]>
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 | ||
45 | BYTE EccBuf[6]; | |
46 | extern PBYTE SMHostAddr; | |
47 | extern BYTE IsSSFDCCompliance; | |
48 | extern BYTE IsXDCompliance; | |
49 | extern DWORD ErrXDCode; | |
50 | ||
51 | extern WORD ReadBlock; | |
52 | extern 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() -------------------------------------------- |
62 | int 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() -------------------------------------------- | |
74 | int 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() ------------------------------------------- | |
89 | int 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() ------------------------------------------ | |
110 | int 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() ------------------------------------------ | |
137 | void 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() ------------------------------------------- | |
146 | void 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() ---------------------------------------------- | |
162 | void 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() ---------------------------------------------- | |
171 | void 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() ------------------------------------------------ | |
180 | void 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() ------------------------------------------ | |
206 | int 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() --------------------------------------------- | |
252 | int 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() --------------------------------------------- | |
304 | int 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() -------------------------------------------- | |
459 | int 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() -------------------------------------------- | |
516 | int 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() -------------------------------------------- | |
569 | int 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() ------------------------------------- | |
736 | int 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() ------------------------------------------- | |
778 | int 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() ----------------------------------------- | |
813 | int 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() ---------------------------------------- | |
855 | int 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() ------------------------------------------ | |
893 | int Ssfdc_D_CheckStatus(void) | |
894 | { | |
895 |