projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Staging: keucr: Coding style fixes in scsiglue.c
[deliverable/linux.git] / drivers / staging / keucr / smilsub.c
CommitLineData
126bb03b
AC		 1#include <linux/slab.h>
2#include "usb.h"
3#include "scsiglue.h"
4#include "transport.h"
5//#include "init.h"
6
7//#include "stdlib.h"
8//#include "EUCR6SK.h"
9#include "smcommon.h"
10#include "smil.h"
11
12void _Set_D_SsfdcRdCmd (BYTE);
13void _Set_D_SsfdcRdAddr (BYTE);
14void _Set_D_SsfdcRdChip (void);
15void _Set_D_SsfdcRdStandby (void);
16void _Start_D_SsfdcRdHwECC (void);
17void _Stop_D_SsfdcRdHwECC (void);
18void _Load_D_SsfdcRdHwECC (BYTE);
19void _Set_D_SsfdcWrCmd (BYTE);
20void _Set_D_SsfdcWrAddr (BYTE);
21void _Set_D_SsfdcWrBlock (void);
22void _Set_D_SsfdcWrStandby (void);
23void _Start_D_SsfdcWrHwECC (void);
24void _Load_D_SsfdcWrHwECC (BYTE);
25int _Check_D_SsfdcBusy (WORD);
26int _Check_D_SsfdcStatus (void);
27void _Reset_D_SsfdcErr (void);
28void _Read_D_SsfdcBuf (BYTE *);
29void _Write_D_SsfdcBuf (BYTE *);
30void _Read_D_SsfdcByte (BYTE *);
31void _ReadRedt_D_SsfdcBuf (BYTE *);
32void _WriteRedt_D_SsfdcBuf (BYTE *);
33BYTE _Check_D_DevCode (BYTE);
34
35void _Set_D_ECCdata (BYTE,BYTE *);
36void _Calc_D_ECCdata (BYTE *);
37
38//void SM_ReadDataWithDMA (PFDO_DEVICE_EXTENSION, BYTE *, WORD);
39//void SM_WriteDataWithDMA (PFDO_DEVICE_EXTENSION, BYTE *, WORD);
40//
41struct SSFDCTYPE Ssfdc;
42struct ADDRESS Media;
43struct CIS_AREA CisArea;
44
d8aba9d5 45static BYTE EccBuf[6];
126bb03b 46extern PBYTE SMHostAddr;
126bb03b
AC		 47extern DWORD ErrXDCode;
48
49extern WORD ReadBlock;
50extern WORD WriteBlock;
51
52//KEVENT SM_DMADoneEvent;
53
54#define EVEN 0 // Even Page for 256byte/page
55#define ODD 1 // Odd Page for 256byte/page
56
57
25985edc 58//SmartMedia Redundant buffer data Control Subroutine
126bb03b
AC		 59//----- Check_D_DataBlank() --------------------------------------------
60int Check_D_DataBlank(BYTE *redundant)
61{
62 char i;
63
64 for(i=0; i<REDTSIZE; i++)
65 if (*redundant++!=0xFF)
66 return(ERROR);
67
fb03d4fc 68 return(SMSUCCESS);
126bb03b
AC		 69}
70
71//----- Check_D_FailBlock() --------------------------------------------
72int Check_D_FailBlock(BYTE *redundant)
73{
74 redundant+=REDT_BLOCK;
75
76 if (*redundant==0xFF)
fb03d4fc 77 return(SMSUCCESS);
126bb03b
AC		 78 if (!*redundant)
79 return(ERROR);
2f7cf8d1 80 if (hweight8(*redundant)<7)
126bb03b
AC		 81 return(ERROR);
82
fb03d4fc 83 return(SMSUCCESS);
126bb03b
AC		 84}
85
86//----- Check_D_DataStatus() -------------------------------------------
87int Check_D_DataStatus(BYTE *redundant)
88{
89 redundant+=REDT_DATA;
90
91 if (*redundant==0xFF)
fb03d4fc 92 return(SMSUCCESS);
126bb03b
AC		 93 if (!*redundant)
94 {
95 ErrXDCode = ERR_DataStatus;
96 return(ERROR);
97 }
98 else
99 ErrXDCode = NO_ERROR;
100
2f7cf8d1 101 if (hweight8(*redundant)<5)
126bb03b
AC		 102 return(ERROR);
103
fb03d4fc 104 return(SMSUCCESS);
126bb03b
AC		 105}
106
107//----- Load_D_LogBlockAddr() ------------------------------------------
108int Load_D_LogBlockAddr(BYTE *redundant)
109{
110 WORD addr1,addr2;
111 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
112 //ADDRESS_T bb = (ADDRESS_T) &Media;
113
114 addr1=(WORD)*(redundant+REDT_ADDR1H)*0x0100+(WORD)*(redundant+REDT_ADDR1L);
115 addr2=(WORD)*(redundant+REDT_ADDR2H)*0x0100+(WORD)*(redundant+REDT_ADDR2L);
116
117 if (addr1==addr2)
118 if ((addr1 &0xF000)==0x1000)
fb03d4fc 119 { Media.LogBlock=(addr1 &0x0FFF)/2; return(SMSUCCESS); }
126bb03b 120
2f7cf8d1 121 if (hweight16((WORD)(addr1^addr2))!=0x01) return(ERROR);
126bb03b
AC		 122
123 if ((addr1 &0xF000)==0x1000)
2f7cf8d1 124 if (!(hweight16(addr1) &0x01))
fb03d4fc 125 { Media.LogBlock=(addr1 &0x0FFF)/2; return(SMSUCCESS); }
126bb03b
AC		 126
127 if ((addr2 &0xF000)==0x1000)
2f7cf8d1 128 if (!(hweight16(addr2) &0x01))
fb03d4fc 129 { Media.LogBlock=(addr2 &0x0FFF)/2; return(SMSUCCESS); }
126bb03b
AC		 130
131 return(ERROR);
132}
133
134//----- Clr_D_RedundantData() ------------------------------------------
135void Clr_D_RedundantData(BYTE *redundant)
136{
137 char i;
138
139 for(i=0; i<REDTSIZE; i++)
140 *(redundant+i)=0xFF;
141}
142
143//----- Set_D_LogBlockAddr() -------------------------------------------
144void Set_D_LogBlockAddr(BYTE *redundant)
145{
146 WORD addr;
147
148 *(redundant+REDT_BLOCK)=0xFF;
149 *(redundant+REDT_DATA) =0xFF;
150 addr=Media.LogBlock*2+0x1000;
151
2f7cf8d1 152 if ((hweight16(addr)%2))
126bb03b
AC		 153 addr++;
154
155 *(redundant+REDT_ADDR1H)=*(redundant+REDT_ADDR2H)=(BYTE)(addr/0x0100);
156 *(redundant+REDT_ADDR1L)=*(redundant+REDT_ADDR2L)=(BYTE)addr;
157}
158
159//----- Set_D_FailBlock() ----------------------------------------------
160void Set_D_FailBlock(BYTE *redundant)
161{
162 char i;
163
164 for(i=0; i<REDTSIZE; i++)
165 *redundant++=(BYTE)((i==REDT_BLOCK)?0xF0:0xFF);
166}
167
168//----- Set_D_DataStaus() ----------------------------------------------
169void Set_D_DataStaus(BYTE *redundant)
170{
171 redundant+=REDT_DATA;
172 *redundant=0x00;
173}
174
175//SmartMedia Function Command Subroutine
176// 6250 CMD 6
177//----- Ssfdc_D_Reset() ------------------------------------------------
178void Ssfdc_D_Reset(struct us_data *us)
179{
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;
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}
202
203//----- Ssfdc_D_ReadCisSect() ------------------------------------------
204int Ssfdc_D_ReadCisSect(struct us_data *us, BYTE *buf,BYTE *redundant)
205{
206 BYTE zone,sector;
207 WORD block;
208 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
209 //ADDRESS_T bb = (ADDRESS_T) &Media;
210
211 zone=Media.Zone; block=Media.PhyBlock; sector=Media.Sector;
212 Media.Zone=0;
213 Media.PhyBlock=CisArea.PhyBlock;
214 Media.Sector=CisArea.Sector;
215
216 if (Ssfdc_D_ReadSect(us,buf,redundant))
217 {
218 Media.Zone=zone; Media.PhyBlock=block; Media.Sector=sector;
219 return(ERROR);
220 }
221
222 Media.Zone=zone; Media.PhyBlock=block; Media.Sector=sector;
fb03d4fc 223 return(SMSUCCESS);
126bb03b
AC		 224}
225/*
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
249//----- Ssfdc_D_ReadSect() ---------------------------------------------
250int Ssfdc_D_ReadSect(struct us_data *us, BYTE *buf,BYTE *redundant)
251{
252 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
253 int result;
254 WORD addr;
255
256 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
257 if (result != USB_STOR_XFER_GOOD)
258 {
259 printk("Load SM RW Code Fail !!\n");
260 return USB_STOR_TRANSPORT_ERROR;
261 }
262
263 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
264 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
265
266 // Read sect data
307ae1d3 267 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 268 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
269 bcb->DataTransferLength = 0x200;
270 bcb->Flags = 0x80;
271 bcb->CDB[0] = 0xF1;
272 bcb->CDB[1] = 0x02;
273 bcb->CDB[4] = (BYTE)addr;
274 bcb->CDB[3] = (BYTE)(addr/0x0100);
275 bcb->CDB[2] = Media.Zone/2;
276
277 result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
278 if (result != USB_STOR_XFER_GOOD)
279 return USB_STOR_TRANSPORT_ERROR;
280
281 // Read redundant
307ae1d3 282 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 283 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
284 bcb->DataTransferLength = 0x10;
285 bcb->Flags = 0x80;
286 bcb->CDB[0] = 0xF1;
287 bcb->CDB[1] = 0x03;
288 bcb->CDB[4] = (BYTE)addr;
289 bcb->CDB[3] = (BYTE)(addr/0x0100);
290 bcb->CDB[2] = Media.Zone/2;
291 bcb->CDB[8] = 0;
292 bcb->CDB[9] = 1;
293
294 result = ENE_SendScsiCmd(us, FDIR_READ, redundant, 0);
295 if (result != USB_STOR_XFER_GOOD)
296 return USB_STOR_TRANSPORT_ERROR;
297
298 return USB_STOR_TRANSPORT_GOOD;
299}
300
301//----- Ssfdc_D_ReadBlock() ---------------------------------------------
302int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
303{
304 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
305 int result;
306 WORD addr;
307
308 //printk("Ssfdc_D_ReadBlock\n");
309 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
310 if (result != USB_STOR_XFER_GOOD)
311 {
312 printk("Load SM RW Code Fail !!\n");
313 return USB_STOR_TRANSPORT_ERROR;
314 }
315
316 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
317 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
318
319 // Read sect data
307ae1d3 320 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 321 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
322 bcb->DataTransferLength = 0x200*count;
323 bcb->Flags = 0x80;
324 bcb->CDB[0] = 0xF1;
325 bcb->CDB[1] = 0x02;
326 bcb->CDB[4] = (BYTE)addr;
327 bcb->CDB[3] = (BYTE)(addr/0x0100);
328 bcb->CDB[2] = Media.Zone/2;
329
330 result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
331 if (result != USB_STOR_XFER_GOOD)
332 return USB_STOR_TRANSPORT_ERROR;
333
334 // Read redundant
307ae1d3 335 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 336 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
337 bcb->DataTransferLength = 0x10;
338 bcb->Flags = 0x80;
339 bcb->CDB[0] = 0xF1;
340 bcb->CDB[1] = 0x03;
341 bcb->CDB[4] = (BYTE)addr;
342 bcb->CDB[3] = (BYTE)(addr/0x0100);
343 bcb->CDB[2] = Media.Zone/2;
344 bcb->CDB[8] = 0;
345 bcb->CDB[9] = 1;
346
347 result = ENE_SendScsiCmd(us, FDIR_READ, redundant, 0);
348 if (result != USB_STOR_XFER_GOOD)
349 return USB_STOR_TRANSPORT_ERROR;
350
351 return USB_STOR_TRANSPORT_GOOD;
352}
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);
fb03d4fc 429// return(SMSUCCESS);
126bb03b
AC		 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();
fb03d4fc 452// return(SMSUCCESS);
126bb03b
AC		 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
fb03d4fc 510 return(SMSUCCESS);
126bb03b
AC		 511}
512*/
513//----- Ssfdc_D_CopyBlock() --------------------------------------------
514int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
515{
516 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
517 int result;
518 //PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
519 //NTSTATUS ntStatus;
520 WORD ReadAddr, WriteAddr;
521
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);
525 if (result != USB_STOR_XFER_GOOD)
526 {
527 printk("Load SM RW Code Fail !!\n");
528 return USB_STOR_TRANSPORT_ERROR;
529 }
530
531 ReadAddr = (WORD)Media.Zone*Ssfdc.MaxBlocks+ReadBlock;
532 ReadAddr = ReadAddr*(WORD)Ssfdc.MaxSectors;
533 WriteAddr = (WORD)Media.Zone*Ssfdc.MaxBlocks+WriteBlock;
534 WriteAddr = WriteAddr*(WORD)Ssfdc.MaxSectors;
535
536 // Write sect data
307ae1d3 537 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 538 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
539 bcb->DataTransferLength = 0x200*count;
540 bcb->Flags = 0x00;
541 bcb->CDB[0] = 0xF0;
542 bcb->CDB[1] = 0x08;
543 bcb->CDB[7] = (BYTE)WriteAddr;
544 bcb->CDB[6] = (BYTE)(WriteAddr/0x0100);
545 bcb->CDB[5] = Media.Zone/2;
546 bcb->CDB[8] = *(redundant+REDT_ADDR1H);
547 bcb->CDB[9] = *(redundant+REDT_ADDR1L);
548 bcb->CDB[10] = Media.Sector;
549
550 if (ReadBlock != NO_ASSIGN)
551 {
552 bcb->CDB[4] = (BYTE)ReadAddr;
553 bcb->CDB[3] = (BYTE)(ReadAddr/0x0100);
554 bcb->CDB[2] = Media.Zone/2;
555 }
556 else
557 bcb->CDB[11] = 1;
558
559 result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
560 if (result != USB_STOR_XFER_GOOD)
561 return USB_STOR_TRANSPORT_ERROR;
562
563 return USB_STOR_TRANSPORT_GOOD;
564}
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
fb03d4fc 615 return(SMSUCCESS);
126bb03b
AC		 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//
fb03d4fc 705// return(SMSUCCESS);
126bb03b
AC		 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();
fb03d4fc 730// return(SMSUCCESS);
126bb03b
AC		 731//}
732*/
733//----- Ssfdc_D_WriteSectForCopy() -------------------------------------
734int Ssfdc_D_WriteSectForCopy(struct us_data *us, BYTE *buf, BYTE *redundant)
735{
736 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
737 int result;
738 //PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
739 //NTSTATUS ntStatus;
740 WORD addr;
741
742 //printk("SMILSUB --- Ssfdc_D_WriteSectForCopy\n");
743 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
744 if (result != USB_STOR_XFER_GOOD)
745 {
746 printk("Load SM RW Code Fail !!\n");
747 return USB_STOR_TRANSPORT_ERROR;
748 }
749
750
751 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
752 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
753
754 // Write sect data
307ae1d3 755 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 756 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
757 bcb->DataTransferLength = 0x200;
758 bcb->Flags = 0x00;
759 bcb->CDB[0] = 0xF0;
760 bcb->CDB[1] = 0x04;
761 bcb->CDB[7] = (BYTE)addr;
762 bcb->CDB[6] = (BYTE)(addr/0x0100);
763 bcb->CDB[5] = Media.Zone/2;
859171ca
JP		 764 bcb->CDB[8] = *(redundant+REDT_ADDR1H);
765 bcb->CDB[9] = *(redundant+REDT_ADDR1L);
126bb03b
AC		 766
767 result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
768 if (result != USB_STOR_XFER_GOOD)
769 return USB_STOR_TRANSPORT_ERROR;
770
771 return USB_STOR_TRANSPORT_GOOD;
772}
773
774// 6250 CMD 5
775//----- Ssfdc_D_EraseBlock() -------------------------------------------
776int Ssfdc_D_EraseBlock(struct us_data *us)
777{
778 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
779 int result;
780 WORD addr;
781
782 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
783 if (result != USB_STOR_XFER_GOOD)
784 {
785 printk("Load SM RW Code Fail !!\n");
786 return USB_STOR_TRANSPORT_ERROR;
787 }
788
789 addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
790 addr=addr*(WORD)Ssfdc.MaxSectors;
791
307ae1d3 792 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 793 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
794 bcb->DataTransferLength = 0x200;
795 bcb->Flags = 0x80;
796 bcb->CDB[0] = 0xF2;
797 bcb->CDB[1] = 0x06;
798 bcb->CDB[7] = (BYTE)addr;
799 bcb->CDB[6] = (BYTE)(addr/0x0100);
800 bcb->CDB[5] = Media.Zone/2;
801
802 result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
803 if (result != USB_STOR_XFER_GOOD)
804 return USB_STOR_TRANSPORT_ERROR;
805
806 return USB_STOR_TRANSPORT_GOOD;
807}
808
809// 6250 CMD 2
810//----- Ssfdc_D_ReadRedtData() -----------------------------------------
811int Ssfdc_D_ReadRedtData(struct us_data *us, BYTE *redundant)
812{
813 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
814 int result;
815 WORD addr;
816 BYTE *buf;
817
818 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
819 if (result != USB_STOR_XFER_GOOD)
820 {
821 printk("Load SM RW Code Fail !!\n");
822 return USB_STOR_TRANSPORT_ERROR;
823 }
824
825 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
826 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
827
307ae1d3 828 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 829 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
830 bcb->DataTransferLength = 0x10;
831 bcb->Flags = 0x80;
832 bcb->CDB[0] = 0xF1;
833 bcb->CDB[1] = 0x03;
834 bcb->CDB[4] = (BYTE)addr;
835 bcb->CDB[3] = (BYTE)(addr/0x0100);
836 bcb->CDB[2] = Media.Zone/2;
837 bcb->CDB[8] = 0;
838 bcb->CDB[9] = 1;
839
840 buf = kmalloc(0x10, GFP_KERNEL);
841 //result = ENE_SendScsiCmd(us, FDIR_READ, redundant, 0);
842 result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
843 memcpy(redundant, buf, 0x10);
844 kfree(buf);
845 if (result != USB_STOR_XFER_GOOD)
846 return USB_STOR_TRANSPORT_ERROR;
847
848 return USB_STOR_TRANSPORT_GOOD;
849}
850
851// 6250 CMD 4
852//----- Ssfdc_D_WriteRedtData() ----------------------------------------
853int Ssfdc_D_WriteRedtData(struct us_data *us, BYTE *redundant)
854{
855 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
856 int result;
857 //PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
858 //NTSTATUS ntStatus;
859 WORD addr;
860
861 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
862 if (result != USB_STOR_XFER_GOOD)
863 {
864 printk("Load SM RW Code Fail !!\n");
865 return USB_STOR_TRANSPORT_ERROR;
866 }
867
868 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
869 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
870
307ae1d3 871 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 872 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
873 bcb->DataTransferLength = 0x10;
874 bcb->Flags = 0x80;
875 bcb->CDB[0] = 0xF2;
876 bcb->CDB[1] = 0x05;
877 bcb->CDB[7] = (BYTE)addr;
878 bcb->CDB[6] = (BYTE)(addr/0x0100);
879 bcb->CDB[5] = Media.Zone/2;
880 bcb->CDB[8] = *(redundant+REDT_ADDR1H);
881 bcb->CDB[9] = *(redundant+REDT_ADDR1L);
882
883 result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
884 if (result != USB_STOR_XFER_GOOD)
885 return USB_STOR_TRANSPORT_ERROR;
886
887 return USB_STOR_TRANSPORT_GOOD;
888}
889
890//----- Ssfdc_D_CheckStatus() ------------------------------------------
891int Ssfdc_D_CheckStatus(void)
892{