aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/staging/keucr
diff options
context:
space:
mode:
authorRuslan Pisarev <ruslan@rpisarev.org.ua>2011-07-22 07:17:04 -0400
committerGreg Kroah-Hartman <gregkh@suse.de>2011-08-23 17:38:44 -0400
commit74a5e01e40be81db3471bfa606f0f894582045be (patch)
treebc461c1b9c187796bfc699dc5d4343146bf1a164 /drivers/staging/keucr
parent581cd7ee21db5c2a1f991adae8d2d889e79f5cb7 (diff)
Staging: keucr: Remove dead (comment) code in drivers/staging/keucr/smilsub.c
Remove dead (comment) code in drivers/staging/keucr/smilsub.c Signed-off-by: Ruslan Pisarev <ruslan@rpisarev.org.ua> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Diffstat (limited to 'drivers/staging/keucr')
-rw-r--r--drivers/staging/keucr/smilsub.c930
1 files changed, 12 insertions, 918 deletions
diff --git a/drivers/staging/keucr/smilsub.c b/drivers/staging/keucr/smilsub.c
index b315d5f8e19..4fcb7d6f3e9 100644
--- a/drivers/staging/keucr/smilsub.c
+++ b/drivers/staging/keucr/smilsub.c
@@ -2,10 +2,7 @@
2#include "usb.h" 2#include "usb.h"
3#include "scsiglue.h" 3#include "scsiglue.h"
4#include "transport.h" 4#include "transport.h"
5//#include "init.h"
6 5
7//#include "stdlib.h"
8//#include "EUCR6SK.h"
9#include "smcommon.h" 6#include "smcommon.h"
10#include "smil.h" 7#include "smil.h"
11 8
@@ -35,9 +32,7 @@ BYTE _Check_D_DevCode (BYTE);
35void _Set_D_ECCdata (BYTE,BYTE *); 32void _Set_D_ECCdata (BYTE,BYTE *);
36void _Calc_D_ECCdata (BYTE *); 33void _Calc_D_ECCdata (BYTE *);
37 34
38//void SM_ReadDataWithDMA (PFDO_DEVICE_EXTENSION, BYTE *, WORD); 35
39//void SM_WriteDataWithDMA (PFDO_DEVICE_EXTENSION, BYTE *, WORD);
40//
41struct SSFDCTYPE Ssfdc; 36struct SSFDCTYPE Ssfdc;
42struct ADDRESS Media; 37struct ADDRESS Media;
43struct CIS_AREA CisArea; 38struct CIS_AREA CisArea;
@@ -49,7 +44,7 @@ extern DWORD ErrXDCode;
49extern WORD ReadBlock; 44extern WORD ReadBlock;
50extern WORD WriteBlock; 45extern WORD WriteBlock;
51 46
52//KEVENT SM_DMADoneEvent; 47
53 48
54#define EVEN 0 // Even Page for 256byte/page 49#define EVEN 0 // Even Page for 256byte/page
55#define ODD 1 // Odd Page for 256byte/page 50#define ODD 1 // Odd Page for 256byte/page
@@ -108,8 +103,6 @@ int Check_D_DataStatus(BYTE *redundant)
108int Load_D_LogBlockAddr(BYTE *redundant) 103int Load_D_LogBlockAddr(BYTE *redundant)
109{ 104{
110 WORD addr1,addr2; 105 WORD addr1,addr2;
111 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
112 //ADDRESS_T bb = (ADDRESS_T) &Media;
113 106
114 addr1=(WORD)*(redundant+REDT_ADDR1H)*0x0100+(WORD)*(redundant+REDT_ADDR1L); 107 addr1=(WORD)*(redundant+REDT_ADDR1H)*0x0100+(WORD)*(redundant+REDT_ADDR1L);
115 addr2=(WORD)*(redundant+REDT_ADDR2H)*0x0100+(WORD)*(redundant+REDT_ADDR2L); 108 addr2=(WORD)*(redundant+REDT_ADDR2H)*0x0100+(WORD)*(redundant+REDT_ADDR2L);
@@ -177,27 +170,7 @@ void Set_D_DataStaus(BYTE *redundant)
177//----- Ssfdc_D_Reset() ------------------------------------------------ 170//----- Ssfdc_D_Reset() ------------------------------------------------
178void Ssfdc_D_Reset(struct us_data *us) 171void Ssfdc_D_Reset(struct us_data *us)
179{ 172{
180 //NTSTATUS ntStatus = STATUS_SUCCESS;
181 //PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
182 //BYTE buf[0x200];
183
184 //printk("Ssfdc_D_Reset --- But do nothing !!\n");
185 return; 173 return;
186/* RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
187 pBulkCbw->dCBWSignature = CBW_SIGNTURE;
188 pBulkCbw->bCBWLun = CBW_LUN;
189 //pBulkCbw->dCBWDataTransferLength = 0x200;
190 pBulkCbw->bmCBWFlags = 0x80;
191 pBulkCbw->CBWCb[0] = 0xF2;
192 pBulkCbw->CBWCb[1] = 0x07;
193
194 ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_READ, NULL);
195
196 if (!NT_SUCCESS(ntStatus))
197 {
198 ENE_Print("Ssfdc_D_Reset Fail !!\n");
199 //return ntStatus;
200 }*/
201} 174}
202 175
203//----- Ssfdc_D_ReadCisSect() ------------------------------------------ 176//----- Ssfdc_D_ReadCisSect() ------------------------------------------
@@ -205,8 +178,6 @@ int Ssfdc_D_ReadCisSect(struct us_data *us, BYTE *buf,BYTE *redundant)
205{ 178{
206 BYTE zone,sector; 179 BYTE zone,sector;
207 WORD block; 180 WORD block;
208 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
209 //ADDRESS_T bb = (ADDRESS_T) &Media;
210 181
211 zone=Media.Zone; block=Media.PhyBlock; sector=Media.Sector; 182 zone=Media.Zone; block=Media.PhyBlock; sector=Media.Sector;
212 Media.Zone=0; 183 Media.Zone=0;
@@ -222,29 +193,7 @@ int Ssfdc_D_ReadCisSect(struct us_data *us, BYTE *buf,BYTE *redundant)
222 Media.Zone=zone; Media.PhyBlock=block; Media.Sector=sector; 193 Media.Zone=zone; Media.PhyBlock=block; Media.Sector=sector;
223 return(SMSUCCESS); 194 return(SMSUCCESS);
224} 195}
225/* 196
226////----- Ssfdc_D_WriteRedtMode() ----------------------------------------
227//void Ssfdc_D_WriteRedtMode(void)
228//{
229// _Set_D_SsfdcRdCmd (RST_CHIP);
230// _Check_D_SsfdcBusy (BUSY_RESET);
231// _Set_D_SsfdcRdCmd (READ_REDT);
232// _Check_D_SsfdcBusy (BUSY_READ);
233// _Set_D_SsfdcRdStandby ();
234//}
235//
236////----- Ssfdc_D_ReadID() -----------------------------------------------
237//void Ssfdc_D_ReadID(BYTE *buf, BYTE ReadID)
238//{
239// _Set_D_SsfdcRdCmd (ReadID);
240// _Set_D_SsfdcRdChip ();
241// _Read_D_SsfdcByte (buf++);
242// _Read_D_SsfdcByte (buf++);
243// _Read_D_SsfdcByte (buf++);
244// _Read_D_SsfdcByte (buf);
245// _Set_D_SsfdcRdStandby ();
246//}
247*/
248// 6250 CMD 1 197// 6250 CMD 1
249//----- Ssfdc_D_ReadSect() --------------------------------------------- 198//----- Ssfdc_D_ReadSect() ---------------------------------------------
250int Ssfdc_D_ReadSect(struct us_data *us, BYTE *buf,BYTE *redundant) 199int Ssfdc_D_ReadSect(struct us_data *us, BYTE *buf,BYTE *redundant)
@@ -305,7 +254,6 @@ int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
305 int result; 254 int result;
306 WORD addr; 255 WORD addr;
307 256
308 //printk("Ssfdc_D_ReadBlock\n");
309 result = ENE_LoadBinCode(us, SM_RW_PATTERN); 257 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
310 if (result != USB_STOR_XFER_GOOD) 258 if (result != USB_STOR_XFER_GOOD)
311 { 259 {
@@ -350,177 +298,15 @@ int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
350 298
351 return USB_STOR_TRANSPORT_GOOD; 299 return USB_STOR_TRANSPORT_GOOD;
352} 300}
353/*
354////----- Ssfdc_D_ReadSect_DMA() ---------------------------------------------
355//int Ssfdc_D_ReadSect_DMA(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
356//{
357// WORD SectByteCount, addr;
358// DWORD Buffer[4];
359// WORD len;
360//
361// if (!_Hw_D_ChkCardIn())
362// return(ERROR);
363// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
364// addr=addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
365// // cycle starting address
366// SM_STARTADDR_LSB = 0x00;
367// SM_STARTADDR_IISB = (BYTE)addr;
368// SM_STARTADDR_IIISB = (BYTE)(addr/0x0100);
369// SM_STARTADDR_MSB = Media.Zone/2;
370//
371// //Sector byte count = 0x200(DMA)
372// SectByteCount = 0x20f;
373// SM_BYTECNT_LO = (BYTE)SectByteCount;
374// SM_CMD_CTRL3 = (SM_CMD_CTRL3 & 0xFC) | (BYTE)(SectByteCount/0x0100);
375// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
376// SM_FIFO_CTRL = (SM_APB08_MASK | SM_DMAEN_MASK | SM_DMA_UPSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
377// else
378// SM_FIFO_CTRL = (SM_APB32_MASK | SM_DMAEN_MASK | SM_DMA_UPSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
379//
380// _Hw_D_EccRdReset();
381// _Hw_D_EccRdStart();
382//
383// SM_CMD_CTRL1 = (SM_CMD_READ_1);
384// SM_CMD_CTRL1 = (SM_CMD_READ_1 | SM_CMD_START_BIT);
385//
386// SectByteCount = 0x1ff;
387// //SM_ReadDataWithDMA(fdoExt, buf, SectByteCount);
388// //_ReadRedt_D_SsfdcBuf(redundant);
389// len = 0x1000 - ((WORD)(buf) & 0x0FFF);
390// if (len < 0x200)
391// {
392// SM_ReadDataWithDMA(fdoExt, buf, len-1);
393// SM_ReadDataWithDMA(fdoExt, buf+len, SectByteCount-len);
394// //ENE_Print("Read DMA !!! buf1 = %p, len = %x, buf2 = %p\n", buf, len, buf+len);
395// }
396// else
397// SM_ReadDataWithDMA(fdoExt, buf, SectByteCount);
398//
399// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
400// {
401// _ReadRedt_D_SsfdcBuf(redundant);
402// }
403// else
404// {
405// Buffer[0] = READ_PORT_DWORD(SM_REG_DATA);
406// Buffer[1] = READ_PORT_DWORD(SM_REG_DATA);
407// Buffer[2] = READ_PORT_DWORD(SM_REG_DATA);
408// Buffer[3] = READ_PORT_DWORD(SM_REG_DATA);
409// memcpy(redundant, Buffer, 0x10);
410// }
411//
412// while ( _Hw_D_ChkCardIn() )
413// {
414// if((READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x10))
415// {
416// WRITE_PORT_BYTE(SM_REG_INT_STATUS, 0x10);
417// break;
418// }
419// }
420// _Hw_D_EccRdStop();
421// _Hw_D_SetRdStandby();
422// _Load_D_SsfdcRdHwECC(EVEN);
423//
424// _Calc_D_ECCdata(buf);
425// _Set_D_SsfdcRdStandby();
426//
427// if (!_Hw_D_ChkCardIn())
428// return(ERROR);
429// return(SMSUCCESS);
430//}
431//
432////----- Ssfdc_D_ReadSect_PIO() ---------------------------------------------
433//int Ssfdc_D_ReadSect_PIO(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
434//{
435// _Set_D_SsfdcRdCmd(READ);
436// _Set_D_SsfdcRdAddr(EVEN);
437//
438// if (_Check_D_SsfdcBusy(BUSY_READ))
439// { _Reset_D_SsfdcErr(); return(ERROR); }
440//
441// _Start_D_SsfdcRdHwECC();
442// _Read_D_SsfdcBuf(buf);
443// _Stop_D_SsfdcRdHwECC();
444// _ReadRedt_D_SsfdcBuf(redundant);
445// _Load_D_SsfdcRdHwECC(EVEN);
446//
447// if (_Check_D_SsfdcBusy(BUSY_READ))
448// { _Reset_D_SsfdcErr(); return(ERROR); }
449//
450// _Calc_D_ECCdata(buf);
451// _Set_D_SsfdcRdStandby();
452// return(SMSUCCESS);
453//}
454
455// 6250 CMD 3
456//----- Ssfdc_D_WriteSect() --------------------------------------------
457int Ssfdc_D_WriteSect(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
458{
459 PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
460 NTSTATUS ntStatus;
461 WORD addr;
462
463 //ENE_Print("SMILSUB --- Ssfdc_D_WriteSect\n");
464 ENE_LoadBinCode(fdoExt, SM_RW_PATTERN);
465
466 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
467 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
468
469 // Write sect data
470 RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
471 pBulkCbw->dCBWSignature = CBW_SIGNTURE;
472 pBulkCbw->bCBWLun = CBW_LUN;
473 pBulkCbw->dCBWDataTransferLength = 0x200;
474 pBulkCbw->bmCBWFlags = 0x00;
475 pBulkCbw->CBWCb[0] = 0xF0;
476 pBulkCbw->CBWCb[1] = 0x04;
477 //pBulkCbw->CBWCb[4] = (BYTE)addr;
478 //pBulkCbw->CBWCb[3] = (BYTE)(addr/0x0100);
479 //pBulkCbw->CBWCb[2] = Media.Zone/2;
480 //pBulkCbw->CBWCb[5] = *(redundant+REDT_ADDR1H);
481 //pBulkCbw->CBWCb[6] = *(redundant+REDT_ADDR1L);
482 pBulkCbw->CBWCb[7] = (BYTE)addr;
483 pBulkCbw->CBWCb[6] = (BYTE)(addr/0x0100);
484 pBulkCbw->CBWCb[5] = Media.Zone/2;
485 pBulkCbw->CBWCb[8] = *(redundant+REDT_ADDR1H);
486 pBulkCbw->CBWCb[9] = *(redundant+REDT_ADDR1L);
487
488 ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_WRITE, buf);
489
490 if (!NT_SUCCESS(ntStatus))
491 return(ERROR);
492
493// // For Test
494// {
495// BYTE bf[0x200], rdd[0x10];
496// ULONG i;
497//
498// RtlZeroMemory(bf, 0x200);
499// RtlZeroMemory(rdd, 0x10);
500// ntStatus = SM_ReadBlock(fdoExt, bf, rdd);
501// for (i=0; i<0x200; i++)
502// {
503// if (buf[i] != bf[i])
504// ENE_Print("buf[%x] = %x, bf[%x] = %x\n", buf, bf);
505// }
506// if (!NT_SUCCESS(ntStatus))
507// ENE_Print("Error\n");
508// }
509 301
510 return(SMSUCCESS); 302
511}
512*/
513//----- Ssfdc_D_CopyBlock() -------------------------------------------- 303//----- Ssfdc_D_CopyBlock() --------------------------------------------
514int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant) 304int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
515{ 305{
516 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 306 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
517 int result; 307 int result;
518 //PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
519 //NTSTATUS ntStatus;
520 WORD ReadAddr, WriteAddr; 308 WORD ReadAddr, WriteAddr;
521 309
522 //printk("Ssfdc_D_WriteSect --- ZONE = %x, ReadBlock = %x, WriteBlock = %x\n", Media.Zone, ReadBlock, WriteBlock);
523
524 result = ENE_LoadBinCode(us, SM_RW_PATTERN); 310 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
525 if (result != USB_STOR_XFER_GOOD) 311 if (result != USB_STOR_XFER_GOOD)
526 { 312 {
@@ -562,184 +348,14 @@ int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
562 348
563 return USB_STOR_TRANSPORT_GOOD; 349 return USB_STOR_TRANSPORT_GOOD;
564} 350}
565/*
566//----- Ssfdc_D_WriteBlock() --------------------------------------------
567int Ssfdc_D_WriteBlock(PFDO_DEVICE_EXTENSION fdoExt, WORD count, BYTE *buf,BYTE *redundant)
568{
569 PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
570 NTSTATUS ntStatus;
571 WORD addr;
572
573 //ENE_Print("SMILSUB --- Ssfdc_D_WriteSect\n");
574 ENE_LoadBinCode(fdoExt, SM_RW_PATTERN);
575
576 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
577 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
578
579 // Write sect data
580 RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
581 pBulkCbw->dCBWSignature = CBW_SIGNTURE;
582 pBulkCbw->bCBWLun = CBW_LUN;
583 pBulkCbw->dCBWDataTransferLength = 0x200*count;
584 pBulkCbw->bmCBWFlags = 0x00;
585 pBulkCbw->CBWCb[0] = 0xF0;
586 pBulkCbw->CBWCb[1] = 0x04;
587 pBulkCbw->CBWCb[7] = (BYTE)addr;
588 pBulkCbw->CBWCb[6] = (BYTE)(addr/0x0100);
589 pBulkCbw->CBWCb[5] = Media.Zone/2;
590 pBulkCbw->CBWCb[8] = *(redundant+REDT_ADDR1H);
591 pBulkCbw->CBWCb[9] = *(redundant+REDT_ADDR1L);
592
593 ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_WRITE, buf);
594
595 if (!NT_SUCCESS(ntStatus))
596 return(ERROR);
597
598// // For Test
599// {
600// BYTE bf[0x200], rdd[0x10];
601// ULONG i;
602//
603// RtlZeroMemory(bf, 0x200);
604// RtlZeroMemory(rdd, 0x10);
605// ntStatus = SM_ReadBlock(fdoExt, bf, rdd);
606// for (i=0; i<0x200; i++)
607// {
608// if (buf[i] != bf[i])
609// ENE_Print("buf[%x] = %x, bf[%x] = %x\n", buf, bf);
610// }
611// if (!NT_SUCCESS(ntStatus))
612// ENE_Print("Error\n");
613// }
614 351
615 return(SMSUCCESS);
616}
617//
618////----- Ssfdc_D_WriteSect_DMA() --------------------------------------------
619//int Ssfdc_D_WriteSect_DMA(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
620//{
621// WORD SectByteCount, addr;
622// DWORD Buffer[4];
623// WORD len;
624//
625// if (!_Hw_D_ChkCardIn())
626// return(ERROR);
627// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
628// addr=addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
629// // cycle starting address
630// SM_STARTADDR_LSB = 0x00;
631// SM_STARTADDR_IISB = (BYTE)addr;
632// SM_STARTADDR_IIISB = (BYTE)(addr/0x0100);
633// SM_STARTADDR_MSB = Media.Zone/2;
634//
635// //Sector byte count (DMA)
636// SectByteCount = 0x20f;
637// SM_BYTECNT_LO = (BYTE)SectByteCount;
638// SM_CMD_CTRL3 = (SM_CMD_CTRL3 & 0xFC) | 0x20 | (BYTE)(SectByteCount/0x0100);
639// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
640// SM_FIFO_CTRL = (SM_APB08_MASK | SM_DMAEN_MASK | SM_DMA_DOWNSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
641// else
642// SM_FIFO_CTRL = (SM_APB32_MASK | SM_DMAEN_MASK | SM_DMA_DOWNSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
643//
644// _Hw_D_EccRdReset();
645// _Hw_D_EccRdStart();
646//
647// SM_CMD_CTRL1 = SM_CMD_PAGPRGM_TRUE;
648// SM_CMD_CTRL1 = (SM_CMD_PAGPRGM_TRUE | SM_CMD_START_BIT);
649//
650// SectByteCount = 0x1ff;
651// //SM_WriteDataWithDMA(fdoExt, buf, SectByteCount);
652// //_WriteRedt_D_SsfdcBuf(redundant);
653// len = 0x1000 - ((WORD)(buf) & 0x0FFF);
654// if (len < 0x200)
655// {
656// SM_WriteDataWithDMA(fdoExt, buf, len-1);
657// SM_WriteDataWithDMA(fdoExt, buf+len, SectByteCount-len);
658// //ENE_Print("Read DMA !!! buf1 = %p, len = %x, buf2 = %p\n", buf, len, buf+len);
659// }
660// else
661// SM_WriteDataWithDMA(fdoExt, buf, SectByteCount);
662//
663// //T1 = (ULONGLONG)buf & 0xFFFFFFFFFFFFF000;
664// //T2 = ((ULONGLONG)buf + 0x1FF) & 0xFFFFFFFFFFFFF000;
665// //if (T1 != T2)
666// // ENE_Print("Ssfdc_D_WriteSect_DMA !!! buf = %p, T1 = %p, T2 = %p\n", buf, T1, T2);
667// //if (T2-T1)
668// //{
669// // l1 = (WORD)(T2 - (ULONGLONG)buf);
670// // SM_WriteDataWithDMA(fdoExt, buf, l1-1);
671// // SM_WriteDataWithDMA(fdoExt, (PBYTE)T2, SectByteCount-l1);
672// //}
673// //else
674// // SM_WriteDataWithDMA(fdoExt, buf, SectByteCount);
675//
676// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
677// {
678// _WriteRedt_D_SsfdcBuf(redundant);
679// }
680// else
681// {
682// memcpy(Buffer, redundant, 0x10);
683// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[0]);
684// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[1]);
685// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[2]);
686// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[3]);
687// }
688//
689// while ( _Hw_D_ChkCardIn() )
690// {
691// if ((READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x10))
692// {
693// WRITE_PORT_BYTE(SM_REG_INT_STATUS, 0x10);
694// break;
695// }
696// }
697// _Hw_D_EccRdStop();
698// _Hw_D_SetRdStandby();
699//
700// _Set_D_SsfdcWrStandby();
701// _Set_D_SsfdcRdStandby();
702// if (!_Hw_D_ChkCardIn())
703// return(ERROR);
704//
705// return(SMSUCCESS);
706//}
707//
708////----- Ssfdc_D_WriteSect_PIO() --------------------------------------------
709//int Ssfdc_D_WriteSect_PIO(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
710//{
711// _Calc_D_ECCdata(buf);
712// _Set_D_SsfdcWrCmd(WRDATA);
713// _Set_D_SsfdcWrAddr(EVEN);
714// _Start_D_SsfdcWrHwECC();
715//
716// _Write_D_SsfdcBuf(buf);
717//
718// _Load_D_SsfdcWrHwECC(EVEN);
719// _Set_D_ECCdata(EVEN,redundant);
720//
721// _WriteRedt_D_SsfdcBuf(redundant);
722//
723// _Set_D_SsfdcWrCmd(WRITE);
724//
725// if (_Check_D_SsfdcBusy(BUSY_PROG))
726// { _Reset_D_SsfdcErr(); return(ERROR); }
727//
728// _Set_D_SsfdcWrStandby();
729// _Set_D_SsfdcRdStandby();
730// return(SMSUCCESS);
731//}
732*/
733//----- Ssfdc_D_WriteSectForCopy() ------------------------------------- 352//----- Ssfdc_D_WriteSectForCopy() -------------------------------------
734int Ssfdc_D_WriteSectForCopy(struct us_data *us, BYTE *buf, BYTE *redundant) 353int Ssfdc_D_WriteSectForCopy(struct us_data *us, BYTE *buf, BYTE *redundant)
735{ 354{
736 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 355 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
737 int result; 356 int result;
738 //PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
739 //NTSTATUS ntStatus;
740 WORD addr; 357 WORD addr;
741 358
742 //printk("SMILSUB --- Ssfdc_D_WriteSectForCopy\n");
743 result = ENE_LoadBinCode(us, SM_RW_PATTERN); 359 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
744 if (result != USB_STOR_XFER_GOOD) 360 if (result != USB_STOR_XFER_GOOD)
745 { 361 {
@@ -838,7 +454,6 @@ int Ssfdc_D_ReadRedtData(struct us_data *us, BYTE *redundant)
838 bcb->CDB[9] = 1; 454 bcb->CDB[9] = 1;
839 455
840 buf = kmalloc(0x10, GFP_KERNEL); 456 buf = kmalloc(0x10, GFP_KERNEL);
841 //result = ENE_SendScsiCmd(us, FDIR_READ, redundant, 0);
842 result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0); 457 result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
843 memcpy(redundant, buf, 0x10); 458 memcpy(redundant, buf, 0x10);
844 kfree(buf); 459 kfree(buf);
@@ -854,8 +469,6 @@ int Ssfdc_D_WriteRedtData(struct us_data *us, BYTE *redundant)
854{ 469{
855 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 470 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
856 int result; 471 int result;
857 //PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
858 //NTSTATUS ntStatus;
859 WORD addr; 472 WORD addr;
860 473
861 result = ENE_LoadBinCode(us, SM_RW_PATTERN); 474 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
@@ -890,347 +503,11 @@ int Ssfdc_D_WriteRedtData(struct us_data *us, BYTE *redundant)
890//----- Ssfdc_D_CheckStatus() ------------------------------------------ 503//----- Ssfdc_D_CheckStatus() ------------------------------------------
891int Ssfdc_D_CheckStatus(void) 504int Ssfdc_D_CheckStatus(void)
892{ 505{
893 // Driver ¤£°µ
894 return(SMSUCCESS); 506 return(SMSUCCESS);
895 //_Set_D_SsfdcRdCmd(RDSTATUS);
896 //
897 //if (_Check_D_SsfdcStatus())
898 //{ _Set_D_SsfdcRdStandby(); return(ERROR); }
899 //
900 //_Set_D_SsfdcRdStandby();
901 //return(SMSUCCESS);
902} 507}
903/* 508
904////NAND Memory (SmartMedia) Control Subroutine for Read Data 509
905////----- _Set_D_SsfdcRdCmd() -------------------------------------------- 510
906//void _Set_D_SsfdcRdCmd(BYTE cmd)
907//{
908// _Hw_D_SetRdCmd();
909// _Hw_D_OutData(cmd);
910// _Hw_D_SetRdData();
911//}
912//
913////----- _Set_D_SsfdcRdAddr() -------------------------------------------
914//void _Set_D_SsfdcRdAddr(BYTE add)
915//{
916// WORD addr;
917// SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
918// ADDRESS_T bb = (ADDRESS_T) &Media;
919//
920// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
921// addr=addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
922//
923// //if ((Ssfdc.Attribute &MPS)==PS256) // for 256byte/page
924// // addr=addr*2+(WORD)add;
925//
926// _Hw_D_SetRdAddr();
927// _Hw_D_OutData(0x00);
928// _Hw_D_OutData((BYTE)addr);
929// _Hw_D_OutData((BYTE)(addr/0x0100));
930//
931// if ((Ssfdc.Attribute &MADC)==AD4CYC)
932// _Hw_D_OutData((BYTE)(Media.Zone/2)); // Patch
933//
934// _Hw_D_SetRdData();
935//}
936//
937////----- _Set_D_SsfdcRdChip() -------------------------------------------
938//void _Set_D_SsfdcRdChip(void)
939//{
940// _Hw_D_SetRdAddr();
941// _Hw_D_OutData(0x00);
942// _Hw_D_SetRdData();
943//}
944//
945////----- _Set_D_SsfdcRdStandby() ----------------------------------------
946//void _Set_D_SsfdcRdStandby(void)
947//{
948// _Hw_D_SetRdStandby();
949//}
950//
951////----- _Start_D_SsfdcRdHwECC() ----------------------------------------
952//void _Start_D_SsfdcRdHwECC(void)
953//{
954//#ifdef HW_ECC_SUPPORTED
955// _Hw_D_EccRdReset();
956// _Hw_D_InData();
957// _Hw_D_EccRdStart();
958//#endif
959//}
960//
961////----- _Stop_D_SsfdcRdHwECC() -----------------------------------------
962//void _Stop_D_SsfdcRdHwECC(void)
963//{
964//#ifdef HW_ECC_SUPPORTED
965// _Hw_D_EccRdStop();
966//#endif
967//}
968//
969////----- _Load_D_SsfdcRdHwECC() -----------------------------------------
970//void _Load_D_SsfdcRdHwECC(BYTE add)
971//{
972//#ifdef HW_ECC_SUPPORTED
973// _Hw_D_EccRdRead();
974// //if (!(add==ODD && (Ssfdc.Attribute &MPS)==PS256))
975// {
976// EccBuf[0]=_Hw_D_InData();
977// EccBuf[1]=_Hw_D_InData();
978// EccBuf[2]=_Hw_D_InData();
979// }
980//
981// //if (!(add==EVEN && (Ssfdc.Attribute &MPS)==PS256))
982// {
983// EccBuf[3]=_Hw_D_InData();
984// EccBuf[4]=_Hw_D_InData();
985// EccBuf[5]=_Hw_D_InData();
986// }
987//
988// _Hw_D_EccRdStop();
989//#endif
990//}
991//
992////NAND Memory (SmartMedia) Control Subroutine for Write Data
993//
994////----- _Set_D_SsfdcWrCmd() -----------------------------------------
995//void _Set_D_SsfdcWrCmd(BYTE cmd)
996//{
997// _Hw_D_SetWrCmd();
998// _Hw_D_OutData(cmd);
999// _Hw_D_SetWrData();
1000//}
1001//
1002////----- _Set_D_SsfdcWrAddr() -----------------------------------------
1003//void _Set_D_SsfdcWrAddr(BYTE add)
1004//{
1005// WORD addr;
1006// SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1007// ADDRESS_T bb = (ADDRESS_T) &Media;
1008//
1009// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
1010// addr=addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
1011//
1012// //if ((Ssfdc.Attribute &MPS)==PS256) // for 256byte/page
1013// // addr=addr*2+(WORD)add;
1014//
1015// _Hw_D_SetWrAddr();
1016// _Hw_D_OutData(0x00);
1017// _Hw_D_OutData((BYTE)addr);
1018// _Hw_D_OutData((BYTE)(addr/0x0100));
1019//
1020// if ((Ssfdc.Attribute &MADC)==AD4CYC)
1021// _Hw_D_OutData((BYTE)(Media.Zone/2)); // Patch
1022//
1023// _Hw_D_SetWrData();
1024//}
1025//
1026////----- _Set_D_SsfdcWrBlock() -----------------------------------------
1027//void _Set_D_SsfdcWrBlock(void)
1028//{
1029// WORD addr;
1030// SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1031// ADDRESS_T bb = (ADDRESS_T) &Media;
1032//
1033// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
1034// addr=addr*(WORD)Ssfdc.MaxSectors;
1035//
1036// //if ((Ssfdc.Attribute &MPS)==PS256) // for 256byte/page
1037// // addr=addr*2;
1038//
1039// _Hw_D_SetWrAddr();
1040// _Hw_D_OutData((BYTE)addr);
1041// _Hw_D_OutData((BYTE)(addr/0x0100));
1042//
1043// if ((Ssfdc.Attribute &MADC)==AD4CYC)
1044// _Hw_D_OutData((BYTE)(Media.Zone/2)); // Patch
1045//
1046// _Hw_D_SetWrData();
1047//}
1048//
1049////----- _Set_D_SsfdcWrStandby() -----------------------------------------
1050//void _Set_D_SsfdcWrStandby(void)
1051//{
1052// _Hw_D_SetWrStandby();
1053//}
1054//
1055////----- _Start_D_SsfdcWrHwECC() -----------------------------------------
1056//void _Start_D_SsfdcWrHwECC(void)
1057//{
1058//#ifdef HW_ECC_SUPPORTED
1059// _Hw_D_EccWrReset();
1060// _Hw_D_InData();
1061// _Hw_D_EccWrStart();
1062//#endif
1063//}
1064//
1065////----- _Load_D_SsfdcWrHwECC() -----------------------------------------
1066//void _Load_D_SsfdcWrHwECC(BYTE add)
1067//{
1068//#ifdef HW_ECC_SUPPORTED
1069// _Hw_D_EccWrRead();
1070// //if (!(add==ODD && (Ssfdc.Attribute &MPS)==PS256))
1071// {
1072// EccBuf[0]=_Hw_D_InData();
1073// EccBuf[1]=_Hw_D_InData();
1074// EccBuf[2]=_Hw_D_InData();
1075// }
1076//
1077// //if (!(add==EVEN && (Ssfdc.Attribute &MPS)==PS256))
1078// {
1079// EccBuf[3]=_Hw_D_InData();
1080// EccBuf[4]=_Hw_D_InData();
1081// EccBuf[5]=_Hw_D_InData();
1082// }
1083//
1084// _Hw_D_EccWrStop();
1085//#endif
1086//}
1087//
1088////NAND Memory (SmartMedia) Control Subroutine
1089////----- _Check_D_SsfdcBusy() -------------------------------------------
1090//int _Check_D_SsfdcBusy(WORD time)
1091//{
1092// WORD count = 0;
1093//
1094// do {
1095// if (!_Hw_D_ChkBusy())
1096// return(SMSUCCESS);
1097// EDelay(100);
1098// count++;
1099// } while (count<=time);
1100//
1101// return(ERROR);
1102//}
1103//
1104////----- _Check_D_SsfdcStatus() -----------------------------------------
1105//int _Check_D_SsfdcStatus(void)
1106//{
1107// if (_Hw_D_InData() & WR_FAIL)
1108// return(ERROR);
1109//
1110// return(SMSUCCESS);
1111//}
1112//
1113//// For 712
1114////----- _Reset_D_SsfdcErr() -----------------------------------------
1115//void _Reset_D_SsfdcErr(void)
1116//{
1117// WORD count = 0;
1118//
1119// _Hw_D_SetRdCmd();
1120// _Hw_D_OutData(RST_CHIP);
1121// _Hw_D_SetRdData();
1122//
1123// do {
1124// if (!_Hw_D_ChkBusy())
1125// break;
1126// EDelay(100);
1127// count++;
1128// } while (count<=BUSY_RESET);
1129//
1130// _Hw_D_SetRdStandby();
1131//}
1132//
1133////NAND Memory (SmartMedia) Buffer Data Xfer Subroutine
1134////----- SM_ReadDataWithDMA() -----------------------------------------
1135//void SM_ReadDataWithDMA(PFDO_DEVICE_EXTENSION fdoExt, BYTE *databuf, WORD SectByteCount)
1136//{
1137// PHYSICAL_ADDRESS Addr;
1138// LARGE_INTEGER ptimeout ;
1139//
1140// KeClearEvent(&fdoExt->SM_DMADoneEvent);
1141//
1142// Addr = MmGetPhysicalAddress(databuf);
1143//
1144// WRITE_PORT_DWORD(SM_DMA_ADDR_REG, (DWORD)Addr.LowPart);
1145// WRITE_PORT_BYTE(SM_DMA_DATA_CTRL, 0);
1146// WRITE_PORT_WORD(SM_DMA_BYTE_COUNT_REG, SectByteCount);
1147//
1148// while ( _Hw_D_ChkCardIn() )
1149// {
1150// if ((READ_PORT_BYTE(SM_REG_FIFO_STATUS) & 0x80))
1151// break;
1152// }
1153// if (!_Hw_D_ChkCardIn()) return;
1154// WRITE_PORT_BYTE(SM_DMA_DATA_CTRL, 0x01);
1155//
1156// ptimeout.QuadPart = 2000 * (-10000); // 2 sec
1157// KeWaitForSingleObject(&fdoExt->SM_DMADoneEvent, Executive, KernelMode, FALSE, &ptimeout);
1158// _Hw_D_SetDMAIntMask();
1159//}
1160//
1161////----- SM_WriteDataWithDMA() -----------------------------------------
1162//void SM_WriteDataWithDMA(PFDO_DEVICE_EXTENSION fdoExt, BYTE *databuf, WORD SectByteCount)
1163//{
1164// PHYSICAL_ADDRESS Addr;
1165// LARGE_INTEGER ptimeout ;
1166//
1167// KeClearEvent(&fdoExt->SM_DMADoneEvent);
1168//
1169// Addr = MmGetPhysicalAddress(databuf);
1170//
1171// WRITE_PORT_DWORD(SM_DMA_ADDR_REG, (DWORD)Addr.LowPart);
1172// WRITE_PORT_BYTE(SM_DMA_DATA_CTRL, 2);
1173// WRITE_PORT_WORD(SM_DMA_BYTE_COUNT_REG, SectByteCount);
1174//
1175// while ( _Hw_D_ChkCardIn() )
1176// {
1177// if ((READ_PORT_BYTE(SM_REG_FIFO_STATUS) & 0x40))
1178// break;
1179// }
1180// if (!_Hw_D_ChkCardIn()) return;
1181// WRITE_PORT_BYTE(SM_DMA_DATA_CTRL, 0x03);
1182//
1183// ptimeout.QuadPart = 2000 * (-10000); // 2 sec
1184// KeWaitForSingleObject(&fdoExt->SM_DMADoneEvent, Executive, KernelMode, FALSE, &ptimeout);
1185// _Hw_D_SetDMAIntMask();
1186//}
1187//
1188////----- _Read_D_SsfdcBuf() -----------------------------------------
1189//void _Read_D_SsfdcBuf(BYTE *databuf)
1190//{
1191// int i;
1192//
1193// //for(i=0x0000;i<(((Ssfdc.Attribute &MPS)==PS256)?0x0100:0x0200);i++)
1194// for(i=0; i<0x200; i++)
1195// *databuf++ =_Hw_D_InData();
1196//}
1197//
1198////----- _Write_D_SsfdcBuf() -----------------------------------------
1199//void _Write_D_SsfdcBuf(BYTE *databuf)
1200//{
1201// int i;
1202//
1203// //for(i=0x0000;i<(((Ssfdc.Attribute &MPS)==PS256)?0x0100:0x0200);i++)
1204// for(i=0; i<0x200; i++)
1205// _Hw_D_OutData(*databuf++);
1206//}
1207//
1208////----- _Read_D_SsfdcByte() -----------------------------------------
1209//void _Read_D_SsfdcByte(BYTE *databuf)
1210//{
1211// *databuf=(BYTE)_Hw_D_InData();
1212//}
1213//
1214////----- _ReadRedt_D_SsfdcBuf() -----------------------------------------
1215//void _ReadRedt_D_SsfdcBuf(BYTE *redundant)
1216//{
1217// char i;
1218//
1219// //for(i=0x00;i<(((Ssfdc.Attribute &MPS)==PS256)?0x08:0x10);i++)
1220// for(i=0; i<0x10; i++)
1221// redundant[i] =_Hw_D_InData();
1222//}
1223//
1224////----- _WriteRedt_D_SsfdcBuf() -----------------------------------------
1225//void _WriteRedt_D_SsfdcBuf(BYTE *redundant)
1226//{
1227// char i;
1228//
1229// //for(i=0x00;i<(((Ssfdc.Attribute &MPS)==PS256)?0x08:0x10);i++)
1230// for(i=0; i<0x10; i++)
1231// _Hw_D_OutData(*redundant++);
1232//}
1233*/
1234//SmartMedia ID Code Check & Mode Set Subroutine 511//SmartMedia ID Code Check & Mode Set Subroutine
1235//----- Set_D_SsfdcModel() --------------------------------------------- 512//----- Set_D_SsfdcModel() ---------------------------------------------
1236int Set_D_SsfdcModel(BYTE dcode) 513int Set_D_SsfdcModel(BYTE dcode)
@@ -1364,118 +641,10 @@ BYTE _Check_D_DevCode(BYTE dcode)
1364 default: return(NOSSFDC); 641 default: return(NOSSFDC);
1365 } 642 }
1366} 643}
1367/* 644
1368////SmartMedia Power Control Subroutine 645
1369////----- Cnt_D_Reset() ---------------------------------------------- 646
1370//void Cnt_D_Reset(void) 647
1371//{
1372// _Hw_D_LedOff();
1373// _Hw_D_SetRdStandby();
1374// _Hw_D_VccOff();
1375//}
1376//
1377////----- Cnt_D_PowerOn() ----------------------------------------------
1378//int Cnt_D_PowerOn(void)
1379//{
1380// // No support 5V.
1381// _Hw_D_EnableVcc3VOn(); // Set SM_REG_CTRL_5 Reg. to 3V
1382// _Hw_D_VccOn();
1383// _Hw_D_SetRdStandby();
1384// _Wait_D_Timer(TIME_PON);
1385//
1386// if (_Hw_D_ChkPower())
1387// {
1388// _Hw_D_EnableOB(); // Set SM_REG_CTRL_5 Reg. to 0x83
1389// return(SMSUCCESS);
1390// }
1391//
1392// _Hw_D_SetVccOff();
1393// return(ERROR);
1394//}
1395//
1396////----- Cnt_D_PowerOff() ----------------------------------------------
1397//void Cnt_D_PowerOff(void)
1398//{
1399// _Hw_D_SetRdStandby();
1400// _Hw_D_SetVccOff();
1401// _Hw_D_VccOff();
1402//}
1403//
1404////----- Cnt_D_LedOn() ----------------------------------------------
1405//void Cnt_D_LedOn(void)
1406//{
1407// _Hw_D_LedOn();
1408//}
1409//
1410////----- Cnt_D_LedOff() ----------------------------------------------
1411//void Cnt_D_LedOff(void)
1412//{
1413// _Hw_D_LedOff();
1414//}
1415//
1416////----- Check_D_CntPower() ----------------------------------------------
1417//int Check_D_CntPower(void)
1418//{
1419// if (_Hw_D_ChkPower())
1420// return(SMSUCCESS); // Power On
1421//
1422// return(ERROR); // Power Off
1423//}
1424//
1425////----- Check_D_CardExist() ----------------------------------------------
1426//int Check_D_CardExist(void)
1427//{
1428// char i,j,k;
1429//
1430// if (!_Hw_D_ChkStatus()) // Not Status Change
1431// if (_Hw_D_ChkCardIn())
1432// return(SMSUCCESS); // Card exist in Slot
1433//
1434// for(i=0,j=0,k=0; i<16; i++) {
1435// if (_Hw_D_ChkCardIn()) // Status Change
1436// {
1437// j++; k=0;
1438// }
1439// else
1440// {
1441// j=0; k++;
1442// }
1443//
1444// if (j>3)
1445// return(SMSUCCESS); // Card exist in Slot
1446// if (k>3)
1447// return(ERROR); // NO Card exist in Slot
1448//
1449// _Wait_D_Timer(TIME_CDCHK);
1450// }
1451//
1452// return(ERROR);
1453//}
1454//
1455////----- Check_D_CardStsChg() ----------------------------------------------
1456//int Check_D_CardStsChg(void)
1457//{
1458// if (_Hw_D_ChkStatus())
1459// return(ERROR); // Status Change
1460//
1461// return(SMSUCCESS); // Not Status Change
1462//}
1463//
1464////----- Check_D_SsfdcWP() ----------------------------------------------
1465//int Check_D_SsfdcWP(void)
1466//{ // ERROR: WP, SMSUCCESS: Not WP
1467// char i;
1468//
1469// for(i=0; i<8; i++) {
1470// if (_Hw_D_ChkWP())
1471// return(ERROR);
1472// _Wait_D_Timer(TIME_WPCHK);
1473// }
1474//
1475// return(SMSUCCESS);
1476//}
1477//
1478*/
1479//SmartMedia ECC Control Subroutine 648//SmartMedia ECC Control Subroutine
1480//----- Check_D_ReadError() ---------------------------------------------- 649//----- Check_D_ReadError() ----------------------------------------------
1481int Check_D_ReadError(BYTE *redundant) 650int Check_D_ReadError(BYTE *redundant)
@@ -1521,81 +690,6 @@ void Set_D_RightECC(BYTE *redundant)
1521{ 690{
1522 // Driver ¤£°µ ECC Check 691 // Driver ¤£°µ ECC Check
1523 return; 692 return;
1524 //StringCopy((char *)(redundant+0x0D),(char *)EccBuf,3);
1525 //StringCopy((char *)(redundant+0x08),(char *)(EccBuf+0x03),3);
1526} 693}
1527/*
1528////----- _Calc_D_ECCdata() ----------------------------------------------
1529//void _Calc_D_ECCdata(BYTE *buf)
1530//{
1531//#ifdef HW_ECC_SUPPORTED
1532//#else
1533// _Calculate_D_SwECC(buf,EccBuf);
1534// buf+=0x0100;
1535// _Calculate_D_SwECC(buf,EccBuf+0x03);
1536//#endif
1537//}
1538//
1539////----- _Set_D_ECCdata() ----------------------------------------------
1540//void _Set_D_ECCdata(BYTE add,BYTE *redundant)
1541//{
1542// //if (add==EVEN && (Ssfdc.Attribute &MPS)==PS256)
1543// // return;
1544//
1545// // for 256byte/page
1546// StringCopy((char *)(redundant+0x0D),(char *)EccBuf,3);
1547// StringCopy((char *)(redundant+0x08),(char *)(EccBuf+0x03),3);
1548//}
1549*/
1550
1551/*
1552//----- SM_ReadBlock() ---------------------------------------------
1553int SM_ReadBlock(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
1554{
1555 PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
1556 NTSTATUS ntStatus;
1557 WORD addr;
1558
1559 ENE_LoadBinCode(fdoExt, SM_RW_PATTERN);
1560
1561 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
1562 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
1563
1564 // Read sect data
1565 RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
1566 pBulkCbw->dCBWSignature = CBW_SIGNTURE;
1567 pBulkCbw->bCBWLun = CBW_LUN;
1568 pBulkCbw->dCBWDataTransferLength = 0x200;
1569 pBulkCbw->bmCBWFlags = 0x80;
1570 pBulkCbw->CBWCb[0] = 0xF1;
1571 pBulkCbw->CBWCb[1] = 0x02;
1572 pBulkCbw->CBWCb[4] = (BYTE)addr;
1573 pBulkCbw->CBWCb[3] = (BYTE)(addr/0x0100);
1574 pBulkCbw->CBWCb[2] = Media.Zone/2;
1575
1576 ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_READ, buf);
1577
1578 if (!NT_SUCCESS(ntStatus))
1579 return(ERROR);
1580
1581 // Read redundant
1582 RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
1583 pBulkCbw->dCBWSignature = CBW_SIGNTURE;
1584 pBulkCbw->bCBWLun = CBW_LUN;
1585 pBulkCbw->dCBWDataTransferLength = 0x10;
1586 pBulkCbw->bmCBWFlags = 0x80;
1587 pBulkCbw->CBWCb[0] = 0xF1;
1588 pBulkCbw->CBWCb[1] = 0x03;
1589 pBulkCbw->CBWCb[4] = (BYTE)addr;
1590 pBulkCbw->CBWCb[3] = (BYTE)(addr/0x0100);
1591 pBulkCbw->CBWCb[2] = Media.Zone/2;
1592 pBulkCbw->CBWCb[5] = 0;
1593 pBulkCbw->CBWCb[6] = 1;
1594
1595 ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_READ, redundant);
1596
1597 if (!NT_SUCCESS(ntStatus))
1598 return(ERROR);
1599 694
1600 return(SMSUCCESS); 695
1601}*/
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-21 23:17:18 -0400