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
|
/* This file is part of the coreboot project. */
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* MultiMediaCard (MMC), eMMC and Secure Digital (SD) write support code.
* This code is controller independent.
*/
#include <stdlib.h>
#include "sd_mmc.h"
#include "storage.h"
static uint32_t storage_write(struct storage_media *media, uint32_t start,
uint64_t block_count, const void *src)
{
struct mmc_command cmd;
struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
cmd.resp_type = CARD_RSP_R1;
cmd.flags = 0;
if (block_count > 1)
cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
else
cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;
if (media->high_capacity)
cmd.cmdarg = start;
else
cmd.cmdarg = start * media->write_bl_len;
struct mmc_data data;
data.src = src;
data.blocks = block_count;
data.blocksize = media->write_bl_len;
data.flags = DATA_FLAG_WRITE;
if (ctrlr->send_cmd(ctrlr, &cmd, &data)) {
sd_mmc_error("Write failed\n");
return 0;
}
/* SPI multiblock writes terminate using a special
* token, not a STOP_TRANSMISSION request.
*/
if ((block_count > 1) && !(ctrlr->caps
& DRVR_CAP_AUTO_CMD12)) {
cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
cmd.cmdarg = 0;
cmd.resp_type = CARD_RSP_R1b;
cmd.flags = CMD_FLAG_IGNORE_INHIBIT;
if (ctrlr->send_cmd(ctrlr, &cmd, NULL)) {
sd_mmc_error("Failed to send stop cmd\n");
return 0;
}
/* Waiting for the ready status */
sd_mmc_send_status(media, SD_MMC_IO_RETRIES);
}
return block_count;
}
uint64_t storage_block_write(struct storage_media *media, uint64_t start,
uint64_t count, const void *buffer)
{
const uint8_t *src = (const uint8_t *)buffer;
if (storage_block_setup(media, start, count, 0) == 0)
return 0;
uint64_t todo = count;
struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
do {
uint64_t cur = MIN(todo, ctrlr->b_max);
if (storage_write(media, start, cur, src) != cur)
return 0;
todo -= cur;
start += cur;
src += cur * media->write_bl_len;
} while (todo > 0);
return count;
}
uint64_t storage_block_fill_write(struct storage_media *media, uint64_t start,
uint64_t count, uint32_t fill_pattern)
{
if (storage_block_setup(media, start, count, 0) == 0)
return 0;
struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
uint64_t block_size = media->write_bl_len;
/*
* We allocate max 4 MiB buffer on heap and set it to fill_pattern and
* perform mmc_write operation using this 4MiB buffer until requested
* size on disk is written by the fill byte.
*
* 4MiB was chosen after repeating several experiments with the max
* buffer size to be used. Using 1 lba i.e. block_size buffer results in
* very large fill_write time. On the other hand, choosing 4MiB, 8MiB or
* even 128 Mib resulted in similar write times. With 2MiB, the
* fill_write time increased by several seconds. So, 4MiB was chosen as
* the default max buffer size.
*/
uint64_t heap_lba = (4 * MiB) / block_size;
/*
* Actual allocated buffer size is minimum of three entities:
* 1) 4MiB equivalent in lba
* 2) count: Number of lbas to overwrite
* 3) ctrlr->b_max: Max lbas that the block device allows write
* operation on at a time.
*/
uint64_t buffer_lba = MIN(MIN(heap_lba, count), ctrlr->b_max);
uint64_t buffer_bytes = buffer_lba * block_size;
uint64_t buffer_words = buffer_bytes / sizeof(uint32_t);
uint32_t *buffer = malloc(buffer_bytes);
uint32_t *ptr = buffer;
for (; buffer_words ; buffer_words--)
*ptr++ = fill_pattern;
uint64_t todo = count;
int ret = 0;
do {
uint64_t curr_lba = MIN(buffer_lba, todo);
if (storage_write(media, start, curr_lba, buffer) != curr_lba)
goto cleanup;
todo -= curr_lba;
start += curr_lba;
} while (todo > 0);
ret = count;
cleanup:
free(buffer);
return ret;
}
|
