Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
smilsub.c
Go to the documentation of this file.
1 #include <linux/slab.h>
2 #include "usb.h"
3 #include "scsiglue.h"
4 #include "transport.h"
5 
6 #include "smcommon.h"
7 #include "smil.h"
8 
9 void _Set_D_SsfdcRdCmd(BYTE);
10 void _Set_D_SsfdcRdAddr(BYTE);
11 void _Set_D_SsfdcRdChip(void);
12 void _Set_D_SsfdcRdStandby(void);
13 void _Start_D_SsfdcRdHwECC(void);
14 void _Stop_D_SsfdcRdHwECC(void);
15 void _Load_D_SsfdcRdHwECC(BYTE);
16 void _Set_D_SsfdcWrCmd(BYTE);
17 void _Set_D_SsfdcWrAddr(BYTE);
18 void _Set_D_SsfdcWrBlock(void);
19 void _Set_D_SsfdcWrStandby(void);
20 void _Start_D_SsfdcWrHwECC(void);
21 void _Load_D_SsfdcWrHwECC(BYTE);
22 int _Check_D_SsfdcBusy(WORD);
23 int _Check_D_SsfdcStatus(void);
24 void _Reset_D_SsfdcErr(void);
25 void _Read_D_SsfdcBuf(BYTE *);
26 void _Write_D_SsfdcBuf(BYTE *);
27 void _Read_D_SsfdcByte(BYTE *);
28 void _ReadRedt_D_SsfdcBuf(BYTE *);
29 void _WriteRedt_D_SsfdcBuf(BYTE *);
30 BYTE _Check_D_DevCode(BYTE);
31 
32 void _Set_D_ECCdata(BYTE, BYTE *);
33 void _Calc_D_ECCdata(BYTE *);
34 
35 
36 struct SSFDCTYPE Ssfdc;
37 struct ADDRESS Media;
38 struct CIS_AREA CisArea;
39 
40 static BYTE EccBuf[6];
41 extern PBYTE SMHostAddr;
42 extern DWORD ErrXDCode;
43 
44 extern WORD ReadBlock;
45 extern WORD WriteBlock;
46 
47 
48 
49 #define EVEN 0 /* Even Page for 256byte/page */
50 #define ODD 1 /* Odd Page for 256byte/page */
51 
52 
53 /* SmartMedia Redundant buffer data Control Subroutine
54  *----- Check_D_DataBlank() --------------------------------------------
55  */
56 int Check_D_DataBlank(BYTE *redundant)
57 {
58  char i;
59 
60  for (i = 0; i < REDTSIZE; i++)
61  if (*redundant++ != 0xFF)
62  return ERROR;
63 
64  return SMSUCCESS;
65 }
66 
67 /* ----- Check_D_FailBlock() -------------------------------------------- */
68 int Check_D_FailBlock(BYTE *redundant)
69 {
70  redundant += REDT_BLOCK;
71 
72  if (*redundant == 0xFF)
73  return SMSUCCESS;
74  if (!*redundant)
75  return ERROR;
76  if (hweight8(*redundant) < 7)
77  return ERROR;
78 
79  return SMSUCCESS;
80 }
81 
82 /* ----- Check_D_DataStatus() ------------------------------------------- */
83 int Check_D_DataStatus(BYTE *redundant)
84 {
85  redundant += REDT_DATA;
86 
87  if (*redundant == 0xFF)
88  return SMSUCCESS;
89  if (!*redundant) {
90  ErrXDCode = ERR_DataStatus;
91  return ERROR;
92  } else
93  ErrXDCode = NO_ERROR;
94 
95  if (hweight8(*redundant) < 5)
96  return ERROR;
97 
98  return SMSUCCESS;
99 }
100 
101 /* ----- Load_D_LogBlockAddr() ------------------------------------------ */
102 int Load_D_LogBlockAddr(BYTE *redundant)
103 {
104  WORD addr1, addr2;
105 
106  addr1 = (WORD)*(redundant + REDT_ADDR1H)*0x0100 + (WORD)*(redundant + REDT_ADDR1L);
107  addr2 = (WORD)*(redundant + REDT_ADDR2H)*0x0100 + (WORD)*(redundant + REDT_ADDR2L);
108 
109  if (addr1 == addr2)
110  if ((addr1 & 0xF000) == 0x1000) {
111  Media.LogBlock = (addr1 & 0x0FFF) / 2;
112  return SMSUCCESS;
113  }
114 
115  if (hweight16((WORD)(addr1^addr2)) != 0x01)
116  return ERROR;
117 
118  if ((addr1 & 0xF000) == 0x1000)
119  if (!(hweight16(addr1) & 0x01)) {
120  Media.LogBlock = (addr1 & 0x0FFF) / 2;
121  return SMSUCCESS;
122  }
123 
124  if ((addr2 & 0xF000) == 0x1000)
125  if (!(hweight16(addr2) & 0x01)) {
126  Media.LogBlock = (addr2 & 0x0FFF) / 2;
127  return SMSUCCESS;
128  }
129 
130  return ERROR;
131 }
132 
133 /* ----- Clr_D_RedundantData() ------------------------------------------ */
134 void Clr_D_RedundantData(BYTE *redundant)
135 {
136  char i;
137 
138  for (i = 0; i < REDTSIZE; i++)
139  *(redundant + i) = 0xFF;
140 }
141 
142 /* ----- Set_D_LogBlockAddr() ------------------------------------------- */
143 void Set_D_LogBlockAddr(BYTE *redundant)
144 {
145  WORD addr;
146 
147  *(redundant + REDT_BLOCK) = 0xFF;
148  *(redundant + REDT_DATA) = 0xFF;
149  addr = Media.LogBlock*2 + 0x1000;
150 
151  if ((hweight16(addr) % 2))
152  addr++;
153 
154  *(redundant + REDT_ADDR1H) = *(redundant + REDT_ADDR2H) = (BYTE)(addr / 0x0100);
155  *(redundant + REDT_ADDR1L) = *(redundant + REDT_ADDR2L) = (BYTE)addr;
156 }
157 
158 /*----- Set_D_FailBlock() ---------------------------------------------- */
159 void Set_D_FailBlock(BYTE *redundant)
160 {
161  char i;
162  for (i = 0; i < REDTSIZE; i++)
163  *redundant++ = (BYTE)((i == REDT_BLOCK) ? 0xF0 : 0xFF);
164 }
165 
166 /* ----- Set_D_DataStaus() ---------------------------------------------- */
167 void Set_D_DataStaus(BYTE *redundant)
168 {
169  redundant += REDT_DATA;
170  *redundant = 0x00;
171 }
172 
173 /* SmartMedia Function Command Subroutine
174  * 6250 CMD 6
175  */
176 /* ----- Ssfdc_D_Reset() ------------------------------------------------ */
177 void Ssfdc_D_Reset(struct us_data *us)
178 {
179  return;
180 }
181 
182 /* ----- Ssfdc_D_ReadCisSect() ------------------------------------------ */
183 int Ssfdc_D_ReadCisSect(struct us_data *us, BYTE *buf, BYTE *redundant)
184 {
185  BYTE zone, sector;
186  WORD block;
187 
188  zone = Media.Zone; block = Media.PhyBlock; sector = Media.Sector;
189  Media.Zone = 0;
190  Media.PhyBlock = CisArea.PhyBlock;
191  Media.Sector = CisArea.Sector;
192 
193  if (Ssfdc_D_ReadSect(us, buf, redundant)) {
194  Media.Zone = zone; Media.PhyBlock = block; Media.Sector = sector;
195  return ERROR;
196  }
197 
198  Media.Zone = zone; Media.PhyBlock = block; Media.Sector = sector;
199  return SMSUCCESS;
200 }
201 
202 /* 6250 CMD 1 */
203 /* ----- Ssfdc_D_ReadSect() --------------------------------------------- */
204 int Ssfdc_D_ReadSect(struct us_data *us, BYTE *buf, BYTE *redundant)
205 {
206  struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
207  int result;
208  WORD addr;
209 
210  result = ENE_LoadBinCode(us, SM_RW_PATTERN);
211  if (result != USB_STOR_XFER_GOOD) {
212  printk("Load SM RW Code Fail !!\n");
213  return USB_STOR_TRANSPORT_ERROR;
214  }
215 
216  addr = (WORD)Media.Zone*Ssfdc.MaxBlocks + Media.PhyBlock;
217  addr = addr*(WORD)Ssfdc.MaxSectors + Media.Sector;
218 
219  /* Read sect data */
220  memset(bcb, 0, sizeof(struct bulk_cb_wrap));
221  bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
222  bcb->DataTransferLength = 0x200;
223  bcb->Flags = 0x80;
224  bcb->CDB[0] = 0xF1;
225  bcb->CDB[1] = 0x02;
226  bcb->CDB[4] = (BYTE)addr;
227  bcb->CDB[3] = (BYTE)(addr / 0x0100);
228  bcb->CDB[2] = Media.Zone / 2;
229 
230  result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
231  if (result != USB_STOR_XFER_GOOD)
232  return USB_STOR_TRANSPORT_ERROR;
233 
234  /* Read redundant */
235  memset(bcb, 0, sizeof(struct bulk_cb_wrap));
236  bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
237  bcb->DataTransferLength = 0x10;
238  bcb->Flags = 0x80;
239  bcb->CDB[0] = 0xF1;
240  bcb->CDB[1] = 0x03;
241  bcb->CDB[4] = (BYTE)addr;
242  bcb->CDB[3] = (BYTE)(addr / 0x0100);
243  bcb->CDB[2] = Media.Zone / 2;
244  bcb->CDB[8] = 0;
245  bcb->CDB[9] = 1;
246 
247  result = ENE_SendScsiCmd(us, FDIR_READ, redundant, 0);
248  if (result != USB_STOR_XFER_GOOD)
249  return USB_STOR_TRANSPORT_ERROR;
250 
251  return USB_STOR_TRANSPORT_GOOD;
252 }
253 
254 /* ----- Ssfdc_D_ReadBlock() --------------------------------------------- */
255 int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf, BYTE *redundant)
256 {
257  struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
258  int result;
259  WORD addr;
260 
261  result = ENE_LoadBinCode(us, SM_RW_PATTERN);
262  if (result != USB_STOR_XFER_GOOD) {
263  printk("Load SM RW Code Fail !!\n");
264  return USB_STOR_TRANSPORT_ERROR;
265  }
266 
267  addr = (WORD)Media.Zone*Ssfdc.MaxBlocks + Media.PhyBlock;
268  addr = addr*(WORD)Ssfdc.MaxSectors + Media.Sector;
269 
270  /* Read sect data */
271  memset(bcb, 0, sizeof(struct bulk_cb_wrap));
272  bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
273  bcb->DataTransferLength = 0x200*count;
274  bcb->Flags = 0x80;
275  bcb->CDB[0] = 0xF1;
276  bcb->CDB[1] = 0x02;
277  bcb->CDB[4] = (BYTE)addr;
278  bcb->CDB[3] = (BYTE)(addr / 0x0100);
279  bcb->CDB[2] = Media.Zone / 2;
280 
281  result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
282  if (result != USB_STOR_XFER_GOOD)
283  return USB_STOR_TRANSPORT_ERROR;
284 
285  /* Read redundant */
286  memset(bcb, 0, sizeof(struct bulk_cb_wrap));
287  bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
288  bcb->DataTransferLength = 0x10;
289  bcb->Flags = 0x80;
290  bcb->CDB[0] = 0xF1;
291  bcb->CDB[1] = 0x03;
292  bcb->CDB[4] = (BYTE)addr;
293  bcb->CDB[3] = (BYTE)(addr / 0x0100);
294  bcb->CDB[2] = Media.Zone / 2;
295  bcb->CDB[8] = 0;
296  bcb->CDB[9] = 1;
297 
298  result = ENE_SendScsiCmd(us, FDIR_READ, redundant, 0);
299  if (result != USB_STOR_XFER_GOOD)
300  return USB_STOR_TRANSPORT_ERROR;
301 
302  return USB_STOR_TRANSPORT_GOOD;
303 }
304 
305 
306 /* ----- Ssfdc_D_CopyBlock() -------------------------------------------- */
307 int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf, BYTE *redundant)
308 {
309  struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
310  int result;
311  WORD ReadAddr, WriteAddr;
312 
313  result = ENE_LoadBinCode(us, SM_RW_PATTERN);
314  if (result != USB_STOR_XFER_GOOD) {
315  printk("Load SM RW Code Fail !!\n");
316  return USB_STOR_TRANSPORT_ERROR;
317  }
318 
319  ReadAddr = (WORD)Media.Zone*Ssfdc.MaxBlocks + ReadBlock;
320  ReadAddr = ReadAddr*(WORD)Ssfdc.MaxSectors;
321  WriteAddr = (WORD)Media.Zone*Ssfdc.MaxBlocks + WriteBlock;
322  WriteAddr = WriteAddr*(WORD)Ssfdc.MaxSectors;
323 
324  /* Write sect data */
325  memset(bcb, 0, sizeof(struct bulk_cb_wrap));
326  bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
327  bcb->DataTransferLength = 0x200*count;
328  bcb->Flags = 0x00;
329  bcb->CDB[0] = 0xF0;
330  bcb->CDB[1] = 0x08;
331  bcb->CDB[7] = (BYTE)WriteAddr;
332  bcb->CDB[6] = (BYTE)(WriteAddr / 0x0100);
333  bcb->CDB[5] = Media.Zone / 2;
334  bcb->CDB[8] = *(redundant + REDT_ADDR1H);
335  bcb->CDB[9] = *(redundant + REDT_ADDR1L);
336  bcb->CDB[10] = Media.Sector;
337 
338  if (ReadBlock != NO_ASSIGN) {
339  bcb->CDB[4] = (BYTE)ReadAddr;
340  bcb->CDB[3] = (BYTE)(ReadAddr / 0x0100);
341  bcb->CDB[2] = Media.Zone / 2;
342  } else
343  bcb->CDB[11] = 1;
344 
345  result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
346  if (result != USB_STOR_XFER_GOOD)
347  return USB_STOR_TRANSPORT_ERROR;
348 
349  return USB_STOR_TRANSPORT_GOOD;
350 }
351 
352 /* ----- Ssfdc_D_WriteSectForCopy() ------------------------------------- */
353 int Ssfdc_D_WriteSectForCopy(struct us_data *us, BYTE *buf, BYTE *redundant)
354 {
355  struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
356  int result;
357  WORD addr;
358 
359  result = ENE_LoadBinCode(us, SM_RW_PATTERN);
360  if (result != USB_STOR_XFER_GOOD) {
361  printk("Load SM RW Code Fail !!\n");
362  return USB_STOR_TRANSPORT_ERROR;
363  }
364 
365 
366  addr = (WORD)Media.Zone*Ssfdc.MaxBlocks + Media.PhyBlock;
367  addr = addr*(WORD)Ssfdc.MaxSectors + Media.Sector;
368 
369  /* Write sect data */
370  memset(bcb, 0, sizeof(struct bulk_cb_wrap));
371  bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
372  bcb->DataTransferLength = 0x200;
373  bcb->Flags = 0x00;
374  bcb->CDB[0] = 0xF0;
375  bcb->CDB[1] = 0x04;
376  bcb->CDB[7] = (BYTE)addr;
377  bcb->CDB[6] = (BYTE)(addr / 0x0100);
378  bcb->CDB[5] = Media.Zone / 2;
379  bcb->CDB[8] = *(redundant + REDT_ADDR1H);
380  bcb->CDB[9] = *(redundant + REDT_ADDR1L);
381 
382  result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
383  if (result != USB_STOR_XFER_GOOD)
384  return USB_STOR_TRANSPORT_ERROR;
385 
386  return USB_STOR_TRANSPORT_GOOD;
387 }
388 
389 /* 6250 CMD 5 */
390 /* ----- Ssfdc_D_EraseBlock() ------------------------------------------- */
391 int Ssfdc_D_EraseBlock(struct us_data *us)
392 {
393  struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
394  int result;
395  WORD addr;
396 
397  result = ENE_LoadBinCode(us, SM_RW_PATTERN);
398  if (result != USB_STOR_XFER_GOOD) {
399  printk("Load SM RW Code Fail !!\n");
400  return USB_STOR_TRANSPORT_ERROR;
401  }
402 
403  addr = (WORD)Media.Zone*Ssfdc.MaxBlocks + Media.PhyBlock;
404  addr = addr*(WORD)Ssfdc.MaxSectors;
405 
406  memset(bcb, 0, sizeof(struct bulk_cb_wrap));
407  bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
408  bcb->DataTransferLength = 0x200;
409  bcb->Flags = 0x80;
410  bcb->CDB[0] = 0xF2;
411  bcb->CDB[1] = 0x06;
412  bcb->CDB[7] = (BYTE)addr;
413  bcb->CDB[6] = (BYTE)(addr / 0x0100);
414  bcb->CDB[5] = Media.Zone / 2;
415 
416  result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
417  if (result != USB_STOR_XFER_GOOD)
418  return USB_STOR_TRANSPORT_ERROR;
419 
420  return USB_STOR_TRANSPORT_GOOD;
421 }
422 
423 /* 6250 CMD 2 */
424 /*----- Ssfdc_D_ReadRedtData() ----------------------------------------- */
425 int Ssfdc_D_ReadRedtData(struct us_data *us, BYTE *redundant)
426 {
427  struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
428  int result;
429  WORD addr;
430  BYTE *buf;
431 
432  result = ENE_LoadBinCode(us, SM_RW_PATTERN);
433  if (result != USB_STOR_XFER_GOOD) {
434  printk("Load SM RW Code Fail !!\n");
435  return USB_STOR_TRANSPORT_ERROR;
436  }
437 
438  addr = (WORD)Media.Zone*Ssfdc.MaxBlocks + Media.PhyBlock;
439  addr = addr*(WORD)Ssfdc.MaxSectors + Media.Sector;
440 
441  memset(bcb, 0, sizeof(struct bulk_cb_wrap));
442  bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
443  bcb->DataTransferLength = 0x10;
444  bcb->Flags = 0x80;
445  bcb->CDB[0] = 0xF1;
446  bcb->CDB[1] = 0x03;
447  bcb->CDB[4] = (BYTE)addr;
448  bcb->CDB[3] = (BYTE)(addr / 0x0100);
449  bcb->CDB[2] = Media.Zone / 2;
450  bcb->CDB[8] = 0;
451  bcb->CDB[9] = 1;
452 
453  buf = kmalloc(0x10, GFP_KERNEL);
454  result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
455  memcpy(redundant, buf, 0x10);
456  kfree(buf);
457  if (result != USB_STOR_XFER_GOOD)
458  return USB_STOR_TRANSPORT_ERROR;
459 
460  return USB_STOR_TRANSPORT_GOOD;
461 }
462 
463 /* 6250 CMD 4 */
464 /* ----- Ssfdc_D_WriteRedtData() ---------------------------------------- */
465 int Ssfdc_D_WriteRedtData(struct us_data *us, BYTE *redundant)
466 {
467  struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
468  int result;
469  WORD addr;
470 
471  result = ENE_LoadBinCode(us, SM_RW_PATTERN);
472  if (result != USB_STOR_XFER_GOOD) {
473  printk("Load SM RW Code Fail !!\n");
474  return USB_STOR_TRANSPORT_ERROR;
475  }
476 
477  addr = (WORD)Media.Zone*Ssfdc.MaxBlocks + Media.PhyBlock;
478  addr = addr*(WORD)Ssfdc.MaxSectors + Media.Sector;
479 
480  memset(bcb, 0, sizeof(struct bulk_cb_wrap));
481  bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
482  bcb->DataTransferLength = 0x10;
483  bcb->Flags = 0x80;
484  bcb->CDB[0] = 0xF2;
485  bcb->CDB[1] = 0x05;
486  bcb->CDB[7] = (BYTE)addr;
487  bcb->CDB[6] = (BYTE)(addr / 0x0100);
488  bcb->CDB[5] = Media.Zone / 2;
489  bcb->CDB[8] = *(redundant + REDT_ADDR1H);
490  bcb->CDB[9] = *(redundant + REDT_ADDR1L);
491 
492  result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
493  if (result != USB_STOR_XFER_GOOD)
494  return USB_STOR_TRANSPORT_ERROR;
495 
496  return USB_STOR_TRANSPORT_GOOD;
497 }
498 
499 /* ----- Ssfdc_D_CheckStatus() ------------------------------------------ */
500 int Ssfdc_D_CheckStatus(void)
501 {
502  return SMSUCCESS;
503 }
504 
505 
506 
507 /* SmartMedia ID Code Check & Mode Set Subroutine
508  * ----- Set_D_SsfdcModel() ---------------------------------------------
509  */
510 int Set_D_SsfdcModel(BYTE dcode)
511 {
512  switch (_Check_D_DevCode(dcode)) {
513  case SSFDC1MB:
514  Ssfdc.Model = SSFDC1MB;
515  Ssfdc.Attribute = FLASH | AD3CYC | BS16 | PS256;
516  Ssfdc.MaxZones = 1;
517  Ssfdc.MaxBlocks = 256;
518  Ssfdc.MaxLogBlocks = 250;
519  Ssfdc.MaxSectors = 8;
520  break;
521  case SSFDC2MB:
522  Ssfdc.Model = SSFDC2MB;
523  Ssfdc.Attribute = FLASH | AD3CYC | BS16 | PS256;
524  Ssfdc.MaxZones = 1;
525  Ssfdc.MaxBlocks = 512;
526  Ssfdc.MaxLogBlocks = 500;
527  Ssfdc.MaxSectors = 8;
528  break;
529  case SSFDC4MB:
530  Ssfdc.Model = SSFDC4MB;
531  Ssfdc.Attribute = FLASH | AD3CYC | BS16 | PS512;
532  Ssfdc.MaxZones = 1;
533  Ssfdc.MaxBlocks = 512;
534  Ssfdc.MaxLogBlocks = 500;
535  Ssfdc.MaxSectors = 16;
536  break;
537  case SSFDC8MB:
538  Ssfdc.Model = SSFDC8MB;
539  Ssfdc.Attribute = FLASH | AD3CYC | BS16 | PS512;
540  Ssfdc.MaxZones = 1;
541  Ssfdc.MaxBlocks = 1024;
542  Ssfdc.MaxLogBlocks = 1000;
543  Ssfdc.MaxSectors = 16;
544  break;
545  case SSFDC16MB:
546  Ssfdc.Model = SSFDC16MB;
547  Ssfdc.Attribute = FLASH | AD3CYC | BS32 | PS512;
548  Ssfdc.MaxZones = 1;
549  Ssfdc.MaxBlocks = 1024;
550  Ssfdc.MaxLogBlocks = 1000;
551  Ssfdc.MaxSectors = 32;
552  break;
553  case SSFDC32MB:
554  Ssfdc.Model = SSFDC32MB;
555  Ssfdc.Attribute = FLASH | AD3CYC | BS32 | PS512;
556  Ssfdc.MaxZones = 2;
557  Ssfdc.MaxBlocks = 1024;
558  Ssfdc.MaxLogBlocks = 1000;
559  Ssfdc.MaxSectors = 32;
560  break;
561  case SSFDC64MB:
562  Ssfdc.Model = SSFDC64MB;
563  Ssfdc.Attribute = FLASH | AD4CYC | BS32 | PS512;
564  Ssfdc.MaxZones = 4;
565  Ssfdc.MaxBlocks = 1024;
566  Ssfdc.MaxLogBlocks = 1000;
567  Ssfdc.MaxSectors = 32;
568  break;
569  case SSFDC128MB:
570  Ssfdc.Model = SSFDC128MB;
571  Ssfdc.Attribute = FLASH | AD4CYC | BS32 | PS512;
572  Ssfdc.MaxZones = 8;
573  Ssfdc.MaxBlocks = 1024;
574  Ssfdc.MaxLogBlocks = 1000;
575  Ssfdc.MaxSectors = 32;
576  break;
577  case SSFDC256MB:
578  Ssfdc.Model = SSFDC256MB;
579  Ssfdc.Attribute = FLASH | AD4CYC | BS32 | PS512;
580  Ssfdc.MaxZones = 16;
581  Ssfdc.MaxBlocks = 1024;
582  Ssfdc.MaxLogBlocks = 1000;
583  Ssfdc.MaxSectors = 32;
584  break;
585  case SSFDC512MB:
586  Ssfdc.Model = SSFDC512MB;
587  Ssfdc.Attribute = FLASH | AD4CYC | BS32 | PS512;
588  Ssfdc.MaxZones = 32;
589  Ssfdc.MaxBlocks = 1024;
590  Ssfdc.MaxLogBlocks = 1000;
591  Ssfdc.MaxSectors = 32;
592  break;
593  case SSFDC1GB:
594  Ssfdc.Model = SSFDC1GB;
595  Ssfdc.Attribute = FLASH | AD4CYC | BS32 | PS512;
596  Ssfdc.MaxZones = 64;
597  Ssfdc.MaxBlocks = 1024;
598  Ssfdc.MaxLogBlocks = 1000;
599  Ssfdc.MaxSectors = 32;
600  break;
601  case SSFDC2GB:
602  Ssfdc.Model = SSFDC2GB;
603  Ssfdc.Attribute = FLASH | AD4CYC | BS32 | PS512;
604  Ssfdc.MaxZones = 128;
605  Ssfdc.MaxBlocks = 1024;
606  Ssfdc.MaxLogBlocks = 1000;
607  Ssfdc.MaxSectors = 32;
608  break;
609  default:
610  Ssfdc.Model = NOSSFDC;
611  return ERROR;
612  }
613 
614  return SMSUCCESS;
615 }
616 
617 /* ----- _Check_D_DevCode() --------------------------------------------- */
618 BYTE _Check_D_DevCode(BYTE dcode)
619 {
620  switch (dcode) {
621  case 0x6E:
622  case 0xE8:
623  case 0xEC: return SSFDC1MB; /* 8Mbit (1M) NAND */
624  case 0x64:
625  case 0xEA: return SSFDC2MB; /* 16Mbit (2M) NAND */
626  case 0x6B:
627  case 0xE3:
628  case 0xE5: return SSFDC4MB; /* 32Mbit (4M) NAND */
629  case 0xE6: return SSFDC8MB; /* 64Mbit (8M) NAND */
630  case 0x73: return SSFDC16MB; /* 128Mbit (16M)NAND */
631  case 0x75: return SSFDC32MB; /* 256Mbit (32M)NAND */
632  case 0x76: return SSFDC64MB; /* 512Mbit (64M)NAND */
633  case 0x79: return SSFDC128MB; /* 1Gbit(128M)NAND */
634  case 0x71: return SSFDC256MB;
635  case 0xDC: return SSFDC512MB;
636  case 0xD3: return SSFDC1GB;
637  case 0xD5: return SSFDC2GB;
638  default: return NOSSFDC;
639  }
640 }
641 
642 
643 
644 
645 /* SmartMedia ECC Control Subroutine
646  * ----- Check_D_ReadError() ----------------------------------------------
647  */
648 int Check_D_ReadError(BYTE *redundant)
649 {
650  return SMSUCCESS;
651 }
652 
653 /* ----- Check_D_Correct() ---------------------------------------------- */
654 int Check_D_Correct(BYTE *buf, BYTE *redundant)
655 {
656  return SMSUCCESS;
657 }
658 
659 /* ----- Check_D_CISdata() ---------------------------------------------- */
660 int Check_D_CISdata(BYTE *buf, BYTE *redundant)
661 {
662  BYTE cis[] = {0x01, 0x03, 0xD9, 0x01, 0xFF, 0x18, 0x02,
663  0xDF, 0x01, 0x20};
664 
665  int cis_len = sizeof(cis);
666 
667  if (!IsSSFDCCompliance && !IsXDCompliance)
668  return SMSUCCESS;
669 
670  if (!memcmp(redundant + 0x0D, EccBuf, 3))
671  return memcmp(buf, cis, cis_len);
672 
673  if (!_Correct_D_SwECC(buf, redundant + 0x0D, EccBuf))
674  return memcmp(buf, cis, cis_len);
675 
676  buf += 0x100;
677  if (!memcmp(redundant + 0x08, EccBuf + 0x03, 3))
678  return memcmp(buf, cis, cis_len);
679 
680  if (!_Correct_D_SwECC(buf, redundant + 0x08, EccBuf + 0x03))
681  return memcmp(buf, cis, cis_len);
682 
683  return ERROR;
684 }
685 
686 /* ----- Set_D_RightECC() ---------------------------------------------- */
687 void Set_D_RightECC(BYTE *redundant)
688 {
689  /* Driver ECC Check */
690  return;
691 }
692 
693 
Generated on Thu Jan 10 2013 14:29:02 for Linux Kernel by   doxygen 1.8.2