diff options
author | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
---|---|---|
committer | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
commit | fcc9d2e5a6c89d22b8b773a64fb4ad21ac318446 (patch) | |
tree | a57612d1888735a2ec7972891b68c1ac5ec8faea /drivers/staging/spectra/lld.c | |
parent | 8dea78da5cee153b8af9c07a2745f6c55057fe12 (diff) |
Diffstat (limited to 'drivers/staging/spectra/lld.c')
-rw-r--r-- | drivers/staging/spectra/lld.c | 339 |
1 files changed, 339 insertions, 0 deletions
diff --git a/drivers/staging/spectra/lld.c b/drivers/staging/spectra/lld.c new file mode 100644 index 00000000000..5c3b9762dc3 --- /dev/null +++ b/drivers/staging/spectra/lld.c | |||
@@ -0,0 +1,339 @@ | |||
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 | |||
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 */ | ||
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 | { | ||
221 | return nand_release_spectra(); | ||
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 | |||
281 | #if CMD_DMA | ||
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 | |||
334 | #endif /* CMD_DMA */ | ||
335 | #endif /* FLASH_NAND */ | ||
336 | |||
337 | /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/ | ||
338 | |||
339 | /* end of LLD.c */ | ||