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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* MTD block - abstraction over MTD subsystem, allowing
* to read and write in blocks using BLK UCLASS.
*
* - Read algorithm:
*
* 1. Convert start block number to start address.
* 2. Read block_dev->blksz bytes using mtd_read() and
* add to start address pointer block_dev->blksz bytes,
* until the requested number of blocks have been read.
*
* - Write algorithm:
*
* 1. Convert start block number to start address.
* 2. Round this address down by mtd->erasesize.
*
* Erase addr Start addr
* | |
* v v
* +----------------+----------------+----------------+
* | blksz | blksz | blksz |
* +----------------+----------------+----------------+
*
* 3. Calculate offset between this two addresses.
* 4. Read mtd->erasesize bytes using mtd_read() into
* temporary buffer from erase address.
*
* Erase addr Start addr
* | |
* v v
* +----------------+----------------+----------------+
* | blksz | blksz | blksz |
* +----------------+----------------+----------------+
* ^
* |
* |
* mtd_read()
* from here
*
* 5. Copy data from user buffer to temporary buffer with offset,
* calculated at step 3.
* 6. Erase and write mtd->erasesize bytes at erase address
* pointer using mtd_erase/mtd_write().
* 7. Add to erase address pointer mtd->erasesize bytes.
* 8. goto 1 until the requested number of blocks have
* been written.
*
* (C) Copyright 2024 SaluteDevices, Inc.
*
* Author: Alexey Romanov <avromanov@salutedevices.com>
*/
#include <blk.h>
#include <part.h>
#include <dm/device.h>
#include <dm/device-internal.h>
#include <linux/mtd/mtd.h>
int mtd_bind(struct udevice *dev, struct mtd_info **mtd)
{
struct blk_desc *bdesc;
struct udevice *bdev;
int ret;
ret = blk_create_devicef(dev, "mtd_blk", "blk", UCLASS_MTD,
-1, 512, 0, &bdev);
if (ret) {
pr_err("Cannot create block device\n");
return ret;
}
bdesc = dev_get_uclass_plat(bdev);
dev_set_priv(bdev, mtd);
bdesc->bdev = bdev;
bdesc->part_type = PART_TYPE_MTD;
return 0;
}
static ulong mtd_blk_read(struct udevice *dev, lbaint_t start, lbaint_t blkcnt,
void *dst)
{
struct blk_desc *block_dev = dev_get_uclass_plat(dev);
struct mtd_info *mtd = blk_desc_to_mtd(block_dev);
unsigned int sect_size = block_dev->blksz;
lbaint_t cur = start;
ulong read_cnt = 0;
while (read_cnt < blkcnt) {
int ret;
loff_t sect_start = cur * sect_size;
size_t retlen;
ret = mtd_read(mtd, sect_start, sect_size, &retlen, dst);
if (ret)
return ret;
if (retlen != sect_size) {
pr_err("mtdblock: failed to read block 0x" LBAF "\n", cur);
return -EIO;
}
cur++;
dst += sect_size;
read_cnt++;
}
return read_cnt;
}
static int mtd_erase_write(struct mtd_info *mtd, uint64_t start, const void *src)
{
int ret;
size_t retlen;
struct erase_info erase = { 0 };
erase.mtd = mtd;
erase.addr = start;
erase.len = mtd->erasesize;
ret = mtd_erase(mtd, &erase);
if (ret)
return ret;
ret = mtd_write(mtd, start, mtd->erasesize, &retlen, src);
if (ret)
return ret;
if (retlen != mtd->erasesize) {
pr_err("mtdblock: failed to read block at 0x%llx\n", start);
return -EIO;
}
return 0;
}
static ulong mtd_blk_write(struct udevice *dev, lbaint_t start, lbaint_t blkcnt,
const void *src)
{
struct blk_desc *block_dev = dev_get_uclass_plat(dev);
struct mtd_info *mtd = blk_desc_to_mtd(block_dev);
unsigned int sect_size = block_dev->blksz;
lbaint_t cur = start, blocks_todo = blkcnt;
ulong write_cnt = 0;
u8 *buf;
int ret = 0;
buf = malloc(mtd->erasesize);
if (!buf)
return -ENOMEM;
while (blocks_todo > 0) {
loff_t sect_start = cur * sect_size;
loff_t erase_start = ALIGN_DOWN(sect_start, mtd->erasesize);
u32 offset = sect_start - erase_start;
size_t cur_size = min_t(size_t, mtd->erasesize - offset,
blocks_todo * sect_size);
size_t retlen;
lbaint_t written;
ret = mtd_read(mtd, erase_start, mtd->erasesize, &retlen, buf);
if (ret)
goto out;
if (retlen != mtd->erasesize) {
pr_err("mtdblock: failed to read block 0x" LBAF "\n", cur);
ret = -EIO;
goto out;
}
memcpy(buf + offset, src, cur_size);
ret = mtd_erase_write(mtd, erase_start, buf);
if (ret)
goto out;
written = cur_size / sect_size;
blocks_todo -= written;
cur += written;
src += cur_size;
write_cnt += written;
}
out:
free(buf);
if (ret)
return ret;
return write_cnt;
}
static int mtd_blk_probe(struct udevice *dev)
{
struct blk_desc *bdesc;
struct mtd_info *mtd;
int ret;
ret = device_probe(dev);
if (ret) {
pr_err("Probing %s failed (err=%d)\n", dev->name, ret);
return ret;
}
bdesc = dev_get_uclass_plat(dev);
mtd = blk_desc_to_mtd(bdesc);
if (mtd_type_is_nand(mtd))
pr_warn("MTD device '%s' is NAND, please use UBI devices instead\n",
mtd->name);
return 0;
}
static const struct blk_ops mtd_blk_ops = {
.read = mtd_blk_read,
.write = mtd_blk_write,
};
U_BOOT_DRIVER(mtd_blk) = {
.name = "mtd_blk",
.id = UCLASS_BLK,
.ops = &mtd_blk_ops,
.probe = mtd_blk_probe,
};
|
