summaryrefslogtreecommitdiff
path: root/drivers/staging/keucr/smil.h
blob: 24a636a4aa1c0f26c4a32f05e2b83f8368c32029 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
/*----- < smil.h> ----------------------------------------------------*/
#ifndef SMIL_INCD
#define SMIL_INCD

/***************************************************************************
Define Definition
***************************************************************************/
#define K_BYTE              1024   /* Kilo Byte */
#define SECTSIZE            512    /* Sector buffer size */
#define REDTSIZE            16     /* Redundant buffer size */

/***************************************************************************/
#define DUMMY_DATA          0xFF   /* No Assign Sector Read Data */

/***************************************************************************
Max Zone/Block/Sectors Data Definition
***************************************************************************/
#define MAX_ZONENUM         128    /* Max Zone Numbers in a SmartMedia    */
#define MAX_BLOCKNUM        0x0400 /* Max Block Numbers in a Zone         */
#define MAX_SECTNUM         0x20   /* Max Sector Numbers in a Block       */
#define MAX_LOGBLOCK        1000   /* Max Logical Block Numbers in a Zone */

/***************************************************************************/
#define CIS_SEARCH_SECT     0x08   /* Max CIS Search Sector Number */

/***************************************************************************
Logical to Physical Block Table Data Definition
***************************************************************************/
#define NO_ASSIGN           0xFFFF /* No Assign Logical Block Address */

/***************************************************************************
'SectCopyMode' Data
***************************************************************************/
#define COMPLETED           0      /* Sector Copy Completed */
#define REQ_ERASE           1      /* Request Read Block Erase */
#define REQ_FAIL            2      /* Request Read Block Failed */

/***************************************************************************
Retry Counter Definition
***************************************************************************/
#define RDERR_REASSIGN      1      /* Reassign with Read Error */
#define L2P_ERR_ERASE       1      /* BlockErase for Contradicted L2P Table */

/***************************************************************************
Hardware ECC Definition
***************************************************************************/
#define HW_ECC_SUPPORTED    1	   /* Hardware ECC Supported */
/* No difinition for Software ECC */

/***************************************************************************
SmartMedia Command & Status Definition
***************************************************************************/
/* SmartMedia Command */
#define WRDATA        0x80
/* #define READ          0x00 */
#define READ_REDT     0x50
/* #define WRITE         0x10 */
#define RDSTATUS      0x70

#define READ1         0x00 /* NO */
#define READ2         0x01 /* NO */
#define READ3         0x50 /* NO */
#define RST_CHIP      0xFF
#define ERASE1        0x60
#define ERASE2        0xD0
#define READ_ID_1     0x90
#define READ_ID_2     0x91
#define READ_ID_3     0x9A

/* 712 SmartMedia Command */
#define SM_CMD_RESET                0x00    /* 0xFF */
#define SM_CMD_READ_ID_1            0x10    /* 0x90 */
#define SM_CMD_READ_ID_2            0x20    /* 0x91 */
#define SM_CMD_READ_STAT            0x30    /* 0x70 */
#define SM_CMD_RDMULTPL_STAT        0x40    /* 0x71 */
#define SM_CMD_READ_1               0x50    /* 0x00 */
#define SM_CMD_READ_2               0x60    /* 0x01 */
#define SM_CMD_READ_3               0x70    /* 0x50 */
#define SM_CMD_PAGPRGM_TRUE         0x80    /* {0x80, 0x10} */
#define SM_CMD_PAGPRGM_DUMY         0x90    /* {0x80, 0x11} */
#define SM_CMD_PAGPRGM_MBLK         0xA0    /* {0x80, 0x15} */
#define SM_CMD_BLKERASE             0xB0    /* {0x60, 0xD0} */
#define SM_CMD_BLKERASE_MULTPL      0xC0    /* {0x60-0x60, 0xD0} */

#define SM_CRADDTCT_DEBNCETIMER_EN  0x02
#define SM_CMD_START_BIT            0x01

#define SM_WaitCmdDone { while (!SM_CmdDone); }
#define SM_WaitDmaDone { while (!SM_DmaDone); }

/* SmartMedia Status */
#define WR_FAIL       0x01      /* 0:Pass, 1:Fail */
#define SUSPENDED     0x20      /* 0:Not Suspended, 1:Suspended */
#define READY         0x40      /* 0:Busy, 1:Ready */
#define WR_PRTCT      0x80      /* 0:Protect, 1:Not Protect */

/* SmartMedia Busy Time (1bit:0.1ms) */
#define BUSY_PROG 200 /* tPROG   : 20ms  ----- Program Time old : 200 */
#define BUSY_ERASE 4000 /* tBERASE : 400ms ----- Block Erase Time old : 4000 */

/*for 712 Test */
/* #define BUSY_READ 1 *//* tR : 100us ----- Data transfer Time   old : 1 */
/* #define BUSY_READ 10 *//* tR : 100us ----- Data transfer Time   old : 1 */

#define BUSY_READ 200 /* tR : 20ms   ----- Data transfer Time   old : 1 */

/* #define BUSY_RESET 60 *//* tRST : 6ms ----- Device Resetting Time old : 60 */

#define BUSY_RESET 600 /* tRST : 60ms   ----- Device Resetting Time old : 60 */

/* Hardware Timer (1bit:0.1ms) */
#define TIME_PON      3000      /* 300ms ------ Power On Wait Time */
#define TIME_CDCHK    200       /* 20ms  ------ Card Check Interval Timer */
#define TIME_WPCHK    50        /* 5ms   ------ WP Check Interval Timer */
#define TIME_5VCHK    10        /* 1ms   ------ 5V Check Interval Timer */

/***************************************************************************
Redundant Data
***************************************************************************/
#define REDT_DATA     0x04
#define REDT_BLOCK    0x05
#define REDT_ADDR1H   0x06
#define REDT_ADDR1L   0x07
#define REDT_ADDR2H   0x0B
#define REDT_ADDR2L   0x0C
#define REDT_ECC10    0x0D
#define REDT_ECC11    0x0E
#define REDT_ECC12    0x0F
#define REDT_ECC20    0x08
#define REDT_ECC21    0x09
#define REDT_ECC22    0x0A

/***************************************************************************
SmartMedia Model & Attribute
***************************************************************************/
/* SmartMedia Attribute */
#define NOWP          0x00 /* 0... .... No Write Protect */
#define WP            0x80 /* 1... .... Write Protected */
#define MASK          0x00 /* .00. .... NAND MASK ROM Model */
#define FLASH         0x20 /* .01. .... NAND Flash ROM Model */
#define AD3CYC        0x00 /* ...0 .... Address 3-cycle */
#define AD4CYC        0x10 /* ...1 .... Address 4-cycle */
#define BS16          0x00 /* .... 00.. 16page/block */
#define BS32          0x04 /* .... 01.. 32page/block */
#define PS256         0x00 /* .... ..00 256byte/page */
#define PS512         0x01 /* .... ..01 512byte/page */
#define MWP           0x80 /* WriteProtect mask */
#define MFLASH        0x60 /* Flash Rom mask */
#define MADC          0x10 /* Address Cycle */
#define MBS           0x0C /* BlockSize mask */
#define MPS           0x03 /* PageSize mask */

/* SmartMedia Model */
#define NOSSFDC       0x00 /* NO   SmartMedia */
#define SSFDC1MB      0x01 /* 1MB  SmartMedia */
#define SSFDC2MB      0x02 /* 2MB  SmartMedia */
#define SSFDC4MB      0x03 /* 4MB  SmartMedia */
#define SSFDC8MB      0x04 /* 8MB  SmartMedia */
#define SSFDC16MB     0x05 /* 16MB SmartMedia */
#define SSFDC32MB     0x06 /* 32MB SmartMedia */
#define SSFDC64MB     0x07 /* 64MB SmartMedia */
#define SSFDC128MB    0x08 /*128MB SmartMedia */
#define SSFDC256MB    0x09
#define SSFDC512MB    0x0A
#define SSFDC1GB      0x0B
#define SSFDC2GB      0x0C

/***************************************************************************
Struct Definition
***************************************************************************/
struct SSFDCTYPE {
	BYTE Model;
	BYTE Attribute;
	BYTE MaxZones;
	BYTE MaxSectors;
	WORD MaxBlocks;
	WORD MaxLogBlocks;
};

typedef struct SSFDCTYPE_T {
	BYTE Model;
	BYTE Attribute;
	BYTE MaxZones;
	BYTE MaxSectors;
	WORD MaxBlocks;
	WORD MaxLogBlocks;
} *SSFDCTYPE_T;

struct ADDRESS {
	BYTE Zone;	/* Zone Number */
	BYTE Sector;	/* Sector(512byte) Number on Block */
	WORD PhyBlock;	/* Physical Block Number on Zone */
	WORD LogBlock;	/* Logical Block Number of Zone */
};

typedef struct ADDRESS_T {
	BYTE Zone;	/* Zone Number */
	BYTE Sector;	/* Sector(512byte) Number on Block */
	WORD PhyBlock;	/* Physical Block Number on Zone */
	WORD LogBlock;	/* Logical Block Number of Zone */
} *ADDRESS_T;

struct CIS_AREA {
	BYTE Sector;	/* Sector(512byte) Number on Block */
	WORD PhyBlock;	/* Physical Block Number on Zone 0 */
};


extern BYTE IsSSFDCCompliance;
extern BYTE IsXDCompliance;

extern DWORD	ErrXDCode;
extern DWORD	ErrCode;
extern WORD	ReadBlock;
extern WORD	WriteBlock;
extern DWORD	MediaChange;

extern struct SSFDCTYPE  Ssfdc;
extern struct ADDRESS    Media;
extern struct CIS_AREA   CisArea;

/*
 * SMILMain.c
 */
/******************************************/
int         Init_D_SmartMedia(void);
int         Pwoff_D_SmartMedia(void);
int         Check_D_SmartMedia(void);
int         Check_D_Parameter(struct us_data *, WORD *, BYTE *, BYTE *);
int         Media_D_ReadSector(struct us_data *, DWORD, WORD, BYTE *);
int         Media_D_WriteSector(struct us_data *, DWORD, WORD, BYTE *);
int         Media_D_CopySector(struct us_data *, DWORD, WORD, BYTE *);
int         Media_D_EraseBlock(struct us_data *, DWORD, WORD);
int         Media_D_EraseAll(struct us_data *);
/******************************************/
int         Media_D_OneSectWriteStart(struct us_data *, DWORD, BYTE *);
int         Media_D_OneSectWriteNext(struct us_data *, BYTE *);
int         Media_D_OneSectWriteFlush(struct us_data *);

/******************************************/
extern int	SM_FreeMem(void);	/* ENE SM function */
void        SM_EnableLED(struct us_data *, BOOLEAN);
void        Led_D_TernOn(void);
void        Led_D_TernOff(void);

int         Media_D_EraseAllRedtData(DWORD Index, BOOLEAN CheckBlock);
/*DWORD Media_D_GetMediaInfo(struct us_data * fdoExt,
	PIOCTL_MEDIA_INFO_IN pParamIn, PIOCTL_MEDIA_INFO_OUT pParamOut); */

/*
 * SMILSub.c
 */
/******************************************/
int  Check_D_DataBlank(BYTE *);
int  Check_D_FailBlock(BYTE *);
int  Check_D_DataStatus(BYTE *);
int  Load_D_LogBlockAddr(BYTE *);
void Clr_D_RedundantData(BYTE *);
void Set_D_LogBlockAddr(BYTE *);
void Set_D_FailBlock(BYTE *);
void Set_D_DataStaus(BYTE *);

/******************************************/
void Ssfdc_D_Reset(struct us_data *);
int  Ssfdc_D_ReadCisSect(struct us_data *, BYTE *, BYTE *);
void Ssfdc_D_WriteRedtMode(void);
void Ssfdc_D_ReadID(BYTE *, BYTE);
int  Ssfdc_D_ReadSect(struct us_data *, BYTE *, BYTE *);
int  Ssfdc_D_ReadBlock(struct us_data *, WORD, BYTE *, BYTE *);
int  Ssfdc_D_WriteSect(struct us_data *, BYTE *, BYTE *);
int  Ssfdc_D_WriteBlock(struct us_data *, WORD, BYTE *, BYTE *);
int  Ssfdc_D_CopyBlock(struct us_data *, WORD, BYTE *, BYTE *);
int  Ssfdc_D_WriteSectForCopy(struct us_data *, BYTE *, BYTE *);
int  Ssfdc_D_EraseBlock(struct us_data *);
int  Ssfdc_D_ReadRedtData(struct us_data *, BYTE *);
int  Ssfdc_D_WriteRedtData(struct us_data *, BYTE *);
int  Ssfdc_D_CheckStatus(void);
int  Set_D_SsfdcModel(BYTE);
void Cnt_D_Reset(void);
int  Cnt_D_PowerOn(void);
void Cnt_D_PowerOff(void);
void Cnt_D_LedOn(void);
void Cnt_D_LedOff(void);
int  Check_D_CntPower(void);
int  Check_D_CardExist(void);
int  Check_D_CardStsChg(void);
int  Check_D_SsfdcWP(void);
int  SM_ReadBlock(struct us_data *, BYTE *, BYTE *);

int  Ssfdc_D_ReadSect_DMA(struct us_data *, BYTE *, BYTE *);
int  Ssfdc_D_ReadSect_PIO(struct us_data *, BYTE *, BYTE *);
int  Ssfdc_D_WriteSect_DMA(struct us_data *, BYTE *, BYTE *);
int  Ssfdc_D_WriteSect_PIO(struct us_data *, BYTE *, BYTE *);

/******************************************/
int  Check_D_ReadError(BYTE *);
int  Check_D_Correct(BYTE *, BYTE *);
int  Check_D_CISdata(BYTE *, BYTE *);
void Set_D_RightECC(BYTE *);

/*
 * SMILECC.c
 */
void calculate_ecc(BYTE *, BYTE *, BYTE *, BYTE *, BYTE *);
BYTE correct_data(BYTE *, BYTE *, BYTE,   BYTE,   BYTE);
int  _Correct_D_SwECC(BYTE *, BYTE *, BYTE *);
void _Calculate_D_SwECC(BYTE *, BYTE *);

void SM_Init(void);

#endif /* already included */