Gitiles
Code Review Sign In
gerrit-public.fairphone.software / kernel / msm / e8e7a2b8ccfdae0d4cb6bd25824bbedcd42da316 / . / drivers / staging / keucr / smilmain.c
blob: 95c688a5c95adfa685c6823b92367122a6291e9c [file] [log] [blame]
Al Cho126bb032010-09-08 00:42:32 -0700[diff] [blame]1#include <linux/slab.h>
2#include "usb.h"
3#include "scsiglue.h"
4#include "smcommon.h"
5#include "smil.h"
6
7int Check_D_LogCHS (WORD *,BYTE *,BYTE *);
8void Initialize_D_Media (void);
9void PowerOff_D_Media (void);
10int Check_D_MediaPower (void);
11int Check_D_MediaExist (void);
12int Check_D_MediaWP (void);
13int Check_D_MediaFmt (struct us_data *);
14int Check_D_MediaFmtForEraseAll (struct us_data *);
15int Conv_D_MediaAddr (struct us_data *, DWORD);
16int Inc_D_MediaAddr (struct us_data *);
17int Check_D_FirstSect (void);
18int Check_D_LastSect (void);
19int Media_D_ReadOneSect (struct us_data *, WORD, BYTE *);
20int Media_D_WriteOneSect (struct us_data *, WORD, BYTE *);
21int Media_D_CopyBlockHead (struct us_data *);
22int Media_D_CopyBlockTail (struct us_data *);
23int Media_D_EraseOneBlock (void);
24int Media_D_EraseAllBlock (void);
25
26int Copy_D_BlockAll (struct us_data *, DWORD);
27int Copy_D_BlockHead (struct us_data *);
28int Copy_D_BlockTail (struct us_data *);
29int Reassign_D_BlockHead (struct us_data *);
30
31int Assign_D_WriteBlock (void);
32int Release_D_ReadBlock (struct us_data *);
33int Release_D_WriteBlock (struct us_data *);
34int Release_D_CopySector (struct us_data *);
35
36int Copy_D_PhyOneSect (struct us_data *);
37int Read_D_PhyOneSect (struct us_data *, WORD, BYTE *);
38int Write_D_PhyOneSect (struct us_data *, WORD, BYTE *);
39int Erase_D_PhyOneBlock (struct us_data *);
40
41int Set_D_PhyFmtValue (struct us_data *);
42int Search_D_CIS (struct us_data *);
43int Make_D_LogTable (struct us_data *);
44void Check_D_BlockIsFull (void);
45
46int MarkFail_D_PhyOneBlock (struct us_data *);
47
48DWORD ErrXDCode;
49DWORD ErrCode;
50//BYTE SectBuf[SECTSIZE];
51BYTE WorkBuf[SECTSIZE];
52BYTE Redundant[REDTSIZE];
53BYTE WorkRedund[REDTSIZE];
54//WORD Log2Phy[MAX_ZONENUM][MAX_LOGBLOCK];
55WORD *Log2Phy[MAX_ZONENUM]; // 128 x 1000, Log2Phy[MAX_ZONENUM][MAX_LOGBLOCK];
56BYTE Assign[MAX_ZONENUM][MAX_BLOCKNUM/8];
57WORD AssignStart[MAX_ZONENUM];
58WORD ReadBlock;
59WORD WriteBlock;
60DWORD MediaChange;
61DWORD SectCopyMode;
62
63extern struct SSFDCTYPE Ssfdc;
64extern struct ADDRESS Media;
65extern struct CIS_AREA CisArea;
66
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300[diff] [blame]67//BIT Control Macro
Al Cho126bb032010-09-08 00:42:32 -0700[diff] [blame]68BYTE BitData[] = { 0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80 } ;
69#define Set_D_Bit(a,b) (a[(BYTE)((b)/8)]|= BitData[(b)%8])
70#define Clr_D_Bit(a,b) (a[(BYTE)((b)/8)]&=~BitData[(b)%8])
71#define Chk_D_Bit(a,b) (a[(BYTE)((b)/8)] & BitData[(b)%8])
72
73//extern PBYTE SMHostAddr;
74extern BYTE IsSSFDCCompliance;
75extern BYTE IsXDCompliance;
76
77
78//
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300[diff] [blame]79////Power Control & Media Exist Check Function
Al Cho126bb032010-09-08 00:42:32 -0700[diff] [blame]80////----- Init_D_SmartMedia() --------------------------------------------
81//int Init_D_SmartMedia(void)
82//{
83// int i;
84//
85// EMCR_Print("Init_D_SmartMedia start\n");
86// for (i=0; i<MAX_ZONENUM; i++)
87// {
88// if (Log2Phy[i]!=NULL)
89// {
90// EMCR_Print("ExFreePool Zone = %x, Addr = %x\n", i, Log2Phy[i]);
91// ExFreePool(Log2Phy[i]);
92// Log2Phy[i] = NULL;
93// }
94// }
95//
96// Initialize_D_Media();
97// return(NO_ERROR);
98//}
99
100//----- SM_FreeMem() -------------------------------------------------
101int SM_FreeMem(void)
102{
103 int i;
104
105 printk("SM_FreeMem start\n");
106 for (i=0; i<MAX_ZONENUM; i++)
107 {
108 if (Log2Phy[i]!=NULL)
109 {
110 printk("Free Zone = %x, Addr = %p\n", i, Log2Phy[i]);
111 kfree(Log2Phy[i]);
112 Log2Phy[i] = NULL;
113 }
114 }
115 return(NO_ERROR);
116}
117
118////----- Pwoff_D_SmartMedia() -------------------------------------------
119//int Pwoff_D_SmartMedia(void)
120//{
121// PowerOff_D_Media();
122// return(NO_ERROR);
123//}
124//
125////----- Check_D_SmartMedia() -------------------------------------------
126//int Check_D_SmartMedia(void)
127//{
128// if (Check_D_MediaExist())
129// return(ErrCode);
130//
131// return(NO_ERROR);
132//}
133//
134////----- Check_D_Parameter() --------------------------------------------
135//int Check_D_Parameter(PFDO_DEVICE_EXTENSION fdoExt,WORD *pcyl,BYTE *phead,BYTE *psect)
136//{
137// if (Check_D_MediaPower())
138// return(ErrCode);
139//
140// if (Check_D_MediaFmt(fdoExt))
141// return(ErrCode);
142//
143// if (Check_D_LogCHS(pcyl,phead,psect))
144// return(ErrCode);
145//
146// return(NO_ERROR);
147//}
148
149//SmartMedia Read/Write/Erase Function
150//----- Media_D_ReadSector() -------------------------------------------
151int Media_D_ReadSector(struct us_data *us, DWORD start,WORD count,BYTE *buf)
152{
153 WORD len, bn;
154
155 //if (Check_D_MediaPower()) ; ¦b 6250 don't care
Joe Perches859171c2010-11-14 19:04:48 -0800[diff] [blame]156 // return(ErrCode);
Al Cho126bb032010-09-08 00:42:32 -0700[diff] [blame]157 //if (Check_D_MediaFmt(fdoExt)) ;
Joe Perches859171c2010-11-14 19:04:48 -0800[diff] [blame]158 // return(ErrCode);
Al Cho126bb032010-09-08 00:42:32 -0700[diff] [blame]159 if (Conv_D_MediaAddr(us, start))
160 return(ErrCode);
161
162 while(1)
163 {
164 len = Ssfdc.MaxSectors - Media.Sector;
165 if (count > len)
166 bn = len;
167 else
168 bn = count;
169 //if (Media_D_ReadOneSect(fdoExt, SectBuf))
170 //if (Media_D_ReadOneSect(fdoExt, count, buf))
171 if (Media_D_ReadOneSect(us, bn, buf))
172 {
173 ErrCode = ERR_EccReadErr;
174 return(ErrCode);
175 }
176
177 Media.Sector += bn;
178 count -= bn;
179
180 if (count<=0)
181 break;
182
183 buf += bn * SECTSIZE;
184
185 if (Inc_D_MediaAddr(us))
186 return(ErrCode);
187 }
188
189 return(NO_ERROR);
190}
191// here
192//----- Media_D_CopySector() ------------------------------------------
193int Media_D_CopySector(struct us_data *us, DWORD start,WORD count,BYTE *buf)
194{
195 //DWORD mode;
196 //int i;
197 WORD len, bn;
198 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
199 //ADDRESS_T bb = (ADDRESS_T) &Media;
200
201 //printk("Media_D_CopySector !!!\n");
202 if (Conv_D_MediaAddr(us, start))
203 return(ErrCode);
204
205 while(1)
206 {
207 if (Assign_D_WriteBlock())
208 return(ERROR);
209
210 len = Ssfdc.MaxSectors - Media.Sector;
211 if (count > len)
212 bn = len;
213 else
214 bn = count;
215
216 //if (Ssfdc_D_CopyBlock(fdoExt,count,buf,Redundant))
217 if (Ssfdc_D_CopyBlock(us,bn,buf,Redundant))
218 {
219 ErrCode = ERR_WriteFault;
220 return(ErrCode);
221 }
222
223 Media.Sector = 0x1F;
224 //if (Release_D_ReadBlock(fdoExt))
225 if (Release_D_CopySector(us))
226 {
227 if (ErrCode==ERR_HwError)
228 {
229 ErrCode = ERR_WriteFault;
230 return(ErrCode);
231 }
232 }
233 count -= bn;
234
235 if (count<=0)
236 break;
237
238 buf += bn * SECTSIZE;
239
240 if (Inc_D_MediaAddr(us))
241 return(ErrCode);
242
243 }
244 return(NO_ERROR);
245}
246
247//----- Release_D_CopySector() ------------------------------------------
248int Release_D_CopySector(struct us_data *us)
249{
250 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
251 //ADDRESS_T bb = (ADDRESS_T) &Media;
252
253 Log2Phy[Media.Zone][Media.LogBlock]=WriteBlock;
254 Media.PhyBlock=ReadBlock;
255
256 if (Media.PhyBlock==NO_ASSIGN)
257 {
258 Media.PhyBlock=WriteBlock;
259 return(SUCCESS);
260 }
261
262 Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock);
263 Media.PhyBlock=WriteBlock;
264
265 return(SUCCESS);
266}
267/*
268//----- Media_D_WriteSector() ------------------------------------------
269int Media_D_WriteSector(PFDO_DEVICE_EXTENSION fdoExt, DWORD start,WORD count,BYTE *buf)
270{
271 int i;
272 WORD len, bn;
273 SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
274 ADDRESS_T bb = (ADDRESS_T) &Media;
275
276 //if (Check_D_MediaPower())
277 // return(ErrCode);
278 //
279 //if (Check_D_MediaFmt(fdoExt))
280 // return(ErrCode);
281 //
282 //if (Check_D_MediaWP())
283 // return(ErrCode);
284
285 if (Conv_D_MediaAddr(fdoExt, start))
286 return(ErrCode);
287
288 //ENE_Print("Media_D_WriteSector --- Sector = %x\n", Media.Sector);
289 if (Check_D_FirstSect())
290 {
291 if (Media_D_CopyBlockHead(fdoExt))
292 {
293 ErrCode = ERR_WriteFault;
294 return(ErrCode);
295 }
296 }
297
298 while(1)
299 {
300 if (!Check_D_FirstSect())
301 {
302 if (Assign_D_WriteBlock())
303 return(ErrCode);
304 }
305
306 len = Ssfdc.MaxSectors - Media.Sector;
307 if (count > len)
308 bn = len;
309 else
310 bn = count;
311 //for(i=0;i<SECTSIZE;i++)
312 // SectBuf[i]=*buf++;
313
314 //if (Media_D_WriteOneSect(fdoExt, SectBuf))
315 if (Media_D_WriteOneSect(fdoExt, bn, buf))
316 {
317 ErrCode = ERR_WriteFault;
318 return(ErrCode);
319 }
320
321 Media.Sector += bn - 1;
322
323 if (!Check_D_LastSect())
324 {
325 if (Release_D_ReadBlock(fdoExt))
326
327 { if (ErrCode==ERR_HwError)
328 {
329 ErrCode = ERR_WriteFault;
330 return(ErrCode);
331 }
332 }
333 }
334
335 count -= bn;
336
337 if (count<=0)
338 break;
339
340 buf += bn * SECTSIZE;
341
342 //if (--count<=0)
343 // break;
344
345 if (Inc_D_MediaAddr(fdoExt))
346 return(ErrCode);
347 }
348
349 if (!Check_D_LastSect())
350 return(NO_ERROR);
351
352 if (Inc_D_MediaAddr(fdoExt))
353 return(ErrCode);
354
355 if (Media_D_CopyBlockTail(fdoExt))
356 {
357 ErrCode = ERR_WriteFault;
358 return(ErrCode);
359 }
360
361 return(NO_ERROR);
362}
363//
364////----- Media_D_EraseBlock() -------------------------------------------
365//int Media_D_EraseBlock(PFDO_DEVICE_EXTENSION fdoExt, DWORD start,WORD count)
366//{
367// if (Check_D_MediaPower())
368// return(ErrCode);
369//
370// if (Check_D_MediaFmt(fdoExt))
371// return(ErrCode);
372//
373// if (Check_D_MediaWP())
374// return(ErrCode);
375//
376// if (Conv_D_MediaAddr(start))
377// return(ErrCode);
378//
379// while(Check_D_FirstSect()) {
380// if (Inc_D_MediaAddr(fdoExt))
381// return(ErrCode);
382//
383// if (--count<=0)
384// return(NO_ERROR);
385// }
386//
387// while(1) {
388// if (!Check_D_LastSect())
389// if (Media_D_EraseOneBlock())
390// if (ErrCode==ERR_HwError)
391// {
392// ErrCode = ERR_WriteFault;
393// return(ErrCode);
394// }
395//
396// if (Inc_D_MediaAddr(fdoExt))
397// return(ErrCode);
398//
399// if (--count<=0)
400// return(NO_ERROR);
401// }
402//}
403//
404////----- Media_D_EraseAll() ---------------------------------------------
405//int Media_D_EraseAll(PFDO_DEVICE_EXTENSION fdoExt)
406//{
407// if (Check_D_MediaPower())
408// return(ErrCode);
409//
410// if (Check_D_MediaFmtForEraseAll(fdoExt))
411// return(ErrCode);
412//
413// if (Check_D_MediaWP())
414// return(ErrCode);
415//
416// if (Media_D_EraseAllBlock())
417// return(ErrCode);
418//
419// return(NO_ERROR);
420//}
421
422//SmartMedia Write Function for One Sector Write Mode
423//----- Media_D_OneSectWriteStart() ------------------------------------
424int Media_D_OneSectWriteStart(PFDO_DEVICE_EXTENSION fdoExt,DWORD start,BYTE *buf)
425{
426// int i;
427// SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
428// ADDRESS_T bb = (ADDRESS_T) &Media;
429//
430// //if (Check_D_MediaPower())
431// // return(ErrCode);
432// //if (Check_D_MediaFmt(fdoExt))
433// // return(ErrCode);
434// //if (Check_D_MediaWP())
435// // return(ErrCode);
436// if (Conv_D_MediaAddr(fdoExt, start))
437// return(ErrCode);
438//
439// if (Check_D_FirstSect())
440// if (Media_D_CopyBlockHead(fdoExt))
441// {
442// ErrCode = ERR_WriteFault;
443// return(ErrCode);
444// }
445//
446// if (!Check_D_FirstSect())
447// if (Assign_D_WriteBlock())
448// return(ErrCode);
449//
450// //for(i=0;i<SECTSIZE;i++)
451// // SectBuf[i]=*buf++;
452//
453// //if (Media_D_WriteOneSect(fdoExt, SectBuf))
454// if (Media_D_WriteOneSect(fdoExt, buf))
455// {
456// ErrCode = ERR_WriteFault;
457// return(ErrCode);
458// }
459//
460// if (!Check_D_LastSect())
461// {
462// if (Release_D_ReadBlock(fdoExt))
463// if (ErrCode==ERR_HwError)
464// {
465// ErrCode = ERR_WriteFault;
466// return(ErrCode);
467// }
468// }
469
470 return(NO_ERROR);
471}
472
473//----- Media_D_OneSectWriteNext() -------------------------------------
474int Media_D_OneSectWriteNext(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf)
475{
476// int i;
477// SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
478// ADDRESS_T bb = (ADDRESS_T) &Media;
479//
480// if (Inc_D_MediaAddr(fdoExt))
481// return(ErrCode);
482//
483// if (!Check_D_FirstSect())
484// if (Assign_D_WriteBlock())
485// return(ErrCode);
486//
487// //for(i=0;i<SECTSIZE;i++)
488// // SectBuf[i]=*buf++;
489//
490// //if (Media_D_WriteOneSect(fdoExt, SectBuf))
491// if (Media_D_WriteOneSect(fdoExt, buf))
492// {
493// ErrCode = ERR_WriteFault;
494// return(ErrCode);
495// }
496//
497// if (!Check_D_LastSect())
498// {
499// if (Release_D_ReadBlock(fdoExt))
500// if (ErrCode==ERR_HwError)
501// {
502// ErrCode = ERR_WriteFault;
503// return(ErrCode);
504// }
505// }
506
507 return(NO_ERROR);
508}
509
510//----- Media_D_OneSectWriteFlush() ------------------------------------
511int Media_D_OneSectWriteFlush(PFDO_DEVICE_EXTENSION fdoExt)
512{
513 if (!Check_D_LastSect())
514 return(NO_ERROR);
515
516 if (Inc_D_MediaAddr(fdoExt))
517 return(ErrCode);
518
519 if (Media_D_CopyBlockTail(fdoExt))
520 {
521 ErrCode = ERR_WriteFault;
522 return(ErrCode);
523 }
524
525 return(NO_ERROR);
526}
527//
528////LED Tern On/Off Subroutine
529////----- SM_EnableLED() -----------------------------------------------
530//void SM_EnableLED(PFDO_DEVICE_EXTENSION fdoExt, BOOLEAN enable)
531//{
532// if (fdoExt->Drive_IsSWLED)
533// {
534// if (enable)
535// Led_D_TernOn();
536// else
537// Led_D_TernOff();
538// }
539//}
540//
541////----- Led_D_TernOn() -------------------------------------------------
542//void Led_D_TernOn(void)
543//{
544// if (Check_D_CardStsChg())
545// MediaChange=ERROR;
546//
547// Cnt_D_LedOn();
548//}
549//
550////----- Led_D_TernOff() ------------------------------------------------
551//void Led_D_TernOff(void)
552//{
553// if (Check_D_CardStsChg())
554// MediaChange=ERROR;
555//
556// Cnt_D_LedOff();
557//}
558//
559////SmartMedia Logical Format Subroutine
560////----- Check_D_LogCHS() -----------------------------------------------
561//int Check_D_LogCHS(WORD *c,BYTE *h,BYTE *s)
562//{
563// switch(Ssfdc.Model) {
564// case SSFDC1MB: *c=125; *h= 4; *s= 4; break;
565// case SSFDC2MB: *c=125; *h= 4; *s= 8; break;
566// case SSFDC4MB: *c=250; *h= 4; *s= 8; break;
567// case SSFDC8MB: *c=250; *h= 4; *s=16; break;
568// case SSFDC16MB: *c=500; *h= 4; *s=16; break;
569// case SSFDC32MB: *c=500; *h= 8; *s=16; break;
570// case SSFDC64MB: *c=500; *h= 8; *s=32; break;
571// case SSFDC128MB: *c=500; *h=16; *s=32; break;
572// default: *c= 0; *h= 0; *s= 0; ErrCode = ERR_NoSmartMedia; return(ERROR);
573// }
574//
575// return(SUCCESS);
576//}
577//
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300[diff] [blame]578////Power Control & Media Exist Check Subroutine
Al Cho126bb032010-09-08 00:42:32 -0700[diff] [blame]579////----- Initialize_D_Media() -------------------------------------------
580//void Initialize_D_Media(void)
581//{
582// ErrCode = NO_ERROR;
583// MediaChange = ERROR;
584// SectCopyMode = COMPLETED;
585// Cnt_D_Reset();
586//}
587//
588////----- PowerOff_D_Media() ---------------------------------------------
589//void PowerOff_D_Media(void)
590//{
591// Cnt_D_PowerOff();
592//}
593//
594////----- Check_D_MediaPower() -------------------------------------------
595//int Check_D_MediaPower(void)
596//{
597// //usleep(56*1024);
598// if (Check_D_CardStsChg())
599// MediaChange = ERROR;
600// //usleep(56*1024);
601// if ((!Check_D_CntPower())&&(!MediaChange)) // ¦³ power & Media ¨S³Q change, «h return success
602// return(SUCCESS);
603// //usleep(56*1024);
604//
605// if (Check_D_CardExist()) // Check if card is not exist, return err
606// {
607// ErrCode = ERR_NoSmartMedia;
608// MediaChange = ERROR;
609// return(ERROR);
610// }
611// //usleep(56*1024);
612// if (Cnt_D_PowerOn())
613// {
614// ErrCode = ERR_NoSmartMedia;
615// MediaChange = ERROR;
616// return(ERROR);
617// }
618// //usleep(56*1024);
619// Ssfdc_D_Reset(fdoExt);
620// //usleep(56*1024);
621// return(SUCCESS);
622//}
623//
624////-----Check_D_MediaExist() --------------------------------------------
625//int Check_D_MediaExist(void)
626//{
627// if (Check_D_CardStsChg())
628// MediaChange = ERROR;
629//
630// if (!Check_D_CardExist())
631// {
632// if (!MediaChange)
633// return(SUCCESS);
634//
635// ErrCode = ERR_ChangedMedia;
636// return(ERROR);
637// }
638//
639// ErrCode = ERR_NoSmartMedia;
640//
641// return(ERROR);
642//}
643//
644////----- Check_D_MediaWP() ----------------------------------------------
645//int Check_D_MediaWP(void)
646//{
647// if (Ssfdc.Attribute &MWP)
648// {
649// ErrCode = ERR_WrtProtect;
650// return(ERROR);
651// }
652//
653// return(SUCCESS);
654//}
655*/
656//SmartMedia Physical Format Test Subroutine
657//----- Check_D_MediaFmt() ---------------------------------------------
658int Check_D_MediaFmt(struct us_data *us)
659{
660 printk("Check_D_MediaFmt\n");
661 //ULONG i,j, result=FALSE, zone,block;
662
663 //usleep(56*1024);
664 if (!MediaChange)
665 return(SUCCESS);
666
667 MediaChange = ERROR;
668 SectCopyMode = COMPLETED;
669
670 //usleep(56*1024);
671 if (Set_D_PhyFmtValue(us))
672 {
673 ErrCode = ERR_UnknownMedia;
674 return(ERROR);
675 }
676
677 //usleep(56*1024);
678 if (Search_D_CIS(us))
679 {
680 ErrCode = ERR_IllegalFmt;
681 return(ERROR);
682 }
683
684
685 MediaChange = SUCCESS;
686 return(SUCCESS);
687}
688/*
689////----- Check_D_BlockIsFull() ----------------------------------
690//void Check_D_BlockIsFull()
691//{
692// ULONG i, block;
693//
694// if (IsXDCompliance || IsSSFDCCompliance)
695// {
696// // If the blocks are full then return write-protect.
697// block = Ssfdc.MaxBlocks/8;
698// for (Media.Zone=0; Media.Zone<Ssfdc.MaxZones; Media.Zone++)
699// {
700// if (Log2Phy[Media.Zone]==NULL)
701// {
702// if (Make_D_LogTable())
703// {
704// ErrCode = ERR_IllegalFmt;
705// return;
706// }
707// }
708//
709// for (i=0; i<block; i++)
710// {
711// if (Assign[Media.Zone][i] != 0xFF)
712// return;
713// }
714// }
715// Ssfdc.Attribute |= WP;
716// }
717//}
718//
719//
720////----- Check_D_MediaFmtForEraseAll() ----------------------------------
721//int Check_D_MediaFmtForEraseAll(PFDO_DEVICE_EXTENSION fdoExt)
722//{
723// MediaChange = ERROR;
724// SectCopyMode = COMPLETED;
725//
726// if (Set_D_PhyFmtValue(fdoExt))
727// {
728// ErrCode = ERR_UnknownMedia;
729// return(ERROR);
730// }
731//
732// if (Search_D_CIS(fdoExt))
733// {
734// ErrCode = ERR_IllegalFmt;
735// return(ERROR);
736// }
737//
738// return(SUCCESS);
739//}
740*/
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300[diff] [blame]741//SmartMedia Physical Address Control Subroutine
Al Cho126bb032010-09-08 00:42:32 -0700[diff] [blame]742//----- Conv_D_MediaAddr() ---------------------------------------------
743int Conv_D_MediaAddr(struct us_data *us, DWORD addr)
744{
745 DWORD temp;
746 //ULONG zz;
747 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
748 //ADDRESS_T bb = (ADDRESS_T) &Media;
749
750 temp = addr/Ssfdc.MaxSectors;
751 Media.Zone = (BYTE) (temp/Ssfdc.MaxLogBlocks);
752
753 if (Log2Phy[Media.Zone]==NULL)
754 {
755 if (Make_D_LogTable(us))
756 {
757 ErrCode = ERR_IllegalFmt;
758 return(ERROR);
759 }
760 }
761
762 Media.Sector = (BYTE) (addr%Ssfdc.MaxSectors);
763 Media.LogBlock = (WORD) (temp%Ssfdc.MaxLogBlocks);
764
765 if (Media.Zone<Ssfdc.MaxZones)
766 {
767 Clr_D_RedundantData(Redundant);
768 Set_D_LogBlockAddr(Redundant);
769 Media.PhyBlock = Log2Phy[Media.Zone][Media.LogBlock];
770 return(SUCCESS);
771 }
772
773 ErrCode = ERR_OutOfLBA;
774 return(ERROR);
775}
776
777//----- Inc_D_MediaAddr() ----------------------------------------------
778int Inc_D_MediaAddr(struct us_data *us)
779{
780 WORD LogBlock = Media.LogBlock;
781 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
782 //ADDRESS_T bb = (ADDRESS_T) &Media;
783
784 if (++Media.Sector<Ssfdc.MaxSectors)
785 return(SUCCESS);
786
787 if (Log2Phy[Media.Zone]==NULL)
788 {
789 if (Make_D_LogTable(us))
790 {
791 ErrCode = ERR_IllegalFmt;
792 return(ERROR);
793 }
794 }
795
796 Media.Sector=0;
797 Media.LogBlock = LogBlock;
798
799 if (++Media.LogBlock<Ssfdc.MaxLogBlocks)
800 {
801 Clr_D_RedundantData(Redundant);
802 Set_D_LogBlockAddr(Redundant);
803 Media.PhyBlock=Log2Phy[Media.Zone][Media.LogBlock];
804 return(SUCCESS);
805 }
806
807 Media.LogBlock=0;
808
809 if (++Media.Zone<Ssfdc.MaxZones)
810 {
811 if (Log2Phy[Media.Zone]==NULL)
812 {
813 if (Make_D_LogTable(us))
814 {
815 ErrCode = ERR_IllegalFmt;
816 return(ERROR);
817 }
818 }
819
820 Media.LogBlock = 0;
821
822 Clr_D_RedundantData(Redundant);
823 Set_D_LogBlockAddr(Redundant);
824 Media.PhyBlock=Log2Phy[Media.Zone][Media.LogBlock];
825 return(SUCCESS);
826 }
827
828 Media.Zone=0;
829 ErrCode = ERR_OutOfLBA;
830
831 return(ERROR);
832}
833/*
834//----- Check_D_FirstSect() --------------------------------------------
835int Check_D_FirstSect(void)
836{
837 SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
838 ADDRESS_T bb = (ADDRESS_T) &Media;
839
840 if (!Media.Sector)
841 return(SUCCESS);
842
843 return(ERROR);
844}
845
846//----- Check_D_LastSect() ---------------------------------------------
847int Check_D_LastSect(void)
848{
849 SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
850 ADDRESS_T bb = (ADDRESS_T) &Media;
851
852 if (Media.Sector<(Ssfdc.MaxSectors-1))
853 return(ERROR);
854
855 return(SUCCESS);
856}
857*/
858//SmartMedia Read/Write Subroutine with Retry
859//----- Media_D_ReadOneSect() ------------------------------------------
860int Media_D_ReadOneSect(struct us_data *us, WORD count, BYTE *buf)
861{
862 DWORD err, retry;
863
864 if (!Read_D_PhyOneSect(us, count, buf))
865 return(SUCCESS);
866 if (ErrCode==ERR_HwError)
867 return(ERROR);
868 if (ErrCode==ERR_DataStatus)
869 return(ERROR);
870
871#ifdef RDERR_REASSIGN
872 if (Ssfdc.Attribute &MWP)
873 {
874 if (ErrCode==ERR_CorReadErr)
875 return(SUCCESS);
876 return(ERROR);
877 }
878
879 err=ErrCode;
880 for(retry=0; retry<2; retry++)
881 {
882 if (Copy_D_BlockAll(us, (err==ERR_EccReadErr)?REQ_FAIL:REQ_ERASE))
883 {
884 if (ErrCode==ERR_HwError)
885 return(ERROR);
886 continue;
887 }
888
889 ErrCode = err;
890 if (ErrCode==ERR_CorReadErr)
891 return(SUCCESS);
892 return(ERROR);
893 }
894
895 MediaChange = ERROR;
896#else
897 if (ErrCode==ERR_CorReadErr) return(SUCCESS);
898#endif
899
900 return(ERROR);
901}
902/*
903//----- Media_D_WriteOneSect() -----------------------------------------
904int Media_D_WriteOneSect(PFDO_DEVICE_EXTENSION fdoExt, WORD count, BYTE *buf)
905{
906 DWORD retry;
907 SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
908 ADDRESS_T bb = (ADDRESS_T) &Media;
909
910 if (!Write_D_PhyOneSect(fdoExt, count, buf))
911 return(SUCCESS);
912 if (ErrCode==ERR_HwError)
913 return(ERROR);
914
915 for(retry=1; retry<2; retry++)
916 {
917 if (Reassign_D_BlockHead(fdoExt))
918 {
919 if (ErrCode==ERR_HwError)
920 return(ERROR);
921 continue;
922 }
923
924 if (!Write_D_PhyOneSect(fdoExt, count, buf))
925 return(SUCCESS);
926 if (ErrCode==ERR_HwError)
927 return(ERROR);
928 }
929
930 if (Release_D_WriteBlock(fdoExt))
931 return(ERROR);
932
933 ErrCode = ERR_WriteFault;
934 MediaChange = ERROR;
935 return(ERROR);
936}
937
938//SmartMedia Data Copy Subroutine with Retry
939//----- Media_D_CopyBlockHead() ----------------------------------------
940int Media_D_CopyBlockHead(PFDO_DEVICE_EXTENSION fdoExt)
941{
942 DWORD retry;
943
944 for(retry=0; retry<2; retry++)
945 {
946 if (!Copy_D_BlockHead(fdoExt))
947 return(SUCCESS);
948 if (ErrCode==ERR_HwError)
949 return(ERROR);
950 }
951
952 MediaChange = ERROR;
953 return(ERROR);
954}
955
956//----- Media_D_CopyBlockTail() ----------------------------------------
957int Media_D_CopyBlockTail(PFDO_DEVICE_EXTENSION fdoExt)
958{
959 DWORD retry;
960
961 if (!Copy_D_BlockTail(fdoExt))
962 return(SUCCESS);
963 if (ErrCode==ERR_HwError)
964 return(ERROR);
965
966 for(retry=1; retry<2; retry++)
967 {
968 if (Reassign_D_BlockHead(fdoExt))
969 {
970 if (ErrCode==ERR_HwError)
971 return(ERROR);
972 continue;
973 }
974
975 if (!Copy_D_BlockTail(fdoExt))
976 return(SUCCESS);
977 if (ErrCode==ERR_HwError)
978 return(ERROR);
979 }
980
981 if (Release_D_WriteBlock(fdoExt))
982 return(ERROR);
983
984 ErrCode = ERR_WriteFault;
985 MediaChange = ERROR;
986 return(ERROR);
987}
988//
989////----- Media_D_EraseOneBlock() ----------------------------------------
990//int Media_D_EraseOneBlock(void)
991//{
992// WORD LogBlock = Media.LogBlock;
993// WORD PhyBlock = Media.PhyBlock;
994// SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
995// ADDRESS_T bb = (ADDRESS_T) &Media;
996//
997// if (Media.PhyBlock==NO_ASSIGN)
998// return(SUCCESS);
999//
1000// if (Log2Phy[Media.Zone]==NULL)
1001// {
1002// if (Make_D_LogTable())
1003// {
1004// ErrCode = ERR_IllegalFmt;
1005// return(ERROR);
1006// }
1007// }
1008// Media.LogBlock = LogBlock;
1009// Media.PhyBlock = PhyBlock;
1010//
1011// Log2Phy[Media.Zone][Media.LogBlock]=NO_ASSIGN;
1012//
1013// if (Erase_D_PhyOneBlock(fdoExt))
1014// {
1015// if (ErrCode==ERR_HwError)
1016// return(ERROR);
1017// if (MarkFail_D_PhyOneBlock())
1018// return(ERROR);
1019//
1020// ErrCode = ERR_WriteFault;
1021// return(ERROR);
1022// }
1023//
1024// Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock);
1025// Media.PhyBlock=NO_ASSIGN;
1026// return(SUCCESS);
1027//}
1028//
1029////SmartMedia Erase Subroutine
1030////----- Media_D_EraseAllBlock() ----------------------------------------
1031//int Media_D_EraseAllBlock(void)
1032//{
1033// WORD cis=0;
1034//
1035// SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1036// ADDRESS_T bb = (ADDRESS_T) &Media;
1037//
1038// MediaChange = ERROR;
1039// Media.Sector = 0;
1040//
1041// for(Media.Zone=0; Media.Zone<Ssfdc.MaxZones; Media.Zone++)
1042// for(Media.PhyBlock=0; Media.PhyBlock<Ssfdc.MaxBlocks; Media.PhyBlock++) {
1043// if (Ssfdc_D_ReadRedtData(Redundant))
1044// {
1045// Ssfdc_D_Reset(fdoExt);
1046// return(ERROR);
1047// }
1048//
1049// Ssfdc_D_Reset(fdoExt);
1050// if (!Check_D_FailBlock(Redundant))
1051// {
1052// if (cis)
1053// {
1054// if (Ssfdc_D_EraseBlock(fdoExt))
1055// {
1056// ErrCode = ERR_HwError;
1057// return(ERROR);
1058// }
1059//
1060// if (Ssfdc_D_CheckStatus())
1061// {
1062// if (MarkFail_D_PhyOneBlock())
1063// return(ERROR);
1064// }
1065//
1066// continue;
1067// }
1068//
1069// if (Media.PhyBlock!=CisArea.PhyBlock)
1070// {
1071// ErrCode = ERR_IllegalFmt;
1072// return(ERROR);
1073// }
1074//
1075// cis++;
1076// }
1077//
1078// }
1079// return(SUCCESS);
1080//}
1081*/
1082//SmartMedia Physical Sector Data Copy Subroutine
1083//----- Copy_D_BlockAll() ----------------------------------------------
1084int Copy_D_BlockAll(struct us_data *us, DWORD mode)
1085{
1086 BYTE sect;
1087 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1088 //ADDRESS_T bb = (ADDRESS_T) &Media;
1089
1090 sect=Media.Sector;
1091
1092 if (Assign_D_WriteBlock())
1093 return(ERROR);
1094 if (mode==REQ_FAIL)
1095 SectCopyMode=REQ_FAIL;
1096
1097 for(Media.Sector=0; Media.Sector<Ssfdc.MaxSectors; Media.Sector++)
1098 {
1099 if (Copy_D_PhyOneSect(us))
1100 {
1101 if (ErrCode==ERR_HwError)
1102 return(ERROR);
1103 if (Release_D_WriteBlock(us))
1104 return(ERROR);
1105
1106 ErrCode = ERR_WriteFault;
1107 Media.PhyBlock=ReadBlock;
1108 Media.Sector=sect;
1109
1110 return(ERROR);
1111 }
1112 }
1113
1114 if (Release_D_ReadBlock(us))
1115 return(ERROR);
1116
1117 Media.PhyBlock=WriteBlock;
1118 Media.Sector=sect;
1119 return(SUCCESS);
1120}
1121/*
1122//----- Copy_D_BlockHead() ---------------------------------------------
1123int Copy_D_BlockHead(PFDO_DEVICE_EXTENSION fdoExt)
1124{
1125 BYTE sect;
1126 SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1127 ADDRESS_T bb = (ADDRESS_T) &Media;
1128
1129 sect=Media.Sector;
1130 if (Assign_D_WriteBlock())
1131 return(ERROR);
1132
1133 for(Media.Sector=0; Media.Sector<sect; Media.Sector++)
1134 {
1135 if (Copy_D_PhyOneSect(fdoExt))
1136 {
1137 if (ErrCode==ERR_HwError)
1138 return(ERROR);
1139 if (Release_D_WriteBlock(fdoExt))
1140 return(ERROR);
1141
1142 ErrCode = ERR_WriteFault;
1143 Media.PhyBlock=ReadBlock;
1144 Media.Sector=sect;
1145
1146 return(ERROR);
1147 }
1148 }
1149
1150 Media.PhyBlock=WriteBlock;
1151 Media.Sector=sect;
1152 return(SUCCESS);
1153}
1154
1155//----- Copy_D_BlockTail() ---------------------------------------------
1156int Copy_D_BlockTail(PFDO_DEVICE_EXTENSION fdoExt)
1157{
1158 BYTE sect;
1159 SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1160 ADDRESS_T bb = (ADDRESS_T) &Media;
1161
1162 for(sect=Media.Sector; Media.Sector<Ssfdc.MaxSectors; Media.Sector++)
1163 {
1164 if (Copy_D_PhyOneSect(fdoExt))
1165 {
1166 if (ErrCode==ERR_HwError)
1167 return(ERROR);
1168
1169 Media.PhyBlock=WriteBlock;
1170 Media.Sector=sect;
1171
1172 return(ERROR);
1173 }
1174 }
1175
1176 if (Release_D_ReadBlock(fdoExt))
1177 return(ERROR);
1178
1179 Media.PhyBlock=WriteBlock;
1180 Media.Sector=sect;
1181 return(SUCCESS);
1182}
1183
1184//----- Reassign_D_BlockHead() -----------------------------------------
1185int Reassign_D_BlockHead(PFDO_DEVICE_EXTENSION fdoExt)
1186{
1187 DWORD mode;
1188 WORD block;
1189 BYTE sect;
1190 SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1191 ADDRESS_T bb = (ADDRESS_T) &Media;
1192
1193 mode=SectCopyMode;
1194 block=ReadBlock;
1195 sect=Media.Sector;
1196
1197 if (Assign_D_WriteBlock())
1198 return(ERROR);
1199
1200 SectCopyMode=REQ_FAIL;
1201
1202 for(Media.Sector=0; Media.Sector<sect; Media.Sector++)
1203 {
1204 if (Copy_D_PhyOneSect(fdoExt))
1205 {
1206 if (ErrCode==ERR_HwError)
1207 return(ERROR);
1208 if (Release_D_WriteBlock(fdoExt))
1209 return(ERROR);
1210
1211 ErrCode = ERR_WriteFault;
1212 SectCopyMode=mode;
1213 WriteBlock=ReadBlock;
1214 ReadBlock=block;
1215 Media.Sector=sect;
1216 Media.PhyBlock=WriteBlock;
1217
1218 return(ERROR);
1219 }
1220 }
1221
1222 if (Release_D_ReadBlock(fdoExt))
1223 return(ERROR);
1224
1225 SectCopyMode=mode;
1226 ReadBlock=block;
1227 Media.Sector=sect;
1228 Media.PhyBlock=WriteBlock;
1229 return(SUCCESS);
1230}
1231*/
1232//SmartMedia Physical Block Assign/Release Subroutine
1233//----- Assign_D_WriteBlock() ------------------------------------------
1234int Assign_D_WriteBlock(void)
1235{
1236 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1237 //ADDRESS_T bb = (ADDRESS_T) &Media;
1238 ReadBlock=Media.PhyBlock;
1239
1240 for(WriteBlock=AssignStart[Media.Zone]; WriteBlock<Ssfdc.MaxBlocks; WriteBlock++)
1241 {
1242 if (!Chk_D_Bit(Assign[Media.Zone],WriteBlock))
1243 {
1244 Set_D_Bit(Assign[Media.Zone],WriteBlock);
1245 AssignStart[Media.Zone]=WriteBlock+1;
1246 Media.PhyBlock=WriteBlock;
1247 SectCopyMode=REQ_ERASE;
1248 //ErrXDCode = NO_ERROR;
1249 return(SUCCESS);
1250 }
1251 }
1252
1253 for(WriteBlock=0; WriteBlock<AssignStart[Media.Zone]; WriteBlock++)
1254 {
1255 if (!Chk_D_Bit(Assign[Media.Zone],WriteBlock))
1256 {
1257 Set_D_Bit(Assign[Media.Zone],WriteBlock);
1258 AssignStart[Media.Zone]=WriteBlock+1;
1259 Media.PhyBlock=WriteBlock;
1260 SectCopyMode=REQ_ERASE;
1261 //ErrXDCode = NO_ERROR;
1262 return(SUCCESS);
1263 }
1264 }
1265
1266 WriteBlock=NO_ASSIGN;
1267 ErrCode = ERR_WriteFault;
1268 // For xD test
1269 //Ssfdc.Attribute |= WP;
1270 //ErrXDCode = ERR_WrtProtect;
1271 return(ERROR);
1272}
1273
1274//----- Release_D_ReadBlock() ------------------------------------------
1275int Release_D_ReadBlock(struct us_data *us)
1276{
1277 DWORD mode;
1278 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1279 //ADDRESS_T bb = (ADDRESS_T) &Media;
1280
1281 mode=SectCopyMode;
1282 SectCopyMode=COMPLETED;
1283
1284 if (mode==COMPLETED)
1285 return(SUCCESS);
1286
1287 Log2Phy[Media.Zone][Media.LogBlock]=WriteBlock;
1288 Media.PhyBlock=ReadBlock;
1289
1290 if (Media.PhyBlock==NO_ASSIGN)
1291 {
1292 Media.PhyBlock=WriteBlock;
1293 return(SUCCESS);
1294 }
1295
1296 if (mode==REQ_ERASE)
1297 {
1298 if (Erase_D_PhyOneBlock(us))
1299 {
1300 if (ErrCode==ERR_HwError) return(ERROR);
1301 if (MarkFail_D_PhyOneBlock(us)) return(ERROR);
1302 }
1303 else
1304 Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock);
1305 }
1306 else if (MarkFail_D_PhyOneBlock(us))
1307 return(ERROR);
1308
1309 Media.PhyBlock=WriteBlock;
1310 return(SUCCESS);
1311}
1312
1313//----- Release_D_WriteBlock() -----------------------------------------
1314int Release_D_WriteBlock(struct us_data *us)
1315{
1316 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1317 //ADDRESS_T bb = (ADDRESS_T) &Media;
1318 SectCopyMode=COMPLETED;
1319 Media.PhyBlock=WriteBlock;
1320
1321 if (MarkFail_D_PhyOneBlock(us))
1322 return(ERROR);
1323
1324 Media.PhyBlock=ReadBlock;
1325 return(SUCCESS);
1326}
1327
1328//SmartMedia Physical Sector Data Copy Subroutine
1329//----- Copy_D_PhyOneSect() --------------------------------------------
1330int Copy_D_PhyOneSect(struct us_data *us)
1331{
1332 int i;
1333 DWORD err, retry;
1334 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1335 //ADDRESS_T bb = (ADDRESS_T) &Media;
1336
1337 //printk("Copy_D_PhyOneSect --- Secotr = %x\n", Media.Sector);
1338 if (ReadBlock!=NO_ASSIGN)
1339 {
1340 Media.PhyBlock=ReadBlock;
1341 for(retry=0; retry<2; retry++)
1342 {
1343 if (retry!=0)
1344 {
1345 Ssfdc_D_Reset(us);
1346 if (Ssfdc_D_ReadCisSect(us,WorkBuf,WorkRedund))
1347 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1348
1349 if (Check_D_CISdata(WorkBuf,WorkRedund))
1350 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1351 }
1352
1353 if (Ssfdc_D_ReadSect(us,WorkBuf,WorkRedund))
1354 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1355 if (Check_D_DataStatus(WorkRedund))
1356 { err=ERROR; break; }
1357 if (!Check_D_ReadError(WorkRedund))
1358 { err=SUCCESS; break; }
1359 if (!Check_D_Correct(WorkBuf,WorkRedund))
1360 { err=SUCCESS; break; }
1361
1362 err=ERROR;
1363 SectCopyMode=REQ_FAIL;
1364 }
1365 }
1366 else
1367 {
1368 err=SUCCESS;
1369 for(i=0; i<SECTSIZE; i++)
1370 WorkBuf[i]=DUMMY_DATA;
1371 Clr_D_RedundantData(WorkRedund);
1372 }
1373
1374 Set_D_LogBlockAddr(WorkRedund);
1375 if (err==ERROR)
1376 {
1377 Set_D_RightECC(WorkRedund);
1378 Set_D_DataStaus(WorkRedund);
1379 }
1380
1381 Media.PhyBlock=WriteBlock;
1382
1383 if (Ssfdc_D_WriteSectForCopy(us, WorkBuf, WorkRedund))
1384 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1385 if (Ssfdc_D_CheckStatus())
1386 { ErrCode = ERR_WriteFault; return(ERROR); }
1387
1388 Media.PhyBlock=ReadBlock;
1389 return(SUCCESS);
1390}
1391
1392//SmartMedia Physical Sector Read/Write/Erase Subroutine
1393//----- Read_D_PhyOneSect() --------------------------------------------
1394int Read_D_PhyOneSect(struct us_data *us, WORD count, BYTE *buf)
1395{
1396 int i;
1397 DWORD retry;
1398 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1399 //ADDRESS_T bb = (ADDRESS_T) &Media;
1400
1401 if (Media.PhyBlock==NO_ASSIGN)
1402 {
1403 for(i=0; i<SECTSIZE; i++)
1404 *buf++=DUMMY_DATA;
1405 return(SUCCESS);
1406 }
1407
1408 for(retry=0; retry<2; retry++)
1409 {
1410 if (retry!=0)
1411 {
1412 Ssfdc_D_Reset(us);
1413
1414 if (Ssfdc_D_ReadCisSect(us,WorkBuf,WorkRedund))
1415 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1416 if (Check_D_CISdata(WorkBuf,WorkRedund))
1417 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1418 }
1419
1420 //if (Ssfdc_D_ReadSect(fdoExt,buf,Redundant))
1421 if (Ssfdc_D_ReadBlock(us,count,buf,Redundant))
1422 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1423 if (Check_D_DataStatus(Redundant))
1424 { ErrCode = ERR_DataStatus; return(ERROR); }
1425
1426 if (!Check_D_ReadError(Redundant))
1427 return(SUCCESS);
1428
1429 if (!Check_D_Correct(buf,Redundant))
1430 { ErrCode = ERR_CorReadErr; return(ERROR); }
1431 }
1432
1433 ErrCode = ERR_EccReadErr;
1434 return(ERROR);
1435}
1436/*
1437//----- Write_D_PhyOneSect() -------------------------------------------
1438int Write_D_PhyOneSect(PFDO_DEVICE_EXTENSION fdoExt, WORD count, BYTE *buf)
1439{
1440 SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1441 ADDRESS_T bb = (ADDRESS_T) &Media;
1442
1443 //if (Ssfdc_D_WriteSect(fdoExt,buf,Redundant))
1444 if (Ssfdc_D_WriteBlock(fdoExt,count,buf,Redundant))
1445 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1446 if (Ssfdc_D_CheckStatus())
1447 { ErrCode = ERR_WriteFault; return(ERROR); }
1448
1449 return(SUCCESS);
1450}
1451*/
1452//----- Erase_D_PhyOneBlock() ------------------------------------------
1453int Erase_D_PhyOneBlock(struct us_data *us)
1454{
1455 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1456 //ADDRESS_T bb = (ADDRESS_T) &Media;
1457
1458 if (Ssfdc_D_EraseBlock(us))
1459 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1460 if (Ssfdc_D_CheckStatus())
1461 { ErrCode = ERR_WriteFault; return(ERROR); }
1462
1463 return(SUCCESS);
1464}
1465
1466//SmartMedia Physical Format Check Local Subroutine
1467//----- Set_D_PhyFmtValue() --------------------------------------------
1468int Set_D_PhyFmtValue(struct us_data *us)
1469{
1470// PPDO_DEVICE_EXTENSION pdoExt;
1471// BYTE idcode[4];
1472// DWORD UserDefData_1, UserDefData_2, Data, mask;
1473//
1474// //if (!fdoExt->ChildDeviceObject) return(ERROR);
1475// //pdoExt = fdoExt->ChildDeviceObject->DeviceExtension;
1476//
1477// Ssfdc_D_ReadID(idcode, READ_ID_1);
1478//
1479 //if (Set_D_SsfdcModel(idcode[1]))
1480 if (Set_D_SsfdcModel(us->SM_DeviceID))
1481 return(ERROR);
1482
1483// //Use Multi-function pin to differentiate SM and xD.
1484// UserDefData_1 = ReadPCIReg(fdoExt->BusID, fdoExt->DevID, fdoExt->FuncID, PCI_REG_USER_DEF) & 0x80;
1485// if (UserDefData_1)
1486// {
1487// if ( READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x80 ) fdoExt->DiskType = DISKTYPE_XD;
1488// if ( READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x40 ) fdoExt->DiskType = DISKTYPE_SM;
1489//
1490// if ( IsXDCompliance && (fdoExt->DiskType == DISKTYPE_XD) )
1491// {
1492// Ssfdc_D_ReadID(idcode, READ_ID_3);
1493// if (idcode[2] != 0xB5)
1494// return(ERROR);
1495// }
1496// }
1497//
1498// //Use GPIO to differentiate SM and xD.
1499// UserDefData_2 = ReadPCIReg(fdoExt->BusID, fdoExt->DevID, fdoExt->FuncID, PCI_REG_USER_DEF) >> 8;
1500// if ( UserDefData_2 )
1501// {
1502// Data = ReadPCIReg(fdoExt->BusID, fdoExt->DevID, 0, 0xAC);
1503//
1504// mask = 1 << (UserDefData_2-1);
1505// // 1 : xD , 0 : SM
1506// if ( Data & mask)
1507// fdoExt->DiskType = DISKTYPE_XD;
1508// else
1509// fdoExt->DiskType = DISKTYPE_SM;
1510//
1511// if ( IsXDCompliance && (fdoExt->DiskType == DISKTYPE_XD) )
1512// {
1513// Ssfdc_D_ReadID(idcode, READ_ID_3);
1514// if (idcode[2] != 0xB5)
1515// return(ERROR);
1516// }
1517// }
1518//
1519// if ( !(UserDefData_1 | UserDefData_2) )
1520// {
1521// // Use UserDefine Register to differentiate SM and xD.
1522// Ssfdc_D_ReadID(idcode, READ_ID_3);
1523//
1524// if (idcode[2] == 0xB5)
1525// fdoExt->DiskType = DISKTYPE_XD;
1526// else
1527// {
1528// if (!IsXDCompliance)
1529// fdoExt->DiskType = DISKTYPE_SM;
1530// else
1531// return(ERROR);
1532// }
1533//
1534// if (fdoExt->UserDef_DiskType == 0x04) fdoExt->DiskType = DISKTYPE_XD;
1535// if (fdoExt->UserDef_DiskType == 0x08) fdoExt->DiskType = DISKTYPE_SM;
1536// }
1537//
1538// if (!fdoExt->UserDef_DisableWP)
1539// {
1540// if (fdoExt->DiskType == DISKTYPE_SM)
1541// {
1542// if (Check_D_SsfdcWP())
1543// Ssfdc.Attribute|=WP;
1544// }
1545// }
1546
1547 return(SUCCESS);
1548}
1549
1550//----- Search_D_CIS() -------------------------------------------------
1551int Search_D_CIS(struct us_data *us)
1552{
1553 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1554 //ADDRESS_T bb = (ADDRESS_T) &Media;
1555
1556 Media.Zone=0; Media.Sector=0;
1557
1558 for (Media.PhyBlock=0; Media.PhyBlock<(Ssfdc.MaxBlocks-Ssfdc.MaxLogBlocks-1); Media.PhyBlock++)
1559 {
1560 if (Ssfdc_D_ReadRedtData(us, Redundant))
1561 {
1562 Ssfdc_D_Reset(us);
1563 return(ERROR);
1564 }
1565
1566 if (!Check_D_FailBlock(Redundant))
1567 break;
1568 }
1569
1570 if (Media.PhyBlock==(Ssfdc.MaxBlocks-Ssfdc.MaxLogBlocks-1))
1571 {
1572 Ssfdc_D_Reset(us);
1573 return(ERROR);
1574 }
1575
1576 while (Media.Sector<CIS_SEARCH_SECT)
1577 {
1578 if (Media.Sector)
1579 {
1580 if (Ssfdc_D_ReadRedtData(us, Redundant))
1581 {
1582 Ssfdc_D_Reset(us);
1583 return(ERROR);
1584 }
1585 }
1586 if (!Check_D_DataStatus(Redundant))
1587 {
1588 if (Ssfdc_D_ReadSect(us,WorkBuf,Redundant))
1589 {
1590 Ssfdc_D_Reset(us);
1591 return(ERROR);
1592 }
1593
1594 if (Check_D_CISdata(WorkBuf,Redundant))
1595 {
1596 Ssfdc_D_Reset(us);
1597 return(ERROR);
1598 }
1599
1600 CisArea.PhyBlock=Media.PhyBlock;
1601 CisArea.Sector=Media.Sector;
1602 Ssfdc_D_Reset(us);
1603 return(SUCCESS);
1604 }
1605
1606 Media.Sector++;
1607 }
1608
1609 Ssfdc_D_Reset(us);
1610 return(ERROR);
1611}
1612
1613//----- Make_D_LogTable() ----------------------------------------------
1614int Make_D_LogTable(struct us_data *us)
1615{
1616 WORD phyblock,logblock;
1617 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1618 //ADDRESS_T bb = (ADDRESS_T) &Media;
1619
1620 if (Log2Phy[Media.Zone]==NULL)
1621 {
1622 Log2Phy[Media.Zone] = kmalloc(MAX_LOGBLOCK*sizeof(WORD), GFP_KERNEL);
1623 //printk("ExAllocatePool Zone = %x, Addr = %x\n", Media.Zone, Log2Phy[Media.Zone]);
1624 if (Log2Phy[Media.Zone]==NULL)
1625 return(ERROR);
1626 }
1627
1628 Media.Sector=0;
1629
1630 //for(Media.Zone=0; Media.Zone<MAX_ZONENUM; Media.Zone++)
1631 //for(Media.Zone=0; Media.Zone<Ssfdc.MaxZones; Media.Zone++)
1632 {
1633 //printk("Make_D_LogTable --- MediaZone = 0x%x\n", Media.Zone);
1634 for(Media.LogBlock=0; Media.LogBlock<Ssfdc.MaxLogBlocks; Media.LogBlock++)
1635 Log2Phy[Media.Zone][Media.LogBlock]=NO_ASSIGN;
1636
1637 for(Media.PhyBlock=0; Media.PhyBlock<(MAX_BLOCKNUM/8); Media.PhyBlock++)
1638 Assign[Media.Zone][Media.PhyBlock]=0x00;
1639
1640 for(Media.PhyBlock=0; Media.PhyBlock<Ssfdc.MaxBlocks; Media.PhyBlock++)
1641 {
1642 if ((!Media.Zone) && (Media.PhyBlock<=CisArea.PhyBlock))
1643 {
1644 Set_D_Bit(Assign[Media.Zone],Media.PhyBlock);
1645 continue;
1646 }
1647
1648 if (Ssfdc_D_ReadRedtData(us, Redundant))
1649 { Ssfdc_D_Reset(us); return(ERROR); }
1650
1651 if (!Check_D_DataBlank(Redundant))
1652 continue;
1653
1654 Set_D_Bit(Assign[Media.Zone],Media.PhyBlock);
1655
1656 if (Check_D_FailBlock(Redundant))
1657 continue;
1658
1659 //if (Check_D_DataStatus(Redundant))
1660 // continue;
1661
1662 if (Load_D_LogBlockAddr(Redundant))
1663 continue;
1664
1665 if (Media.LogBlock>=Ssfdc.MaxLogBlocks)
1666 continue;
1667
1668 if (Log2Phy[Media.Zone][Media.LogBlock]==NO_ASSIGN)
1669 {
1670 Log2Phy[Media.Zone][Media.LogBlock]=Media.PhyBlock;
1671 continue;
1672 }
1673
1674 phyblock = Media.PhyBlock;
1675 logblock = Media.LogBlock;
1676 Media.Sector = (BYTE)(Ssfdc.MaxSectors-1);
1677
1678 if (Ssfdc_D_ReadRedtData(us, Redundant))
1679 { Ssfdc_D_Reset(us); return(ERROR); }
1680
1681 if (!Load_D_LogBlockAddr(Redundant))
1682 {
1683 if (Media.LogBlock==logblock)
1684 {
1685 Media.PhyBlock=Log2Phy[Media.Zone][logblock];
1686
1687 if (Ssfdc_D_ReadRedtData(us, Redundant))
1688 { Ssfdc_D_Reset(us); return(ERROR); }
1689
1690 Media.PhyBlock=phyblock;
1691
1692 if (!Load_D_LogBlockAddr(Redundant))
1693 {
1694 if (Media.LogBlock!=logblock)
1695 {
1696 Media.PhyBlock=Log2Phy[Media.Zone][logblock];
1697 Log2Phy[Media.Zone][logblock]=phyblock;
1698 }
1699 }
1700 else
1701 {
1702 Media.PhyBlock=Log2Phy[Media.Zone][logblock];
1703 Log2Phy[Media.Zone][logblock]=phyblock;
1704 }
1705 }
1706 }
1707
1708 Media.Sector=0;
1709
1710// here Not yet
1711//#ifdef L2P_ERR_ERASE
1712// if (!(Ssfdc.Attribute &MWP))
1713// {
1714// Ssfdc_D_Reset(fdoExt);
1715// if (Ssfdc_D_EraseBlock(fdoExt))
1716// return(ERROR);
1717//
1718// if (Ssfdc_D_CheckStatus())
1719// {
1720// if (MarkFail_D_PhyOneBlock())
1721// return(ERROR);
1722// }
1723// else
1724// Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock);
1725// }
1726//#else
1727// Ssfdc.Attribute|=MWP;
1728//#endif
1729 Media.PhyBlock=phyblock;
1730
1731 } // End for (Media.PhyBlock<Ssfdc.MaxBlocks)
1732
1733 AssignStart[Media.Zone]=0;
1734
1735 } // End for (Media.Zone<MAX_ZONENUM)
1736
1737 Ssfdc_D_Reset(us);
1738 return(SUCCESS);
1739}
1740
1741//----- MarkFail_D_PhyOneBlock() ---------------------------------------
1742int MarkFail_D_PhyOneBlock(struct us_data *us)
1743{
1744 BYTE sect;
1745 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1746 //ADDRESS_T bb = (ADDRESS_T) &Media;
1747
1748 sect=Media.Sector;
1749 Set_D_FailBlock(WorkRedund);
1750 //Ssfdc_D_WriteRedtMode();
1751
1752 for(Media.Sector=0; Media.Sector<Ssfdc.MaxSectors; Media.Sector++)
1753 {
1754 if (Ssfdc_D_WriteRedtData(us, WorkRedund))
1755 {
1756 Ssfdc_D_Reset(us);
1757 Media.Sector = sect;
1758 ErrCode = ERR_HwError;
1759 MediaChange = ERROR;
1760 return(ERROR);
1761 } // NO Status Check
1762 }
1763
1764 Ssfdc_D_Reset(us);
1765 Media.Sector=sect;
1766 return(SUCCESS);
1767}
1768/*
1769//
1770////----- SM_Init() ----------------------------------------------------
1771//void SM_Init(void)
1772//{
1773// _Hw_D_ClrIntCardChg();
1774// _Hw_D_SetIntMask();
1775// // For DMA Interrupt
1776// _Hw_D_ClrDMAIntCardChg();
1777// _Hw_D_SetDMAIntMask();
1778//}
1779//
1780////----- Media_D_EraseAllRedtData() -----------------------------------
1781//int Media_D_EraseAllRedtData(DWORD Index, BOOLEAN CheckBlock)
1782//{
1783// BYTE i;
1784//
1785// if (Check_D_MediaPower())
1786// return(ErrCode);
1787//
1788// if (Check_D_MediaWP())
1789// return(ErrCode);
1790//
1791// for (i=0; i<REDTSIZE; i++)
1792// WorkRedund[i] = 0xFF;
1793//
1794// Media.Zone = (BYTE)Index;
1795// for (Media.PhyBlock=0; Media.PhyBlock<Ssfdc.MaxBlocks; Media.PhyBlock++)
1796// {
1797// if ((!Media.Zone) && (Media.PhyBlock<=CisArea.PhyBlock))
1798// continue;
1799//
1800// if (Ssfdc_D_EraseBlock(fdoExt))
1801// {
1802// ErrCode = ERR_HwError;
1803// return(ERROR);
1804// }
1805//
1806// for(Media.Sector=0; Media.Sector<Ssfdc.MaxSectors; Media.Sector++)
1807// {
1808// Ssfdc_D_WriteRedtMode();
1809//
1810// if (Ssfdc_D_WriteRedtData(WorkRedund))
1811// {
1812// Ssfdc_D_Reset(fdoExt);
1813// ErrCode = ERR_HwError;
1814// MediaChange = ERROR;
1815// return(ERROR);
1816// } // NO Status Check
1817// }
1818//
1819// Ssfdc_D_Reset(fdoExt);
1820// }
1821//
1822// Ssfdc_D_Reset(fdoExt);
1823//
1824// return(SUCCESS);
1825//}
1826//
1827////----- Media_D_GetMediaInfo() ---------------------------------------
1828//DWORD Media_D_GetMediaInfo(PFDO_DEVICE_EXTENSION fdoExt, PIOCTL_MEDIA_INFO_IN pParamIn, PIOCTL_MEDIA_INFO_OUT pParamOut)
1829//{
1830// pParamOut->ErrCode = STATUS_CMD_FAIL;
1831//
1832// Init_D_SmartMedia();
1833//
1834// if (Check_D_MediaPower())
1835// return (ErrCode==ERR_NoSmartMedia) ? STATUS_CMD_NO_MEDIA : STATUS_CMD_FAIL;
1836//
1837// if (Set_D_PhyFmtValue(fdoExt))
1838// return STATUS_CMD_FAIL;
1839//
1840// //usleep(56*1024);
1841// if (Search_D_CIS(fdoExt))
1842// return STATUS_CMD_FAIL;
1843//
1844// if (Check_D_MediaWP())
1845// return STATUS_CMD_MEDIA_WP;
1846//
1847// pParamOut->PageSize = Ssfdc.MaxSectors;
1848// pParamOut->BlockSize = Ssfdc.MaxBlocks;
1849// pParamOut->ZoneSize = Ssfdc.MaxZones;
1850//
1851// return STATUS_CMD_SUCCESS;
1852//}*/