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