embox

1
/**
2
 * @file emulator.c
3
 * @brief Simple flash emulator
4
 *
5
 * @date 22.08.2013
6
 * @author Andrey Gazukin
7
 * @author Denis Deryugin
8
 */
9

10
#include <errno.h>
11
#include <stdio.h>
12
#include <fcntl.h>
13
#include <unistd.h>
14
#include <string.h>
15
#include <stdlib.h>
16
#include <stdint.h>
17

18
#include <drivers/block_dev.h>
19
#include <drivers/flash/flash.h>
20
#include <mem/sysmalloc.h>
21

22
#include <util/log.h>
23
#include <util/err.h>
24

25
#define EMU_FLASH_WORD_SIZE  4
26

27
struct flash_emulator_priv {
28
	uint8_t *base;
29
	size_t block_sz;
30
	size_t size;
31

32
	uint8_t aligned_word[EMU_FLASH_WORD_SIZE] 
33
			__attribute__ ((aligned(EMU_FLASH_WORD_SIZE)));
34
};
35

36
int flash_emu_init (struct flash_dev *dev, void *arg) {
37
	/* Do nothing */
38
	return 0;
39
}
40

41
static int flash_emu_erase_block(struct flash_dev *dev, uint32_t block_base) {
42
	struct flash_emulator_priv *priv;
43
	uint8_t *mem;
44
	int len;
45

46
	assert(dev);
47

48
	priv = dev->privdata;
49
	assert(priv);
50

51
	len = priv->block_sz;
52
	mem = priv->base + priv->block_sz * block_base;
53

54
	assert(mem >= priv->base);
55
	assert(mem < priv->base + priv->size);
56
	assert(mem + len >= priv->base);
57
	assert(mem + len <= priv->base + priv->size);
58

59
	memset(mem, 0xFF, len);
60

61
	return 0;
62
}
63

64
static int flash_emu_program (struct flash_dev *dev, uint32_t base,
65
		const void* data, size_t len) {
66
	struct flash_emulator_priv *priv;
67
	uint8_t *mem;
68

69
	assert(dev);
70
	assert(data);
71

72
	priv = dev->privdata;
73
	assert(priv);
74

75
	mem = priv->base + base;
76

77
	assert(mem >= priv->base);
78
	assert(mem < priv->base + priv->size);
79
	assert(mem + len >= priv->base);
80
	assert(mem + len <= priv->base + priv->size);
81

82
	memcpy(mem, data, len);
83

84
	return len;
85
}
86

87
static int flash_emu_read (struct flash_dev *dev,
88
		uint32_t base, void* data, size_t len) {
89
	struct flash_emulator_priv *priv;
90
	uint8_t *mem;
91

92
	assert(dev);
93
	assert(data);
94

95
	priv = dev->privdata;
96
	assert(priv);
97

98
	mem = priv->base + base;
99

100
	assert(mem >= priv->base);
101
	assert(mem < priv->base + priv->size);
102
	assert(mem + len >= priv->base);
103
	assert(mem + len <= priv->base + priv->size);
104

105
	memcpy(data, mem, len);
106

107
	return len;
108
}
109

110
static struct flash_dev_drv flash_emu_drv = {
111
	flash_emu_init,
112
	flash_emu_erase_block,
113
	flash_emu_program,
114
	flash_emu_read
115
};
116

117
int flash_emu_dev_create(const char *name, int blocks, size_t block_size) {
118
	struct flash_dev *flash;
119
	struct flash_emulator_priv *priv;
120
	int err;
121

122
	flash = flash_create(name, blocks * block_size);
123
	if (flash == NULL) {
124
		return -1;
125
	}
126

127
	priv = malloc(sizeof(struct flash_emulator_priv));
128
	if (priv == NULL) {
129
		err = -ENOMEM;
130
		goto out_free_flash;
131
	}
132

133
	flash->privdata = priv;
134

135
	priv->size = blocks * block_size;
136
	priv->block_sz = block_size;
137
	priv->base = malloc(priv->size);
138
	if (priv->base == NULL) {
139
		err = -ENOMEM;
140
		goto out_free_priv;
141
	}
142

143
	memset(priv->base, 0xFF, priv->size);
144

145
	flash->num_block_infos = 1;
146
	flash->block_info[0].block_size = block_size;
147
	flash->block_info[0].blocks = blocks;
148

149
	flash->size = priv->size;
150
	flash->fld_aligned_word = priv->aligned_word;
151
	flash->fld_word_size = EMU_FLASH_WORD_SIZE;
152

153
	flash->drv = &flash_emu_drv;
154

155
	return 0;
156

157
out_free_priv:
158
	free(priv);
159
out_free_flash:
160
	flash_delete(flash);
161

162
	log_error("Failed to create flash emulator error=%d", err);
163

164
	return err;
165
}
166