flash.c

Revision 12281, 16.1 kB (checked in by BrainSlayer, 5 months ago)
MicroRedBoot v1.2 source release (for ar5315/16/17/18 based devices)

Line
1	//==========================================================================
2	//
3	// flash.c
4	//
5	// Flash programming
6	//
7	//==========================================================================
8	//####ECOSGPLCOPYRIGHTBEGIN####
9	// -------------------------------------------
10	// This file is part of eCos, the Embedded Configurable Operating System.
11	// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
12	// Copyright (C) 2003 Gary Thomas
13	//
14	// eCos is free software; you can redistribute it and/or modify it under
15	// the terms of the GNU General Public License as published by the Free
16	// Software Foundation; either version 2 or (at your option) any later version.
17	//
18	// eCos is distributed in the hope that it will be useful, but WITHOUT ANY
19	// WARRANTY; without even the implied warranty of MERCHANTABILITY or
20	// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21	// for more details.
22	//
23	// You should have received a copy of the GNU General Public License along
24	// with eCos; if not, write to the Free Software Foundation, Inc.,
25	// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
26	//
27	// As a special exception, if other files instantiate templates or use macros
28	// or inline functions from this file, or you compile this file and link it
29	// with other works to produce a work based on this file, this file does not
30	// by itself cause the resulting work to be covered by the GNU General Public
31	// License. However the source code for this file must still be made available
32	// in accordance with section (3) of the GNU General Public License.
33	//
34	// This exception does not invalidate any other reasons why a work based on
35	// this file might be covered by the GNU General Public License.
36	//
37	// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
38	// at http://sources.redhat.com/ecos/ecos-license/
39	// -------------------------------------------
40	//####ECOSGPLCOPYRIGHTEND####
41	//==========================================================================
42	//#####DESCRIPTIONBEGIN####
43	//
44	// Author(s): gthomas
45	// Contributors: gthomas
46	// Date: 2000-07-26
47	// Purpose:
48	// Description:
49	//
50	//####DESCRIPTIONEND####
51	//
52	//==========================================================================
53
54	#include <pkgconf/system.h>
55	#include <pkgconf/io_flash.h>
56
57	#include <cyg/hal/hal_arch.h>
58	#include <cyg/hal/hal_intr.h>
59	#include <cyg/hal/hal_cache.h>
60	#include <string.h>
61
62	#define _FLASH_PRIVATE_
63	#include <cyg/io/flash.h>
64
65	// When this flag is set, do not actually jump to the relocated code.
66	// This can be used for running the function in place (RAM startup only),
67	// allowing calls to diag_printf() and similar.
68	#undef RAM_FLASH_DEV_DEBUG
69	#if !defined(CYG_HAL_STARTUP_RAM) && defined(RAM_FLASH_DEV_DEBUG)
70	# warning "Can only enable the flash debugging when configured for RAM startup"
71	#endif
72
73	struct flash_info flash_info;
74
75	// These are the functions in the HW specific driver we need to call.
76	typedef void code_fun(void*);
77
78	externC code_fun flash_query;
79	externC code_fun flash_erase_block;
80	externC code_fun flash_program_buf;
81	externC code_fun flash_read_buf;
82	externC code_fun flash_lock_block;
83	externC code_fun flash_unlock_block;
84
85	int
86	flash_init(_printf *pf)
87	{
88	int err;
89
90	if (flash_info.init) return FLASH_ERR_OK;
91	flash_info.pf = pf; // Do this before calling into the driver
92	if ((err = flash_hwr_init()) != FLASH_ERR_OK) {
93	return err;
94	}
95	flash_info.block_mask = ~(flash_info.block_size-1);
96	flash_info.init = 1;
97	return FLASH_ERR_OK;
98	}
99
100	// Use this function to make function pointers anonymous - forcing the
101	// compiler to use jumps instead of branches when calling driver
102	// services.
103	static void* __anonymizer(void* p)
104	{
105	return p;
106	}
107
108	// FIXME: Want to change all drivers to use this function. But it may
109	// make sense to wait till device structure pointer arguments get
110	// added as well.
111	void
112	flash_dev_query(void* data)
113	{
114	typedef void code_fun(void*);
115	code_fun *_flash_query;
116	int d_cache, i_cache;
117
118	_flash_query = (code_fun*) __anonymizer(&flash_query);
119
120	HAL_FLASH_CACHES_OFF(d_cache, i_cache);
121	(*_flash_query)(data);
122	HAL_FLASH_CACHES_ON(d_cache, i_cache);
123	}
124
125	int
126	flash_verify_addr(void *target)
127	{
128	if (!flash_info.init) {
129	return FLASH_ERR_NOT_INIT;
130	}
131	if (((CYG_ADDRESS)target >= (CYG_ADDRESS)flash_info.start) &&
132	((CYG_ADDRESS)target <= ( ((CYG_ADDRESS)flash_info.end) - 1) )) {
133	return FLASH_ERR_OK;
134	} else {
135	return FLASH_ERR_INVALID;
136	}
137	}
138
139	int
140	flash_get_limits(void target, void start, void *end)
141	{
142	if (!flash_info.init) {
143	return FLASH_ERR_NOT_INIT;
144	}
145	*start = flash_info.start;
146	*end = flash_info.end;
147	return FLASH_ERR_OK;
148	}
149
150	int
151	flash_get_block_info(int block_size, int blocks)
152	{
153	if (!flash_info.init) {
154	return FLASH_ERR_NOT_INIT;
155	}
156	*block_size = flash_info.block_size;
157	*blocks = flash_info.blocks;
158	return FLASH_ERR_OK;
159	}
160
161	int
162	flash_erase(void addr, int len, void *err_addr)
163	{
164	unsigned short block, end_addr;
165	int stat = 0;
166	typedef int code_fun(unsigned short *, unsigned int);
167	code_fun *_flash_erase_block;
168	int d_cache, i_cache;
169
170	if (!flash_info.init) {
171	return FLASH_ERR_NOT_INIT;
172	}
173
174	#ifdef CYGSEM_IO_FLASH_SOFT_WRITE_PROTECT
175	if (plf_flash_query_soft_wp(addr,len))
176	return FLASH_ERR_PROTECT;
177	#endif
178
179	_flash_erase_block = (code_fun*) __anonymizer(&flash_erase_block);
180
181	block = (unsigned short *)((CYG_ADDRESS)addr & flash_info.block_mask);
182	end_addr = (unsigned short *)((CYG_ADDRESS)addr+len);
183
184	/* Check to see if end_addr overflowed */
185	if( (end_addr < block) && (len > 0) ){
186	end_addr = (unsigned short *) ((CYG_ADDRESS) flash_info.end - 1);
187	}
188
189	#ifdef CYGSEM_IO_FLASH_CHATTER
190	(flash_info.pf)("... Erase from %p-%p: ", (void)block, (void*)end_addr);
191	#endif
192
193	HAL_FLASH_CACHES_OFF(d_cache, i_cache);
194	FLASH_Enable(block, end_addr);
195	while (block < end_addr) {
196	// Supply the blocksize for a gross check for erase success
197	unsigned short *tmp_block;
198	#if !defined(CYGSEM_IO_FLASH_READ_INDIRECT)
199	int i;
200	unsigned char *dp;
201	bool erased = true;
202
203	dp = (unsigned char *)block;
204	for (i = 0; i < flash_info.block_size; i++) {
205	if (*dp++ != (unsigned char)0xFF) {
206	erased = false;
207	break;
208	}
209	}
210	#else
211	bool erased = false;
212	#endif
213
214	if (!erased) {
215	stat = (*_flash_erase_block)(block, flash_info.block_size);
216	stat = flash_hwr_map_error(stat);
217	}
218	if (stat) {
219	err_addr = (void )block;
220	break;
221	}
222
223	// Check to see if block will overflow
224	tmp_block = block + flash_info.block_size / sizeof(*block);
225	if(tmp_block < block){
226	// If block address overflows, set block value to end on this loop
227	block = end_addr;
228	}
229	else{
230	block = tmp_block;
231	}
232	#ifdef CYGSEM_IO_FLASH_CHATTER
233	(*flash_info.pf)(".");
234	#endif
235	}
236	FLASH_Disable(block, end_addr);
237	HAL_FLASH_CACHES_ON(d_cache, i_cache);
238	#ifdef CYGSEM_IO_FLASH_CHATTER
239	(*flash_info.pf)("\n");
240	#endif
241	return (stat);
242	}
243
244	int
245	flash_program(void _addr, void _data, int len, void **err_addr)
246	{
247	int stat = 0;
248	int size;
249	typedef int code_fun(void , void , int, unsigned long, int);
250	code_fun *_flash_program_buf;
251	unsigned char addr = (unsigned char )_addr;
252	unsigned char data = (unsigned char )_data;
253	CYG_ADDRESS tmp;
254	int d_cache, i_cache;
255
256	if (!flash_info.init) {
257	return FLASH_ERR_NOT_INIT;
258	}
259
260	#ifdef CYGSEM_IO_FLASH_SOFT_WRITE_PROTECT
261	if (plf_flash_query_soft_wp(addr,len))
262	return FLASH_ERR_PROTECT;
263	#endif
264
265	_flash_program_buf = (code_fun*) __anonymizer(&flash_program_buf);
266
267	#ifdef CYGSEM_IO_FLASH_CHATTER
268	(flash_info.pf)("... Program from %p-%p at %p: ", (void)data,
269	(void)(((CYG_ADDRESS)data)+len), (void)addr);
270	#endif
271
272	HAL_FLASH_CACHES_OFF(d_cache, i_cache);
273	FLASH_Enable((unsigned short)addr, (unsigned short )(addr+len));
274	while (len > 0) {
275	size = len;
276	if (size > flash_info.block_size) size = flash_info.block_size;
277
278	tmp = (CYG_ADDRESS)addr & ~flash_info.block_mask;
279	if (tmp) {
280	tmp = flash_info.block_size - tmp;
281	if (size>tmp) size = tmp;
282
283	}
284
285	stat = (*_flash_program_buf)(addr, data, size,
286	flash_info.block_mask, flash_info.buffer_size);
287	stat = flash_hwr_map_error(stat);
288	#ifdef CYGSEM_IO_FLASH_VERIFY_PROGRAM
289	if (0 == stat) // Claims to be OK
290	if (memcmp(addr, data, size) != 0) {
291	stat = 0x0BAD;
292	#ifdef CYGSEM_IO_FLASH_CHATTER
293	(*flash_info.pf)("V");
294	#endif
295	}
296	#endif
297	if (stat) {
298	err_addr = (void )addr;
299	break;
300	}
301	#ifdef CYGSEM_IO_FLASH_CHATTER
302	(*flash_info.pf)(".");
303	#endif
304	len -= size;
305	addr += size/sizeof(*addr);
306	data += size/sizeof(*data);
307	}
308	FLASH_Disable((unsigned short)addr, (unsigned short )(addr+len));
309	HAL_FLASH_CACHES_ON(d_cache, i_cache);
310	#ifdef CYGSEM_IO_FLASH_CHATTER
311	(*flash_info.pf)("\n");
312	#endif
313	return (stat);
314	}
315
316	int
317	flash_read(void _addr, void _data, int len, void **err_addr)
318	{
319	#ifdef CYGSEM_IO_FLASH_READ_INDIRECT
320	int stat = 0;
321	int size;
322	typedef int code_fun(void , void , int, unsigned long, int);
323	code_fun *_flash_read_buf;
324	unsigned char addr = (unsigned char )_addr;
325	unsigned char data = (unsigned char )_data;
326	CYG_ADDRESS tmp;
327	int d_cache, i_cache;
328
329	if (!flash_info.init) {
330	return FLASH_ERR_NOT_INIT;
331	}
332
333	_flash_read_buf = (code_fun*) __anonymizer(&flash_read_buf);
334
335	#ifdef CYGSEM_IO_FLASH_CHATTER
336	(flash_info.pf)("... Read from %p-%p at %p: ", (void)data,
337	(void)(((CYG_ADDRESS)data)+len), (void)addr);
338	#endif
339
340	HAL_FLASH_CACHES_OFF(d_cache, i_cache);
341	FLASH_Enable((unsigned short)addr, (unsigned short )(addr+len));
342	while (len > 0) {
343	size = len;
344	if (size > flash_info.block_size) size = flash_info.block_size;
345
346	tmp = (CYG_ADDRESS)addr & ~flash_info.block_mask;
347	if (tmp) {
348	tmp = flash_info.block_size - tmp;
349	if (size>tmp) size = tmp;
350
351	}
352
353	stat = (*_flash_read_buf)(addr, data, size,
354	flash_info.block_mask, flash_info.buffer_size);
355	stat = flash_hwr_map_error(stat);
356	#ifdef CYGSEM_IO_FLASH_VERIFY_PROGRAM_
357	if (0 == stat) // Claims to be OK
358	if (memcmp(addr, data, size) != 0) {
359	stat = 0x0BAD;
360	#ifdef CYGSEM_IO_FLASH_CHATTER
361	(*flash_info.pf)("V");
362	#endif
363	}
364	#endif
365	if (stat) {
366	err_addr = (void )addr;
367	break;
368	}
369	#ifdef CYGSEM_IO_FLASH_CHATTER
370	(*flash_info.pf)(".");
371	#endif
372	len -= size;
373	addr += size/sizeof(*addr);
374	data += size/sizeof(*data);
375	}
376	FLASH_Disable((unsigned short)addr, (unsigned short )(addr+len));
377	HAL_FLASH_CACHES_ON(d_cache, i_cache);
378	#ifdef CYGSEM_IO_FLASH_CHATTER
379	(*flash_info.pf)("\n");
380	#endif
381	return (stat);
382	#else // CYGSEM_IO_FLASH_READ_INDIRECT
383	// Direct access to FLASH memory is possible - just move the requested bytes
384	if (!flash_info.init) {
385	return FLASH_ERR_NOT_INIT;
386	}
387	memcpy(_data, _addr, len);
388	return FLASH_ERR_OK;
389	#endif
390	}
391
392	#ifdef CYGHWR_IO_FLASH_BLOCK_LOCKING
393
394	int
395	flash_lock(void addr, int len, void *err_addr)
396	{
397	unsigned short block, end_addr;
398	int stat = 0;
399	typedef int code_fun(unsigned short *);
400	code_fun *_flash_lock_block;
401	int d_cache, i_cache;
402
403	if (!flash_info.init) {
404	return FLASH_ERR_NOT_INIT;
405	}
406
407	#ifdef CYGSEM_IO_FLASH_SOFT_WRITE_PROTECT
408	if (plf_flash_query_soft_wp(addr,len))
409	return FLASH_ERR_PROTECT;
410	#endif
411
412	_flash_lock_block = (code_fun*) __anonymizer(&flash_lock_block);
413
414	block = (unsigned short *)((CYG_ADDRESS)addr & flash_info.block_mask);
415	end_addr = (unsigned short *)((CYG_ADDRESS)addr+len);
416
417	/* Check to see if end_addr overflowed */
418	if( (end_addr < block) && (len > 0) ){
419	end_addr = (unsigned short *) ((CYG_ADDRESS) flash_info.end - 1);
420	}
421
422	#ifdef CYGSEM_IO_FLASH_CHATTER
423	(*flash_info.pf)("... Lock from %p-%p: ", block, end_addr);
424	#endif
425
426	HAL_FLASH_CACHES_OFF(d_cache, i_cache);
427	FLASH_Enable(block, end_addr);
428	while (block < end_addr) {
429	unsigned short *tmp_block;
430	stat = (*_flash_lock_block)(block);
431	stat = flash_hwr_map_error(stat);
432	if (stat) {
433	err_addr = (void )block;
434	break;
435	}
436
437	// Check to see if block will overflow
438	tmp_block = block + flash_info.block_size / sizeof(*block);
439	if(tmp_block < block){
440	// If block address overflows, set block value to end on this loop
441	block = end_addr;
442	}
443	else{
444	block = tmp_block;
445	}
446	#ifdef CYGSEM_IO_FLASH_CHATTER
447	(*flash_info.pf)(".");
448	#endif
449	}
450	FLASH_Disable(block, end_addr);
451	HAL_FLASH_CACHES_ON(d_cache, i_cache);
452	#ifdef CYGSEM_IO_FLASH_CHATTER
453	(*flash_info.pf)("\n");
454	#endif
455	return (stat);
456	}
457
458	int
459	flash_unlock(void addr, int len, void *err_addr)
460	{
461	unsigned short block, end_addr;
462	int stat = 0;
463	typedef int code_fun(unsigned short *, int, int);
464	code_fun *_flash_unlock_block;
465	int d_cache, i_cache;
466
467	if (!flash_info.init) {
468	return FLASH_ERR_NOT_INIT;
469	}
470
471	#ifdef CYGSEM_IO_FLASH_SOFT_WRITE_PROTECT
472	if (plf_flash_query_soft_wp(addr,len))
473	return FLASH_ERR_PROTECT;
474	#endif
475
476	_flash_unlock_block = (code_fun*) __anonymizer(&flash_unlock_block);
477
478	block = (unsigned short *)((CYG_ADDRESS)addr & flash_info.block_mask);
479	end_addr = (unsigned short *)((CYG_ADDRESS)addr+len);
480
481	/* Check to see if end_addr overflowed */
482	if( (end_addr < block) && (len > 0) ){
483	end_addr = (unsigned short *) ((CYG_ADDRESS) flash_info.end - 1);
484	}
485
486	#ifdef CYGSEM_IO_FLASH_CHATTER
487	(*flash_info.pf)("... Unlock from %p-%p: ", block, end_addr);
488	#endif
489
490	HAL_FLASH_CACHES_OFF(d_cache, i_cache);
491	FLASH_Enable(block, end_addr);
492	while (block < end_addr) {
493	unsigned short *tmp_block;
494	stat = (*_flash_unlock_block)(block, flash_info.block_size, flash_info.blocks);
495	stat = flash_hwr_map_error(stat);
496	if (stat) {
497	err_addr = (void )block;
498	break;
499	}
500
501	tmp_block = block + flash_info.block_size / sizeof(*block);
502	if(tmp_block < block){
503	// If block address overflows, set block value to end on this loop
504	block = end_addr;
505	}
506	else{
507	block = tmp_block;
508	}
509	#ifdef CYGSEM_IO_FLASH_CHATTER
510	(*flash_info.pf)(".");
511	#endif
512	}
513	FLASH_Disable(block, end_addr);
514	HAL_FLASH_CACHES_ON(d_cache, i_cache);
515	#ifdef CYGSEM_IO_FLASH_CHATTER
516	(*flash_info.pf)("\n");
517	#endif
518	return (stat);
519	}
520	#endif
521
522	char *
523	flash_errmsg(int err)
524	{
525	switch (err) {
526	case FLASH_ERR_OK:
527	return "No error - operation complete";
528	case FLASH_ERR_ERASE_SUSPEND:
529	return "Device is in erase suspend state";
530	case FLASH_ERR_PROGRAM_SUSPEND:
531	return "Device is in program suspend state";
532	case FLASH_ERR_INVALID:
533	return "Invalid FLASH address";
534	case FLASH_ERR_ERASE:
535	return "Error trying to erase";
536	case FLASH_ERR_LOCK:
537	return "Error trying to lock/unlock";
538	case FLASH_ERR_PROGRAM:
539	return "Error trying to program";
540	case FLASH_ERR_PROTOCOL:
541	return "Generic error";
542	case FLASH_ERR_PROTECT:
543	return "Device/region is write-protected";
544	case FLASH_ERR_NOT_INIT:
545	return "FLASH sub-system not initialized";
546	case FLASH_ERR_DRV_VERIFY:
547	return "Data verify failed after operation";
548	case FLASH_ERR_DRV_TIMEOUT:
549	return "Driver timed out waiting for device";
550	case FLASH_ERR_DRV_WRONG_PART:
551	return "Driver does not support device";
552	case FLASH_ERR_LOW_VOLTAGE:
553	return "Device reports low voltage";
554	default:
555	return "Unknown error";
556	}
557	}
558
559	// EOF io/flash/..../flash.c

Note: See TracBrowser for help on using the browser.

root/ar5315_microredboot/microredboot/ecos/packages/io/flash/current/src/flash.c

Download in other formats: