projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix common misspellings
[linux-block.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
45BYTE EccBuf[6];
46extern PBYTE SMHostAddr;
47extern BYTE IsSSFDCCompliance;
48extern BYTE IsXDCompliance;
49extern DWORD ErrXDCode;
50
51extern WORD ReadBlock;
52extern WORD WriteBlock;
53
54//KEVENT SM_DMADoneEvent;
55
56#define EVEN 0 // Even Page for 256byte/page
57#define ODD 1 // Odd Page for 256byte/page
58
59
25985edc 60//SmartMedia Redundant buffer data Control Subroutine
126bb03b
AC		 61//----- Check_D_DataBlank() --------------------------------------------
62int Check_D_DataBlank(BYTE *redundant)
63{
64 char i;
65
66 for(i=0; i<REDTSIZE; i++)
67 if (*redundant++!=0xFF)
68 return(ERROR);
69
70 return(SUCCESS);
71}
72
73//----- Check_D_FailBlock() --------------------------------------------
74int Check_D_FailBlock(BYTE *redundant)
75{
76 redundant+=REDT_BLOCK;
77
78 if (*redundant==0xFF)
79 return(SUCCESS);
80 if (!*redundant)
81 return(ERROR);
2f7cf8d1 82 if (hweight8(*redundant)<7)
126bb03b
AC		 83 return(ERROR);
84
85 return(SUCCESS);
86}
87
88//----- Check_D_DataStatus() -------------------------------------------
89int Check_D_DataStatus(BYTE *redundant)
90{
91 redundant+=REDT_DATA;
92
93 if (*redundant==0xFF)
94 return(SUCCESS);
95 if (!*redundant)
96 {
97 ErrXDCode = ERR_DataStatus;
98 return(ERROR);
99 }
100 else
101 ErrXDCode = NO_ERROR;
102
2f7cf8d1 103 if (hweight8(*redundant)<5)
126bb03b
AC		 104 return(ERROR);
105
106 return(SUCCESS);
107}
108
109//----- Load_D_LogBlockAddr() ------------------------------------------
110int Load_D_LogBlockAddr(BYTE *redundant)
111{
112 WORD addr1,addr2;
113 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
114 //ADDRESS_T bb = (ADDRESS_T) &Media;
115
116 addr1=(WORD)*(redundant+REDT_ADDR1H)*0x0100+(WORD)*(redundant+REDT_ADDR1L);
117 addr2=(WORD)*(redundant+REDT_ADDR2H)*0x0100+(WORD)*(redundant+REDT_ADDR2L);
118
119 if (addr1==addr2)
120 if ((addr1 &0xF000)==0x1000)
121 { Media.LogBlock=(addr1 &0x0FFF)/2; return(SUCCESS); }
122
2f7cf8d1 123 if (hweight16((WORD)(addr1^addr2))!=0x01) return(ERROR);
126bb03b
AC		 124
125 if ((addr1 &0xF000)==0x1000)
2f7cf8d1 126 if (!(hweight16(addr1) &0x01))
126bb03b
AC		 127 { Media.LogBlock=(addr1 &0x0FFF)/2; return(SUCCESS); }
128
129 if ((addr2 &0xF000)==0x1000)
2f7cf8d1 130 if (!(hweight16(addr2) &0x01))
126bb03b
AC		 131 { Media.LogBlock=(addr2 &0x0FFF)/2; return(SUCCESS); }
132
133 return(ERROR);
134}
135
136//----- Clr_D_RedundantData() ------------------------------------------
137void Clr_D_RedundantData(BYTE *redundant)
138{
139 char i;
140
141 for(i=0; i<REDTSIZE; i++)
142 *(redundant+i)=0xFF;
143}
144
145//----- Set_D_LogBlockAddr() -------------------------------------------
146void Set_D_LogBlockAddr(BYTE *redundant)
147{
148 WORD addr;
149
150 *(redundant+REDT_BLOCK)=0xFF;
151 *(redundant+REDT_DATA) =0xFF;
152 addr=Media.LogBlock*2+0x1000;
153
2f7cf8d1 154 if ((hweight16(addr)%2))
126bb03b
AC		 155 addr++;
156
157 *(redundant+REDT_ADDR1H)=*(redundant+REDT_ADDR2H)=(BYTE)(addr/0x0100);
158 *(redundant+REDT_ADDR1L)=*(redundant+REDT_ADDR2L)=(BYTE)addr;
159}
160
161//----- Set_D_FailBlock() ----------------------------------------------
162void Set_D_FailBlock(BYTE *redundant)
163{
164 char i;
165
166 for(i=0; i<REDTSIZE; i++)
167 *redundant++=(BYTE)((i==REDT_BLOCK)?0xF0:0xFF);
168}
169
170//----- Set_D_DataStaus() ----------------------------------------------
171void Set_D_DataStaus(BYTE *redundant)
172{
173 redundant+=REDT_DATA;
174 *redundant=0x00;
175}
176
177//SmartMedia Function Command Subroutine
178// 6250 CMD 6
179//----- Ssfdc_D_Reset() ------------------------------------------------
180void Ssfdc_D_Reset(struct us_data *us)
181{
182 //NTSTATUS ntStatus = STATUS_SUCCESS;
183 //PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
184 //BYTE buf[0x200];
185
186 //printk("Ssfdc_D_Reset --- But do nothing !!\n");
187 return;
188/* RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
189 pBulkCbw->dCBWSignature = CBW_SIGNTURE;
190 pBulkCbw->bCBWLun = CBW_LUN;
191 //pBulkCbw->dCBWDataTransferLength = 0x200;
192 pBulkCbw->bmCBWFlags = 0x80;
193 pBulkCbw->CBWCb[0] = 0xF2;
194 pBulkCbw->CBWCb[1] = 0x07;
195
196 ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_READ, NULL);
197
198 if (!NT_SUCCESS(ntStatus))
199 {
200 ENE_Print("Ssfdc_D_Reset Fail !!\n");
201 //return ntStatus;
202 }*/
203}
204
205//----- Ssfdc_D_ReadCisSect() ------------------------------------------
206int Ssfdc_D_ReadCisSect(struct us_data *us, BYTE *buf,BYTE *redundant)
207{
208 BYTE zone,sector;
209 WORD block;
210 //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
211 //ADDRESS_T bb = (ADDRESS_T) &Media;
212
213 zone=Media.Zone; block=Media.PhyBlock; sector=Media.Sector;
214 Media.Zone=0;
215 Media.PhyBlock=CisArea.PhyBlock;
216 Media.Sector=CisArea.Sector;
217
218 if (Ssfdc_D_ReadSect(us,buf,redundant))
219 {
220 Media.Zone=zone; Media.PhyBlock=block; Media.Sector=sector;
221 return(ERROR);
222 }
223
224 Media.Zone=zone; Media.PhyBlock=block; Media.Sector=sector;
225 return(SUCCESS);
226}
227/*
228////----- Ssfdc_D_WriteRedtMode() ----------------------------------------
229//void Ssfdc_D_WriteRedtMode(void)
230//{
231// _Set_D_SsfdcRdCmd (RST_CHIP);
232// _Check_D_SsfdcBusy (BUSY_RESET);
233// _Set_D_SsfdcRdCmd (READ_REDT);
234// _Check_D_SsfdcBusy (BUSY_READ);
235// _Set_D_SsfdcRdStandby ();
236//}
237//
238////----- Ssfdc_D_ReadID() -----------------------------------------------
239//void Ssfdc_D_ReadID(BYTE *buf, BYTE ReadID)
240//{
241// _Set_D_SsfdcRdCmd (ReadID);
242// _Set_D_SsfdcRdChip ();
243// _Read_D_SsfdcByte (buf++);
244// _Read_D_SsfdcByte (buf++);
245// _Read_D_SsfdcByte (buf++);
246// _Read_D_SsfdcByte (buf);
247// _Set_D_SsfdcRdStandby ();
248//}
249*/
250// 6250 CMD 1
251//----- Ssfdc_D_ReadSect() ---------------------------------------------
252int Ssfdc_D_ReadSect(struct us_data *us, BYTE *buf,BYTE *redundant)
253{
254 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
255 int result;
256 WORD addr;
257
258 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
259 if (result != USB_STOR_XFER_GOOD)
260 {
261 printk("Load SM RW Code Fail !!\n");
262 return USB_STOR_TRANSPORT_ERROR;
263 }
264
265 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
266 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
267
268 // Read sect data
307ae1d3 269 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 270 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
271 bcb->DataTransferLength = 0x200;
272 bcb->Flags = 0x80;
273 bcb->CDB[0] = 0xF1;
274 bcb->CDB[1] = 0x02;
275 bcb->CDB[4] = (BYTE)addr;
276 bcb->CDB[3] = (BYTE)(addr/0x0100);
277 bcb->CDB[2] = Media.Zone/2;
278
279 result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
280 if (result != USB_STOR_XFER_GOOD)
281 return USB_STOR_TRANSPORT_ERROR;
282
283 // Read redundant
307ae1d3 284 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 285 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
286 bcb->DataTransferLength = 0x10;
287 bcb->Flags = 0x80;
288 bcb->CDB[0] = 0xF1;
289 bcb->CDB[1] = 0x03;
290 bcb->CDB[4] = (BYTE)addr;
291 bcb->CDB[3] = (BYTE)(addr/0x0100);
292 bcb->CDB[2] = Media.Zone/2;
293 bcb->CDB[8] = 0;
294 bcb->CDB[9] = 1;
295
296 result = ENE_SendScsiCmd(us, FDIR_READ, redundant, 0);
297 if (result != USB_STOR_XFER_GOOD)
298 return USB_STOR_TRANSPORT_ERROR;
299
300 return USB_STOR_TRANSPORT_GOOD;
301}
302
303//----- Ssfdc_D_ReadBlock() ---------------------------------------------
304int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
305{
306 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
307 int result;
308 WORD addr;
309
310 //printk("Ssfdc_D_ReadBlock\n");
311 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
312 if (result != USB_STOR_XFER_GOOD)
313 {
314 printk("Load SM RW Code Fail !!\n");
315 return USB_STOR_TRANSPORT_ERROR;
316 }
317
318 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
319 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
320
321 // Read sect data
307ae1d3 322 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 323 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
324 bcb->DataTransferLength = 0x200*count;
325 bcb->Flags = 0x80;
326 bcb->CDB[0] = 0xF1;
327 bcb->CDB[1] = 0x02;
328 bcb->CDB[4] = (BYTE)addr;
329 bcb->CDB[3] = (BYTE)(addr/0x0100);
330 bcb->CDB[2] = Media.Zone/2;
331
332 result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
333 if (result != USB_STOR_XFER_GOOD)
334 return USB_STOR_TRANSPORT_ERROR;
335
336 // Read redundant
307ae1d3 337 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 338 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
339 bcb->DataTransferLength = 0x10;
340 bcb->Flags = 0x80;
341 bcb->CDB[0] = 0xF1;
342 bcb->CDB[1] = 0x03;
343 bcb->CDB[4] = (BYTE)addr;
344 bcb->CDB[3] = (BYTE)(addr/0x0100);
345 bcb->CDB[2] = Media.Zone/2;
346 bcb->CDB[8] = 0;
347 bcb->CDB[9] = 1;
348
349 result = ENE_SendScsiCmd(us, FDIR_READ, redundant, 0);
350 if (result != USB_STOR_XFER_GOOD)
351 return USB_STOR_TRANSPORT_ERROR;
352
353 return USB_STOR_TRANSPORT_GOOD;
354}
355/*
356////----- Ssfdc_D_ReadSect_DMA() ---------------------------------------------
357//int Ssfdc_D_ReadSect_DMA(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
358//{
359// WORD SectByteCount, addr;
360// DWORD Buffer[4];
361// WORD len;
362//
363// if (!_Hw_D_ChkCardIn())
364// return(ERROR);
365// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
366// addr=addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
367// // cycle starting address
368// SM_STARTADDR_LSB = 0x00;
369// SM_STARTADDR_IISB = (BYTE)addr;
370// SM_STARTADDR_IIISB = (BYTE)(addr/0x0100);
371// SM_STARTADDR_MSB = Media.Zone/2;
372//
373// //Sector byte count = 0x200(DMA)
374// SectByteCount = 0x20f;
375// SM_BYTECNT_LO = (BYTE)SectByteCount;
376// SM_CMD_CTRL3 = (SM_CMD_CTRL3 & 0xFC) | (BYTE)(SectByteCount/0x0100);
377// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
378// SM_FIFO_CTRL = (SM_APB08_MASK | SM_DMAEN_MASK | SM_DMA_UPSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
379// else
380// SM_FIFO_CTRL = (SM_APB32_MASK | SM_DMAEN_MASK | SM_DMA_UPSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
381//
382// _Hw_D_EccRdReset();
383// _Hw_D_EccRdStart();
384//
385// SM_CMD_CTRL1 = (SM_CMD_READ_1);
386// SM_CMD_CTRL1 = (SM_CMD_READ_1 | SM_CMD_START_BIT);
387//
388// SectByteCount = 0x1ff;
389// //SM_ReadDataWithDMA(fdoExt, buf, SectByteCount);
390// //_ReadRedt_D_SsfdcBuf(redundant);
391// len = 0x1000 - ((WORD)(buf) & 0x0FFF);
392// if (len < 0x200)
393// {
394// SM_ReadDataWithDMA(fdoExt, buf, len-1);
395// SM_ReadDataWithDMA(fdoExt, buf+len, SectByteCount-len);
396// //ENE_Print("Read DMA !!! buf1 = %p, len = %x, buf2 = %p\n", buf, len, buf+len);
397// }
398// else
399// SM_ReadDataWithDMA(fdoExt, buf, SectByteCount);
400//
401// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
402// {
403// _ReadRedt_D_SsfdcBuf(redundant);
404// }
405// else
406// {
407// Buffer[0] = READ_PORT_DWORD(SM_REG_DATA);
408// Buffer[1] = READ_PORT_DWORD(SM_REG_DATA);
409// Buffer[2] = READ_PORT_DWORD(SM_REG_DATA);
410// Buffer[3] = READ_PORT_DWORD(SM_REG_DATA);
411// memcpy(redundant, Buffer, 0x10);
412// }
413//
414// while ( _Hw_D_ChkCardIn() )
415// {
416// if((READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x10))
417// {
418// WRITE_PORT_BYTE(SM_REG_INT_STATUS, 0x10);
419// break;
420// }
421// }
422// _Hw_D_EccRdStop();
423// _Hw_D_SetRdStandby();
424// _Load_D_SsfdcRdHwECC(EVEN);
425//
426// _Calc_D_ECCdata(buf);
427// _Set_D_SsfdcRdStandby();
428//
429// if (!_Hw_D_ChkCardIn())
430// return(ERROR);
431// return(SUCCESS);
432//}
433//
434////----- Ssfdc_D_ReadSect_PIO() ---------------------------------------------
435//int Ssfdc_D_ReadSect_PIO(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
436//{
437// _Set_D_SsfdcRdCmd(READ);
438// _Set_D_SsfdcRdAddr(EVEN);
439//
440// if (_Check_D_SsfdcBusy(BUSY_READ))
441// { _Reset_D_SsfdcErr(); return(ERROR); }
442//
443// _Start_D_SsfdcRdHwECC();
444// _Read_D_SsfdcBuf(buf);
445// _Stop_D_SsfdcRdHwECC();
446// _ReadRedt_D_SsfdcBuf(redundant);
447// _Load_D_SsfdcRdHwECC(EVEN);
448//
449// if (_Check_D_SsfdcBusy(BUSY_READ))
450// { _Reset_D_SsfdcErr(); return(ERROR); }
451//
452// _Calc_D_ECCdata(buf);
453// _Set_D_SsfdcRdStandby();
454// return(SUCCESS);
455//}
456
457// 6250 CMD 3
458//----- Ssfdc_D_WriteSect() --------------------------------------------
459int Ssfdc_D_WriteSect(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
460{
461 PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
462 NTSTATUS ntStatus;
463 WORD addr;
464
465 //ENE_Print("SMILSUB --- Ssfdc_D_WriteSect\n");
466 ENE_LoadBinCode(fdoExt, SM_RW_PATTERN);
467
468 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
469 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
470
471 // Write sect data
472 RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
473 pBulkCbw->dCBWSignature = CBW_SIGNTURE;
474 pBulkCbw->bCBWLun = CBW_LUN;
475 pBulkCbw->dCBWDataTransferLength = 0x200;
476 pBulkCbw->bmCBWFlags = 0x00;
477 pBulkCbw->CBWCb[0] = 0xF0;
478 pBulkCbw->CBWCb[1] = 0x04;
479 //pBulkCbw->CBWCb[4] = (BYTE)addr;
480 //pBulkCbw->CBWCb[3] = (BYTE)(addr/0x0100);
481 //pBulkCbw->CBWCb[2] = Media.Zone/2;
482 //pBulkCbw->CBWCb[5] = *(redundant+REDT_ADDR1H);
483 //pBulkCbw->CBWCb[6] = *(redundant+REDT_ADDR1L);
484 pBulkCbw->CBWCb[7] = (BYTE)addr;
485 pBulkCbw->CBWCb[6] = (BYTE)(addr/0x0100);
486 pBulkCbw->CBWCb[5] = Media.Zone/2;
487 pBulkCbw->CBWCb[8] = *(redundant+REDT_ADDR1H);
488 pBulkCbw->CBWCb[9] = *(redundant+REDT_ADDR1L);
489
490 ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_WRITE, buf);
491
492 if (!NT_SUCCESS(ntStatus))
493 return(ERROR);
494
495// // For Test
496// {
497// BYTE bf[0x200], rdd[0x10];
498// ULONG i;
499//
500// RtlZeroMemory(bf, 0x200);
501// RtlZeroMemory(rdd, 0x10);
502// ntStatus = SM_ReadBlock(fdoExt, bf, rdd);
503// for (i=0; i<0x200; i++)
504// {
505// if (buf[i] != bf[i])
506// ENE_Print("buf[%x] = %x, bf[%x] = %x\n", buf, bf);
507// }
508// if (!NT_SUCCESS(ntStatus))
509// ENE_Print("Error\n");
510// }
511
512 return(SUCCESS);
513}
514*/
515//----- Ssfdc_D_CopyBlock() --------------------------------------------
516int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
517{
518 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
519 int result;
520 //PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
521 //NTSTATUS ntStatus;
522 WORD ReadAddr, WriteAddr;
523
524 //printk("Ssfdc_D_WriteSect --- ZONE = %x, ReadBlock = %x, WriteBlock = %x\n", Media.Zone, ReadBlock, WriteBlock);
525
526 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
527 if (result != USB_STOR_XFER_GOOD)
528 {
529 printk("Load SM RW Code Fail !!\n");
530 return USB_STOR_TRANSPORT_ERROR;
531 }
532
533 ReadAddr = (WORD)Media.Zone*Ssfdc.MaxBlocks+ReadBlock;
534 ReadAddr = ReadAddr*(WORD)Ssfdc.MaxSectors;
535 WriteAddr = (WORD)Media.Zone*Ssfdc.MaxBlocks+WriteBlock;
536 WriteAddr = WriteAddr*(WORD)Ssfdc.MaxSectors;
537
538 // Write sect data
307ae1d3 539 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 540 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
541 bcb->DataTransferLength = 0x200*count;
542 bcb->Flags = 0x00;
543 bcb->CDB[0] = 0xF0;
544 bcb->CDB[1] = 0x08;
545 bcb->CDB[7] = (BYTE)WriteAddr;
546 bcb->CDB[6] = (BYTE)(WriteAddr/0x0100);
547 bcb->CDB[5] = Media.Zone/2;
548 bcb->CDB[8] = *(redundant+REDT_ADDR1H);
549 bcb->CDB[9] = *(redundant+REDT_ADDR1L);
550 bcb->CDB[10] = Media.Sector;
551
552 if (ReadBlock != NO_ASSIGN)
553 {
554 bcb->CDB[4] = (BYTE)ReadAddr;
555 bcb->CDB[3] = (BYTE)(ReadAddr/0x0100);
556 bcb->CDB[2] = Media.Zone/2;
557 }
558 else
559 bcb->CDB[11] = 1;
560
561 result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
562 if (result != USB_STOR_XFER_GOOD)
563 return USB_STOR_TRANSPORT_ERROR;
564
565 return USB_STOR_TRANSPORT_GOOD;
566}
567/*
568//----- Ssfdc_D_WriteBlock() --------------------------------------------
569int Ssfdc_D_WriteBlock(PFDO_DEVICE_EXTENSION fdoExt, WORD count, BYTE *buf,BYTE *redundant)
570{
571 PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
572 NTSTATUS ntStatus;
573 WORD addr;
574
575 //ENE_Print("SMILSUB --- Ssfdc_D_WriteSect\n");
576 ENE_LoadBinCode(fdoExt, SM_RW_PATTERN);
577
578 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
579 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
580
581 // Write sect data
582 RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
583 pBulkCbw->dCBWSignature = CBW_SIGNTURE;
584 pBulkCbw->bCBWLun = CBW_LUN;
585 pBulkCbw->dCBWDataTransferLength = 0x200*count;
586 pBulkCbw->bmCBWFlags = 0x00;
587 pBulkCbw->CBWCb[0] = 0xF0;
588 pBulkCbw->CBWCb[1] = 0x04;
589 pBulkCbw->CBWCb[7] = (BYTE)addr;
590 pBulkCbw->CBWCb[6] = (BYTE)(addr/0x0100);
591 pBulkCbw->CBWCb[5] = Media.Zone/2;
592 pBulkCbw->CBWCb[8] = *(redundant+REDT_ADDR1H);
593 pBulkCbw->CBWCb[9] = *(redundant+REDT_ADDR1L);
594
595 ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_WRITE, buf);
596
597 if (!NT_SUCCESS(ntStatus))
598 return(ERROR);
599
600// // For Test
601// {
602// BYTE bf[0x200], rdd[0x10];
603// ULONG i;
604//
605// RtlZeroMemory(bf, 0x200);
606// RtlZeroMemory(rdd, 0x10);
607// ntStatus = SM_ReadBlock(fdoExt, bf, rdd);
608// for (i=0; i<0x200; i++)
609// {
610// if (buf[i] != bf[i])
611// ENE_Print("buf[%x] = %x, bf[%x] = %x\n", buf, bf);
612// }
613// if (!NT_SUCCESS(ntStatus))
614// ENE_Print("Error\n");
615// }
616
617 return(SUCCESS);
618}
619//
620////----- Ssfdc_D_WriteSect_DMA() --------------------------------------------
621//int Ssfdc_D_WriteSect_DMA(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
622//{
623// WORD SectByteCount, addr;
624// DWORD Buffer[4];
625// WORD len;
626//
627// if (!_Hw_D_ChkCardIn())
628// return(ERROR);
629// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
630// addr=addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
631// // cycle starting address
632// SM_STARTADDR_LSB = 0x00;
633// SM_STARTADDR_IISB = (BYTE)addr;
634// SM_STARTADDR_IIISB = (BYTE)(addr/0x0100);
635// SM_STARTADDR_MSB = Media.Zone/2;
636//
637// //Sector byte count (DMA)
638// SectByteCount = 0x20f;
639// SM_BYTECNT_LO = (BYTE)SectByteCount;
640// SM_CMD_CTRL3 = (SM_CMD_CTRL3 & 0xFC) | 0x20 | (BYTE)(SectByteCount/0x0100);
641// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
642// SM_FIFO_CTRL = (SM_APB08_MASK | SM_DMAEN_MASK | SM_DMA_DOWNSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
643// else
644// SM_FIFO_CTRL = (SM_APB32_MASK | SM_DMAEN_MASK | SM_DMA_DOWNSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
645//
646// _Hw_D_EccRdReset();
647// _Hw_D_EccRdStart();
648//
649// SM_CMD_CTRL1 = SM_CMD_PAGPRGM_TRUE;
650// SM_CMD_CTRL1 = (SM_CMD_PAGPRGM_TRUE | SM_CMD_START_BIT);
651//
652// SectByteCount = 0x1ff;
653// //SM_WriteDataWithDMA(fdoExt, buf, SectByteCount);
654// //_WriteRedt_D_SsfdcBuf(redundant);
655// len = 0x1000 - ((WORD)(buf) & 0x0FFF);
656// if (len < 0x200)
657// {
658// SM_WriteDataWithDMA(fdoExt, buf, len-1);
659// SM_WriteDataWithDMA(fdoExt, buf+len, SectByteCount-len);
660// //ENE_Print("Read DMA !!! buf1 = %p, len = %x, buf2 = %p\n", buf, len, buf+len);
661// }
662// else
663// SM_WriteDataWithDMA(fdoExt, buf, SectByteCount);
664//
665// //T1 = (ULONGLONG)buf & 0xFFFFFFFFFFFFF000;
666// //T2 = ((ULONGLONG)buf + 0x1FF) & 0xFFFFFFFFFFFFF000;
667// //if (T1 != T2)
668// // ENE_Print("Ssfdc_D_WriteSect_DMA !!! buf = %p, T1 = %p, T2 = %p\n", buf, T1, T2);
669// //if (T2-T1)
670// //{
671// // l1 = (WORD)(T2 - (ULONGLONG)buf);
672// // SM_WriteDataWithDMA(fdoExt, buf, l1-1);
673// // SM_WriteDataWithDMA(fdoExt, (PBYTE)T2, SectByteCount-l1);
674// //}
675// //else
676// // SM_WriteDataWithDMA(fdoExt, buf, SectByteCount);
677//
678// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
679// {
680// _WriteRedt_D_SsfdcBuf(redundant);
681// }
682// else
683// {
684// memcpy(Buffer, redundant, 0x10);
685// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[0]);
686// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[1]);
687// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[2]);
688// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[3]);
689// }
690//
691// while ( _Hw_D_ChkCardIn() )
692// {
693// if ((READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x10))
694// {
695// WRITE_PORT_BYTE(SM_REG_INT_STATUS, 0x10);
696// break;
697// }
698// }
699// _Hw_D_EccRdStop();
700// _Hw_D_SetRdStandby();
701//
702// _Set_D_SsfdcWrStandby();
703// _Set_D_SsfdcRdStandby();
704// if (!_Hw_D_ChkCardIn())
705// return(ERROR);
706//
707// return(SUCCESS);
708//}
709//
710////----- Ssfdc_D_WriteSect_PIO() --------------------------------------------
711//int Ssfdc_D_WriteSect_PIO(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
712//{
713// _Calc_D_ECCdata(buf);
714// _Set_D_SsfdcWrCmd(WRDATA);
715// _Set_D_SsfdcWrAddr(EVEN);
716// _Start_D_SsfdcWrHwECC();
717//
718// _Write_D_SsfdcBuf(buf);
719//
720// _Load_D_SsfdcWrHwECC(EVEN);
721// _Set_D_ECCdata(EVEN,redundant);
722//
723// _WriteRedt_D_SsfdcBuf(redundant);
724//
725// _Set_D_SsfdcWrCmd(WRITE);
726//
727// if (_Check_D_SsfdcBusy(BUSY_PROG))
728// { _Reset_D_SsfdcErr(); return(ERROR); }
729//
730// _Set_D_SsfdcWrStandby();
731// _Set_D_SsfdcRdStandby();
732// return(SUCCESS);
733//}
734*/
735//----- Ssfdc_D_WriteSectForCopy() -------------------------------------
736int Ssfdc_D_WriteSectForCopy(struct us_data *us, BYTE *buf, BYTE *redundant)
737{
738 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
739 int result;
740 //PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
741 //NTSTATUS ntStatus;
742 WORD addr;
743
744 //printk("SMILSUB --- Ssfdc_D_WriteSectForCopy\n");
745 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
746 if (result != USB_STOR_XFER_GOOD)
747 {
748 printk("Load SM RW Code Fail !!\n");
749 return USB_STOR_TRANSPORT_ERROR;
750 }
751
752
753 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
754 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
755
756 // Write sect data
307ae1d3 757 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 758 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
759 bcb->DataTransferLength = 0x200;
760 bcb->Flags = 0x00;
761 bcb->CDB[0] = 0xF0;
762 bcb->CDB[1] = 0x04;
763 bcb->CDB[7] = (BYTE)addr;
764 bcb->CDB[6] = (BYTE)(addr/0x0100);
765 bcb->CDB[5] = Media.Zone/2;
859171ca
JP		 766 bcb->CDB[8] = *(redundant+REDT_ADDR1H);
767 bcb->CDB[9] = *(redundant+REDT_ADDR1L);
126bb03b
AC		 768
769 result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
770 if (result != USB_STOR_XFER_GOOD)
771 return USB_STOR_TRANSPORT_ERROR;
772
773 return USB_STOR_TRANSPORT_GOOD;
774}
775
776// 6250 CMD 5
777//----- Ssfdc_D_EraseBlock() -------------------------------------------
778int Ssfdc_D_EraseBlock(struct us_data *us)
779{
780 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
781 int result;
782 WORD addr;
783
784 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
785 if (result != USB_STOR_XFER_GOOD)
786 {
787 printk("Load SM RW Code Fail !!\n");
788 return USB_STOR_TRANSPORT_ERROR;
789 }
790
791 addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
792 addr=addr*(WORD)Ssfdc.MaxSectors;
793
307ae1d3 794 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 795 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
796 bcb->DataTransferLength = 0x200;
797 bcb->Flags = 0x80;
798 bcb->CDB[0] = 0xF2;
799 bcb->CDB[1] = 0x06;
800 bcb->CDB[7] = (BYTE)addr;
801 bcb->CDB[6] = (BYTE)(addr/0x0100);
802 bcb->CDB[5] = Media.Zone/2;
803
804 result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
805 if (result != USB_STOR_XFER_GOOD)
806 return USB_STOR_TRANSPORT_ERROR;
807
808 return USB_STOR_TRANSPORT_GOOD;
809}
810
811// 6250 CMD 2
812//----- Ssfdc_D_ReadRedtData() -----------------------------------------
813int Ssfdc_D_ReadRedtData(struct us_data *us, BYTE *redundant)
814{
815 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
816 int result;
817 WORD addr;
818 BYTE *buf;
819
820 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
821 if (result != USB_STOR_XFER_GOOD)
822 {
823 printk("Load SM RW Code Fail !!\n");
824 return USB_STOR_TRANSPORT_ERROR;
825 }
826
827 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
828 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
829
307ae1d3 830 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 831 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
832 bcb->DataTransferLength = 0x10;
833 bcb->Flags = 0x80;
834 bcb->CDB[0] = 0xF1;
835 bcb->CDB[1] = 0x03;
836 bcb->CDB[4] = (BYTE)addr;
837 bcb->CDB[3] = (BYTE)(addr/0x0100);
838 bcb->CDB[2] = Media.Zone/2;
839 bcb->CDB[8] = 0;
840 bcb->CDB[9] = 1;
841
842 buf = kmalloc(0x10, GFP_KERNEL);
843 //result = ENE_SendScsiCmd(us, FDIR_READ, redundant, 0);
844 result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
845 memcpy(redundant, buf, 0x10);
846 kfree(buf);
847 if (result != USB_STOR_XFER_GOOD)
848 return USB_STOR_TRANSPORT_ERROR;
849
850 return USB_STOR_TRANSPORT_GOOD;
851}
852
853// 6250 CMD 4
854//----- Ssfdc_D_WriteRedtData() ----------------------------------------
855int Ssfdc_D_WriteRedtData(struct us_data *us, BYTE *redundant)
856{
857 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
858 int result;
859 //PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
860 //NTSTATUS ntStatus;
861 WORD addr;
862
863 result = ENE_LoadBinCode(us, SM_RW_PATTERN);
864 if (result != USB_STOR_XFER_GOOD)
865 {
866 printk("Load SM RW Code Fail !!\n");
867 return USB_STOR_TRANSPORT_ERROR;
868 }
869
870 addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
871 addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
872
307ae1d3 873 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b
AC		 874 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
875 bcb->DataTransferLength = 0x10;
876 bcb->Flags = 0x80;
877 bcb->CDB[0] = 0xF2;
878 bcb->CDB[1] = 0x05;
879 bcb->CDB[7] = (BYTE)addr;
880 bcb->CDB[6] = (BYTE)(addr/0x0100);
881 bcb->CDB[5] = Media.Zone/2;
882 bcb->CDB[8] = *(redundant+REDT_ADDR1H);
883 bcb->CDB[9] = *(redundant+REDT_ADDR1L);
884
885 result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
886 if (result != USB_STOR_XFER_GOOD)
887 return USB_STOR_TRANSPORT_ERROR;
888
889 return USB_STOR_TRANSPORT_GOOD;
890}
891
892//----- Ssfdc_D_CheckStatus() ------------------------------------------
893int Ssfdc_D_CheckStatus(void)
894{
895