153 */ |
153 */ |
154 |
154 |
155 |
155 |
156 int nvram_open(void) |
156 int nvram_open(void) |
157 { |
157 { |
|
158 int n = NVRAM_BLOCK_SIZE / sizeof(unsigned int); |
|
159 |
158 /* some actions to initialise the flash */ |
160 /* some actions to initialise the flash */ |
159 data_len = 0; |
161 data_len = 0; |
160 |
162 data_num_pages = 0; |
161 data_addr = 0; |
163 |
162 |
164 data_page = (unsigned int *)malloc(sizeof(unsigned int) * n); |
163 data_page = (unsigned int *)malloc(sizeof(unsigned int) * 64); |
165 memset(data_page, 0, sizeof(unsigned int)*n); |
164 memset(data_page, 0, sizeof(unsigned int)*64); |
|
165 |
166 |
166 if (data_page == NULL) |
167 if (data_page == NULL) |
167 return -1; |
168 return -1; |
168 |
169 |
|
170 regs_page = (unsigned int *)malloc(sizeof(unsigned int) * n); |
|
171 memset(regs_page, 0, sizeof(unsigned int)*n); |
|
172 if (regs_page == NULL) |
|
173 return -2; |
|
174 |
|
175 iat_flash_read_regs(); |
|
176 |
|
177 /* start the data at the location specified in the registers */ |
|
178 if (0) /* for now it is 0, but put here a test to know whether |
|
179 or not the NVRAM has been written before */ |
|
180 data_addr = regs_page[1]; |
|
181 else |
|
182 data_addr = NVRAM_BLOCK_SIZE; /* let start at block 1 */ |
|
183 |
169 return 0; |
184 return 0; |
170 } |
185 } |
171 |
186 |
172 |
187 |
173 void nvram_close(void) |
188 void nvram_close(void) |
174 { |
189 { |
|
190 /* write the last page before closing */ |
|
191 iat_flash_write_page(data_addr); |
|
192 |
175 /* some actions to end accessing the flash */ |
193 /* some actions to end accessing the flash */ |
176 free(data_page); |
194 free(data_page); |
|
195 |
|
196 regs_page[4] = data_num_pages; |
|
197 /* write the registers to the NVRAM before closing */ |
|
198 iat_flash_write_regs(); |
|
199 free(regs_page); |
|
200 } |
|
201 |
|
202 |
|
203 void nvram_set_pos(UNS32 pos) |
|
204 /* set the current position in the NVRAM to pos */ |
|
205 { |
|
206 } |
|
207 |
|
208 |
|
209 void nvram_new_firmwave() |
|
210 { |
|
211 /* |
|
212 this function is called whenever a new firmware is about |
|
213 to be written in the NVRAM |
|
214 */ |
|
215 data_addr = regs_page[1] + regs_page[4]*NVRAM_BLOCK_SIZE; |
|
216 if (data_addr > NVRAM_MAX_SIZE) |
|
217 data_addr = NVRAM_BLOCK_SIZE; |
177 } |
218 } |
178 |
219 |
179 int _get_data_len(int type) |
220 int _get_data_len(int type) |
180 { |
221 { |
181 int len = 0; /* number of bytes */ |
222 int len = 0; /* number of bytes */ |
231 |
272 |
232 return len; |
273 return len; |
233 } |
274 } |
234 |
275 |
235 |
276 |
236 char nvram_write(int type, int access_attr, void *data) |
277 char nvram_write_data(int type, int access_attr, void *data) |
237 /* return 0 if successfull */ |
278 /* return 0 if successfull */ |
238 { |
279 { |
239 int len = _get_data_len(type); |
280 int len = _get_data_len(type); |
240 |
281 |
241 if (data_len+len > 256) |
282 if (data_len+len > NVRAM_BLOCK_SIZE) |
242 { |
283 { |
243 iat_flash_write_page(data_addr); |
284 iat_flash_write_page(data_addr); |
244 data_len = 0; |
285 data_len = 0; |
245 data_addr += 256; |
286 data_addr += NVRAM_BLOCK_SIZE; |
|
287 |
|
288 /* wrap-around address pointer */ |
|
289 if (data_addr > NVRAM_MAX_SIZE) |
|
290 data_addr = NVRAM_BLOCK_SIZE; |
|
291 |
|
292 data_num_pages++; |
246 } |
293 } |
247 |
294 |
248 memcpy(((char *)data_page)+data_len, data, len); |
295 memcpy(((char *)data_page)+data_len, data, len); |
249 |
296 |
250 data_len += len; |
297 data_len += len; |
251 |
298 |
252 return 0; |
299 return 0; |
253 } |
300 } |
254 |
301 |
255 |
302 |
256 char nvram_read(int type, int access_attr, void *data) |
303 char nvram_read_data(int type, int access_attr, void *data) |
257 /* return 0 if successful */ |
304 /* return 0 if successful */ |
258 { |
305 { |
259 int len = _get_data_len(type); |
306 int len = _get_data_len(type); |
260 |
307 |
261 if (data_len+len > 256) |
308 if (data_len+len > NVRAM_BLOCK_SIZE) |
262 { |
309 { |
263 data_addr += 256; |
310 data_addr += NVRAM_BLOCK_SIZE; |
|
311 |
|
312 /* wrap-around address pointer */ |
|
313 if (data_addr > NVRAM_MAX_SIZE) |
|
314 data_addr = NVRAM_BLOCK_SIZE; |
|
315 |
264 iat_flash_read_page(data_addr); |
316 iat_flash_read_page(data_addr); |
265 data_len = 0; |
317 data_len = 0; |
266 } |
318 } |
267 |
319 |
268 memcpy(data, ((char *)data_page)+data_len, len); |
320 memcpy(data, ((char *)data_page)+data_len, len); |
270 data_len += len; |
322 data_len += len; |
271 |
323 |
272 return 0; |
324 return 0; |
273 } |
325 } |
274 |
326 |
|
327 /* |
|
328 NVRAM registers at block 0 |
|
329 pos description |
|
330 0 version of the current dictionnary |
|
331 1 starting address for data block |
|
332 2 date of last writing |
|
333 3 address of the previous dictionnary |
|
334 4 size in pages of the current dict |
|
335 */ |
|
336 void nvram_write_reg(UNS32 reg, UNS16 pos) |
|
337 /* write reg at the position in the data block 0 */ |
|
338 { |
|
339 regs_page[pos] = reg; |
|
340 } |
|
341 |
|
342 UNS32 nvram_read_reg(UNS16 pos) |
|
343 /* read reg at the position in the data block 0 */ |
|
344 { |
|
345 return regs_page[pos]; |
|
346 } |
|
347 |
275 |
348 |
276 /* |
349 /* |
277 LED |
350 LED |
278 */ |
351 */ |
279 |
352 |
280 void led_set_redgreen(unsigned char bits) |
353 void led_set_redgreen(UNS8 bits) |
|
354 /* bits : each bit of this uns8 is assigned a led |
|
355 0=off, 1=on |
|
356 */ |
281 { |
357 { |
282 lpc2138_redgreenled_set(bits); |
358 lpc2138_redgreenled_set(bits); |
283 } |
359 } |
284 |
360 |