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
|
//==========================================================================
//
// flash.h
//
// Flash programming - external interfaces
//
//==========================================================================
// ####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2009 Free Software Foundation, Inc.
//
// eCos is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 or (at your option) any later
// version.
//
// eCos is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License
// along with eCos; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
// As a special exception, if other files instantiate templates or use
// macros or inline functions from this file, or you compile this file
// and link it with other works to produce a work based on this file,
// this file does not by itself cause the resulting work to be covered by
// the GNU General Public License. However the source code for this file
// must still be made available in accordance with section (3) of the GNU
// General Public License v2.
//
// This exception does not invalidate any other reasons why a work based
// on this file might be covered by the GNU General Public License.
// -------------------------------------------
// ####ECOSGPLCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): gthomas
// Contributors: gthomas, Andrew Lunn, bartv
// Date: 2000-07-14
// Purpose:
// Description:
//
//####DESCRIPTIONEND####
//
//==========================================================================
#ifndef _IO_FLASH_H_
#define _IO_FLASH_H_
#include <pkgconf/system.h>
#include <pkgconf/io_flash.h>
#include <stddef.h>
#include <cyg/infra/cyg_type.h>
#ifdef CYGPKG_KERNEL
#include <cyg/kernel/kapi.h>
#endif
// Currently a 32-bit quantity. In future this may be 64-bits on some
// platforms, e.g. to support very large nand flashes which can only
// be accessed indirectly.
typedef CYG_ADDRESS cyg_flashaddr_t;
typedef struct cyg_flash_block_info
{
size_t block_size;
cyg_uint32 blocks;
} cyg_flash_block_info_t;
// Information about what one device driver drives
typedef struct {
cyg_flashaddr_t start; // First address
cyg_flashaddr_t end; // Last address
cyg_uint32 num_block_infos; // Number of entries
const cyg_flash_block_info_t* block_info; // Info about block sizes
} cyg_flash_info_t;
typedef int cyg_flash_printf(const char *fmt, ...);
__externC int cyg_flash_init( cyg_flash_printf *pf );
__externC int cyg_flash_set_printf(const cyg_flashaddr_t flash_base,
cyg_flash_printf *pf);
__externC void cyg_flash_set_global_printf(cyg_flash_printf *pf);
__externC int cyg_flash_get_info(cyg_uint32 devno,
cyg_flash_info_t * info);
__externC int cyg_flash_get_info_addr(const cyg_flashaddr_t flash_base,
cyg_flash_info_t * info);
__externC int cyg_flash_verify_addr(const cyg_flashaddr_t address);
__externC size_t cyg_flash_block_size(const cyg_flashaddr_t flash_base);
__externC int cyg_flash_read(const cyg_flashaddr_t flash_base,
void *ram_base,
size_t len,
cyg_flashaddr_t *err_address);
__externC int cyg_flash_erase(cyg_flashaddr_t flash_base,
size_t len,
cyg_flashaddr_t *err_address);
__externC int cyg_flash_program(cyg_flashaddr_t flash_base,
const void *ram_base,
size_t len,
cyg_flashaddr_t *err_address);
__externC int cyg_flash_lock(const cyg_flashaddr_t flash_base,
size_t len,
cyg_flashaddr_t *err_address);
__externC int cyg_flash_unlock(const cyg_flashaddr_t flash_base,
size_t len,
cyg_flashaddr_t *err_address);
__externC const char *cyg_flash_errmsg(const int err);
#ifdef CYGPKG_KERNEL
__externC int cyg_flash_mutex_lock(const cyg_flashaddr_t from,
size_t len);
__externC int cyg_flash_mutex_unlock(const cyg_flashaddr_t from,
size_t len);
#endif
#define CYG_FLASH_ERR_OK 0x00 // No error - operation complete
#define CYG_FLASH_ERR_INVALID 0x01 // Invalid FLASH address
#define CYG_FLASH_ERR_ERASE 0x02 // Error trying to erase
#define CYG_FLASH_ERR_LOCK 0x03 // Error trying to lock/unlock
#define CYG_FLASH_ERR_PROGRAM 0x04 // Error trying to program
#define CYG_FLASH_ERR_PROTOCOL 0x05 // Generic error
#define CYG_FLASH_ERR_PROTECT 0x06 // Device/region is write-protected
#define CYG_FLASH_ERR_NOT_INIT 0x07 // FLASH info not yet initialized
#define CYG_FLASH_ERR_HWR 0x08 // Hardware (configuration?) problem
#define CYG_FLASH_ERR_ERASE_SUSPEND 0x09 // Device is in erase suspend mode
#define CYG_FLASH_ERR_PROGRAM_SUSPEND 0x0a // Device is in program suspend mode
#define CYG_FLASH_ERR_DRV_VERIFY 0x0b // Driver failed to verify data
#define CYG_FLASH_ERR_DRV_TIMEOUT 0x0c // Driver timed out
#define CYG_FLASH_ERR_DRV_WRONG_PART 0x0d // Driver does not support device
#define CYG_FLASH_ERR_LOW_VOLTAGE 0x0e // Not enough juice to complete job
#ifdef CYGSEM_IO_FLASH_LEGACY_API
typedef int _printf(const char *fmt, ...);
externC int flash_init(_printf *pf);
externC int flash_erase(void *base, int len, void **err_address);
externC int flash_program(void *flash_base, void *ram_base, int len,
void **err_address);
externC int flash_read(void *flash_base, void *ram_base, int len,
void **err_address);
externC void flash_dev_query(void *data);
#ifdef CYGHWR_IO_FLASH_BLOCK_LOCKING
externC int flash_lock(void *base, int len, void **err_address);
externC int flash_unlock(void *base, int len, void **err_address);
#endif
externC int flash_verify_addr(void *base);
externC int flash_get_limits(void *base, void **start, void **end);
externC int flash_get_block_info(int *block_size, int *blocks);
externC bool flash_code_overlaps(void *start, void *end);
externC char *flash_errmsg(int err);
#endif // CYGSEM_IO_FLASH_LEGACY_API
#if defined(CYGSEM_IO_FLASH_LEGACY_API) || defined(CYGHWR_IO_FLASH_DEVICE_LEGACY)
#define FLASH_ERR_OK CYG_FLASH_ERR_OK
#define FLASH_ERR_INVALID CYG_FLASH_ERR_INVALID
#define FLASH_ERR_ERASE CYG_FLASH_ERR_ERASE
#define FLASH_ERR_LOCK CYG_FLASH_ERR_LOCK
#define FLASH_ERR_PROGRAM CYG_FLASH_ERR_PROGRAM
#define FLASH_ERR_PROTOCOL CYG_FLASH_ERR_PROTOCOL
#define FLASH_ERR_PROTECT CYG_FLASH_ERR_PROTECT
#define FLASH_ERR_NOT_INIT CYG_FLASH_ERR_NOT_INIT
#define FLASH_ERR_HWR CYG_FLASH_ERR_HWR
#define FLASH_ERR_ERASE_SUSPEND CYG_FLASH_ERR_ERASE_SUSPEND
#define FLASH_ERR_PROGRAM_SUSPEND CYG_FLASH_ERR_PROGRAM_SUSPEND
#define FLASH_ERR_DRV_VERIFY CYG_FLASH_ERR_DRV_VERIFY
#define FLASH_ERR_DRV_TIMEOUT CYG_FLASH_ERR_DRV_TIMEOUT
#define FLASH_ERR_DRV_WRONG_PART CYG_FLASH_ERR_DRV_WRONG_PART
#define FLASH_ERR_LOW_VOLTAGE CYG_FLASH_ERR_LOW_VOLTAGE
#endif
#if defined(CYGPKG_IO_FLASH_BLOCK_DEVICE) || \
defined(CYGPKG_IO_FLASH_BLOCK_DEVICE_LEGACY)
typedef struct {
CYG_ADDRESS offset;
size_t len;
int flasherr;
cyg_flashaddr_t err_address;
} cyg_io_flash_getconfig_erase_t;
typedef cyg_io_flash_getconfig_erase_t cyg_io_flash_getconfig_lock_t;
typedef cyg_io_flash_getconfig_erase_t cyg_io_flash_getconfig_unlock_t;
typedef struct {
size_t dev_size;
} cyg_io_flash_getconfig_devsize_t;
typedef struct {
cyg_flashaddr_t dev_addr;
} cyg_io_flash_getconfig_devaddr_t;
typedef struct {
CYG_ADDRESS offset;
size_t block_size;
} cyg_io_flash_getconfig_blocksize_t;
#endif
#endif // _IO_FLASH_H_
|