Commit | Line | Data |
---|---|---|
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 | ||
12 | void _Set_D_SsfdcRdCmd (BYTE); | |
13 | void _Set_D_SsfdcRdAddr (BYTE); | |
14 | void _Set_D_SsfdcRdChip (void); | |
15 | void _Set_D_SsfdcRdStandby (void); | |
16 | void _Start_D_SsfdcRdHwECC (void); | |
17 | void _Stop_D_SsfdcRdHwECC (void); | |
18 | void _Load_D_SsfdcRdHwECC (BYTE); | |
19 | void _Set_D_SsfdcWrCmd (BYTE); | |
20 | void _Set_D_SsfdcWrAddr (BYTE); | |
21 | void _Set_D_SsfdcWrBlock (void); | |
22 | void _Set_D_SsfdcWrStandby (void); | |
23 | void _Start_D_SsfdcWrHwECC (void); | |
24 | void _Load_D_SsfdcWrHwECC (BYTE); | |
25 | int _Check_D_SsfdcBusy (WORD); | |
26 | int _Check_D_SsfdcStatus (void); | |
27 | void _Reset_D_SsfdcErr (void); | |
28 | void _Read_D_SsfdcBuf (BYTE *); | |
29 | void _Write_D_SsfdcBuf (BYTE *); | |
30 | void _Read_D_SsfdcByte (BYTE *); | |
31 | void _ReadRedt_D_SsfdcBuf (BYTE *); | |
32 | void _WriteRedt_D_SsfdcBuf (BYTE *); | |
33 | BYTE _Check_D_DevCode (BYTE); | |
34 | ||
35 | void _Set_D_ECCdata (BYTE,BYTE *); | |
36 | void _Calc_D_ECCdata (BYTE *); | |
37 | ||
38 | //void SM_ReadDataWithDMA (PFDO_DEVICE_EXTENSION, BYTE *, WORD); | |
39 | //void SM_WriteDataWithDMA (PFDO_DEVICE_EXTENSION, BYTE *, WORD); | |
40 | // | |
41 | struct SSFDCTYPE Ssfdc; | |
42 | struct ADDRESS Media; | |
43 | struct CIS_AREA CisArea; | |
44 | ||
d8aba9d5 | 45 | static BYTE EccBuf[6]; |
126bb03b | 46 | extern PBYTE SMHostAddr; |
126bb03b AC |
47 | extern DWORD ErrXDCode; |
48 | ||
49 | extern WORD ReadBlock; | |
50 | extern 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() -------------------------------------------- |
60 | int 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 | ||
68 | return(SUCCESS); | |
69 | } | |
70 | ||
71 | //----- Check_D_FailBlock() -------------------------------------------- | |
72 | int Check_D_FailBlock(BYTE *redundant) | |
73 | { | |
74 | redundant+=REDT_BLOCK; | |
75 | ||
76 | if (*redundant==0xFF) | |
77 | return(SUCCESS); | |
78 | if (!*redundant) | |
79 | return(ERROR); | |
2f7cf8d1 | 80 | if (hweight8(*redundant)<7) |
126bb03b AC |
81 | return(ERROR); |
82 | ||
83 | return(SUCCESS); | |
84 | } | |
85 | ||
86 | //----- Check_D_DataStatus() ------------------------------------------- | |
87 | int Check_D_DataStatus(BYTE *redundant) | |
88 | { | |
89 | redundant+=REDT_DATA; | |
90 | ||
91 | if (*redundant==0xFF) | |
92 | return(SUCCESS); | |
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 | ||
104 | return(SUCCESS); | |
105 | } | |
106 | ||
107 | //----- Load_D_LogBlockAddr() ------------------------------------------ | |
108 | int 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) | |
119 | { Media.LogBlock=(addr1 &0x0FFF)/2; return(SUCCESS); } | |
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)) |
126bb03b AC |
125 | { Media.LogBlock=(addr1 &0x0FFF)/2; return(SUCCESS); } |
126 | ||
127 | if ((addr2 &0xF000)==0x1000) | |
2f7cf8d1 | 128 | if (!(hweight16(addr2) &0x01)) |
126bb03b AC |
129 | { Media.LogBlock=(addr2 &0x0FFF)/2; return(SUCCESS); } |
130 | ||
131 | return(ERROR); | |
132 | } | |
133 | ||
134 | //----- Clr_D_RedundantData() ------------------------------------------ | |
135 | void 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() ------------------------------------------- | |
144 | void 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() ---------------------------------------------- | |
160 | void 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() ---------------------------------------------- | |
169 | void 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() ------------------------------------------------ | |
178 | void 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() ------------------------------------------ | |
204 | int 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; | |
223 | return(SUCCESS); | |
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() --------------------------------------------- | |
250 | int 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() --------------------------------------------- | |
302 | int 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); | |
429 | // return(SUCCESS); | |
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(SUCCESS); | |
453 | //} | |
454 | ||
455 | // 6250 CMD 3 | |
456 | //----- Ssfdc_D_WriteSect() -------------------------------------------- | |
457 | int 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 | ||
510 | return(SUCCESS); | |
511 | } | |
512 | */ | |
513 | //----- Ssfdc_D_CopyBlock() -------------------------------------------- | |
514 | int 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() -------------------------------------------- | |
567 | int 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 | ||
615 | return(SUCCESS); | |
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(SUCCESS); | |
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(SUCCESS); | |
731 | //} | |
732 | */ | |
733 | //----- Ssfdc_D_WriteSectForCopy() ------------------------------------- | |
734 | int 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() ------------------------------------------- | |
776 | int 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() ----------------------------------------- | |
811 | int 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() ---------------------------------------- | |
853 | int 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() ------------------------------------------ | |
891 | int Ssfdc_D_CheckStatus(void) | |
892 | { |