Commit | Line | Data |
---|---|---|
494a43bb AO |
1 | /* |
2 | * NAND Flash Controller Device Driver | |
3 | * Copyright (c) 2009, Intel Corporation and its suppliers. | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify it | |
6 | * under the terms and conditions of the GNU General Public License, | |
7 | * version 2, as published by the Free Software Foundation. | |
8 | * | |
9 | * This program is distributed in the hope it will be useful, but WITHOUT | |
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
12 | * more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License along with | |
15 | * this program; if not, write to the Free Software Foundation, Inc., | |
16 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | |
17 | * | |
18 | */ | |
19 | ||
20 | #include "spectraswconfig.h" | |
21 | #include "ffsport.h" | |
22 | #include "ffsdefs.h" | |
23 | #include "lld.h" | |
24 | #include "lld_nand.h" | |
25 | ||
26 | /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/ | |
27 | #if FLASH_EMU /* vector all the LLD calls to the LLD_EMU code */ | |
28 | #include "lld_emu.h" | |
29 | #include "lld_cdma.h" | |
30 | ||
31 | /* common functions: */ | |
32 | u16 GLOB_LLD_Flash_Reset(void) | |
33 | { | |
34 | return emu_Flash_Reset(); | |
35 | } | |
36 | ||
37 | u16 GLOB_LLD_Read_Device_ID(void) | |
38 | { | |
39 | return emu_Read_Device_ID(); | |
40 | } | |
41 | ||
42 | int GLOB_LLD_Flash_Release(void) | |
43 | { | |
44 | return emu_Flash_Release(); | |
45 | } | |
46 | ||
47 | u16 GLOB_LLD_Flash_Init(void) | |
48 | { | |
49 | return emu_Flash_Init(); | |
50 | } | |
51 | ||
52 | u16 GLOB_LLD_Erase_Block(u32 block_add) | |
53 | { | |
54 | return emu_Erase_Block(block_add); | |
55 | } | |
56 | ||
57 | u16 GLOB_LLD_Write_Page_Main(u8 *write_data, u32 block, u16 Page, | |
58 | u16 PageCount) | |
59 | { | |
60 | return emu_Write_Page_Main(write_data, block, Page, PageCount); | |
61 | } | |
62 | ||
63 | u16 GLOB_LLD_Read_Page_Main(u8 *read_data, u32 block, u16 Page, | |
64 | u16 PageCount) | |
65 | { | |
66 | return emu_Read_Page_Main(read_data, block, Page, PageCount); | |
67 | } | |
68 | ||
69 | u16 GLOB_LLD_Read_Page_Main_Polling(u8 *read_data, | |
70 | u32 block, u16 page, u16 page_count) | |
71 | { | |
72 | return emu_Read_Page_Main(read_data, block, page, page_count); | |
73 | } | |
74 | ||
75 | u16 GLOB_LLD_Write_Page_Main_Spare(u8 *write_data, u32 block, | |
76 | u16 Page, u16 PageCount) | |
77 | { | |
78 | return emu_Write_Page_Main_Spare(write_data, block, Page, PageCount); | |
79 | } | |
80 | ||
81 | u16 GLOB_LLD_Read_Page_Main_Spare(u8 *read_data, u32 block, | |
82 | u16 Page, u16 PageCount) | |
83 | { | |
84 | return emu_Read_Page_Main_Spare(read_data, block, Page, PageCount); | |
85 | } | |
86 | ||
87 | u16 GLOB_LLD_Write_Page_Spare(u8 *write_data, u32 block, u16 Page, | |
88 | u16 PageCount) | |
89 | { | |
90 | return emu_Write_Page_Spare(write_data, block, Page, PageCount); | |
91 | } | |
92 | ||
93 | u16 GLOB_LLD_Read_Page_Spare(u8 *read_data, u32 block, u16 Page, | |
94 | u16 PageCount) | |
95 | { | |
96 | return emu_Read_Page_Spare(read_data, block, Page, PageCount); | |
97 | } | |
98 | ||
99 | u16 GLOB_LLD_Get_Bad_Block(u32 block) | |
100 | { | |
101 | return emu_Get_Bad_Block(block); | |
102 | } | |
103 | ||
104 | #endif /* FLASH_EMU */ | |
105 | ||
b589aece DW |
106 | /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/ |
107 | #if FLASH_MTD /* vector all the LLD calls to the LLD_MTD code */ | |
108 | #include "lld_mtd.h" | |
109 | #include "lld_cdma.h" | |
110 | ||
111 | /* common functions: */ | |
112 | u16 GLOB_LLD_Flash_Reset(void) | |
113 | { | |
114 | return mtd_Flash_Reset(); | |
115 | } | |
116 | ||
117 | u16 GLOB_LLD_Read_Device_ID(void) | |
118 | { | |
119 | return mtd_Read_Device_ID(); | |
120 | } | |
121 | ||
122 | int GLOB_LLD_Flash_Release(void) | |
123 | { | |
124 | return mtd_Flash_Release(); | |
125 | } | |
126 | ||
127 | u16 GLOB_LLD_Flash_Init(void) | |
128 | { | |
129 | return mtd_Flash_Init(); | |
130 | } | |
131 | ||
132 | u16 GLOB_LLD_Erase_Block(u32 block_add) | |
133 | { | |
134 | return mtd_Erase_Block(block_add); | |
135 | } | |
136 | ||
137 | u16 GLOB_LLD_Write_Page_Main(u8 *write_data, u32 block, u16 Page, | |
138 | u16 PageCount) | |
139 | { | |
140 | return mtd_Write_Page_Main(write_data, block, Page, PageCount); | |
141 | } | |
142 | ||
143 | u16 GLOB_LLD_Read_Page_Main(u8 *read_data, u32 block, u16 Page, | |
144 | u16 PageCount) | |
145 | { | |
146 | return mtd_Read_Page_Main(read_data, block, Page, PageCount); | |
147 | } | |
148 | ||
149 | u16 GLOB_LLD_Read_Page_Main_Polling(u8 *read_data, | |
150 | u32 block, u16 page, u16 page_count) | |
151 | { | |
152 | return mtd_Read_Page_Main(read_data, block, page, page_count); | |
153 | } | |
154 | ||
155 | u16 GLOB_LLD_Write_Page_Main_Spare(u8 *write_data, u32 block, | |
156 | u16 Page, u16 PageCount) | |
157 | { | |
158 | return mtd_Write_Page_Main_Spare(write_data, block, Page, PageCount); | |
159 | } | |
160 | ||
161 | u16 GLOB_LLD_Read_Page_Main_Spare(u8 *read_data, u32 block, | |
162 | u16 Page, u16 PageCount) | |
163 | { | |
164 | return mtd_Read_Page_Main_Spare(read_data, block, Page, PageCount); | |
165 | } | |
166 | ||
167 | u16 GLOB_LLD_Write_Page_Spare(u8 *write_data, u32 block, u16 Page, | |
168 | u16 PageCount) | |
169 | { | |
170 | return mtd_Write_Page_Spare(write_data, block, Page, PageCount); | |
171 | } | |
172 | ||
173 | u16 GLOB_LLD_Read_Page_Spare(u8 *read_data, u32 block, u16 Page, | |
174 | u16 PageCount) | |
175 | { | |
176 | return mtd_Read_Page_Spare(read_data, block, Page, PageCount); | |
177 | } | |
178 | ||
179 | u16 GLOB_LLD_Get_Bad_Block(u32 block) | |
180 | { | |
181 | return mtd_Get_Bad_Block(block); | |
182 | } | |
183 | ||
184 | #endif /* FLASH_MTD */ | |
494a43bb AO |
185 | |
186 | /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/ | |
187 | #if FLASH_NAND /* vector all the LLD calls to the NAND controller code */ | |
188 | #include "lld_nand.h" | |
189 | #include "lld_cdma.h" | |
190 | #include "flash.h" | |
191 | ||
192 | /* common functions for LLD_NAND */ | |
193 | void GLOB_LLD_ECC_Control(int enable) | |
194 | { | |
195 | NAND_ECC_Ctrl(enable); | |
196 | } | |
197 | ||
198 | /* common functions for LLD_NAND */ | |
199 | u16 GLOB_LLD_Flash_Reset(void) | |
200 | { | |
201 | return NAND_Flash_Reset(); | |
202 | } | |
203 | ||
204 | u16 GLOB_LLD_Read_Device_ID(void) | |
205 | { | |
206 | return NAND_Read_Device_ID(); | |
207 | } | |
208 | ||
209 | u16 GLOB_LLD_UnlockArrayAll(void) | |
210 | { | |
211 | return NAND_UnlockArrayAll(); | |
212 | } | |
213 | ||
214 | u16 GLOB_LLD_Flash_Init(void) | |
215 | { | |
216 | return NAND_Flash_Init(); | |
217 | } | |
218 | ||
219 | int GLOB_LLD_Flash_Release(void) | |
220 | { | |
0dba333c | 221 | return nand_release_spectra(); |
494a43bb AO |
222 | } |
223 | ||
224 | u16 GLOB_LLD_Erase_Block(u32 block_add) | |
225 | { | |
226 | return NAND_Erase_Block(block_add); | |
227 | } | |
228 | ||
229 | ||
230 | u16 GLOB_LLD_Write_Page_Main(u8 *write_data, u32 block, u16 Page, | |
231 | u16 PageCount) | |
232 | { | |
233 | return NAND_Write_Page_Main(write_data, block, Page, PageCount); | |
234 | } | |
235 | ||
236 | u16 GLOB_LLD_Read_Page_Main(u8 *read_data, u32 block, u16 page, | |
237 | u16 page_count) | |
238 | { | |
239 | if (page_count == 1) /* Using polling to improve read speed */ | |
240 | return NAND_Read_Page_Main_Polling(read_data, block, page, 1); | |
241 | else | |
242 | return NAND_Read_Page_Main(read_data, block, page, page_count); | |
243 | } | |
244 | ||
245 | u16 GLOB_LLD_Read_Page_Main_Polling(u8 *read_data, | |
246 | u32 block, u16 page, u16 page_count) | |
247 | { | |
248 | return NAND_Read_Page_Main_Polling(read_data, | |
249 | block, page, page_count); | |
250 | } | |
251 | ||
252 | u16 GLOB_LLD_Write_Page_Main_Spare(u8 *write_data, u32 block, | |
253 | u16 Page, u16 PageCount) | |
254 | { | |
255 | return NAND_Write_Page_Main_Spare(write_data, block, Page, PageCount); | |
256 | } | |
257 | ||
258 | u16 GLOB_LLD_Write_Page_Spare(u8 *write_data, u32 block, u16 Page, | |
259 | u16 PageCount) | |
260 | { | |
261 | return NAND_Write_Page_Spare(write_data, block, Page, PageCount); | |
262 | } | |
263 | ||
264 | u16 GLOB_LLD_Read_Page_Main_Spare(u8 *read_data, u32 block, | |
265 | u16 page, u16 page_count) | |
266 | { | |
267 | return NAND_Read_Page_Main_Spare(read_data, block, page, page_count); | |
268 | } | |
269 | ||
270 | u16 GLOB_LLD_Read_Page_Spare(u8 *read_data, u32 block, u16 Page, | |
271 | u16 PageCount) | |
272 | { | |
273 | return NAND_Read_Page_Spare(read_data, block, Page, PageCount); | |
274 | } | |
275 | ||
276 | u16 GLOB_LLD_Get_Bad_Block(u32 block) | |
277 | { | |
278 | return NAND_Get_Bad_Block(block); | |
279 | } | |
280 | ||
4087524f | 281 | #if CMD_DMA |
494a43bb AO |
282 | u16 GLOB_LLD_Event_Status(void) |
283 | { | |
284 | return CDMA_Event_Status(); | |
285 | } | |
286 | ||
287 | u16 glob_lld_execute_cmds(void) | |
288 | { | |
289 | return CDMA_Execute_CMDs(); | |
290 | } | |
291 | ||
292 | u16 GLOB_LLD_MemCopy_CMD(u8 *dest, u8 *src, | |
293 | u32 ByteCount, u16 flag) | |
294 | { | |
295 | /* Replace the hardware memcopy with software memcpy function */ | |
296 | if (CDMA_Execute_CMDs()) | |
297 | return FAIL; | |
298 | memcpy(dest, src, ByteCount); | |
299 | return PASS; | |
300 | ||
301 | /* return CDMA_MemCopy_CMD(dest, src, ByteCount, flag); */ | |
302 | } | |
303 | ||
304 | u16 GLOB_LLD_Erase_Block_cdma(u32 block, u16 flags) | |
305 | { | |
306 | return CDMA_Data_CMD(ERASE_CMD, 0, block, 0, 0, flags); | |
307 | } | |
308 | ||
309 | u16 GLOB_LLD_Write_Page_Main_cdma(u8 *data, u32 block, u16 page, u16 count) | |
310 | { | |
311 | return CDMA_Data_CMD(WRITE_MAIN_CMD, data, block, page, count, 0); | |
312 | } | |
313 | ||
314 | u16 GLOB_LLD_Read_Page_Main_cdma(u8 *data, u32 block, u16 page, | |
315 | u16 count, u16 flags) | |
316 | { | |
317 | return CDMA_Data_CMD(READ_MAIN_CMD, data, block, page, count, flags); | |
318 | } | |
319 | ||
320 | u16 GLOB_LLD_Write_Page_Main_Spare_cdma(u8 *data, u32 block, u16 page, | |
321 | u16 count, u16 flags) | |
322 | { | |
323 | return CDMA_Data_CMD(WRITE_MAIN_SPARE_CMD, | |
324 | data, block, page, count, flags); | |
325 | } | |
326 | ||
327 | u16 GLOB_LLD_Read_Page_Main_Spare_cdma(u8 *data, | |
328 | u32 block, u16 page, u16 count) | |
329 | { | |
330 | return CDMA_Data_CMD(READ_MAIN_SPARE_CMD, data, block, page, count, | |
331 | LLD_CMD_FLAG_MODE_CDMA); | |
332 | } | |
333 | ||
4087524f | 334 | #endif /* CMD_DMA */ |
494a43bb AO |
335 | #endif /* FLASH_NAND */ |
336 | ||
337 | /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/ | |
338 | ||
339 | /* end of LLD.c */ |