1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright 2014 Broadcom Corporation.
4 * Copyright 2015 Free Electrons.
5 */
6
7 #include <config.h>
8 #include <common.h>
9 #include <blk.h>
10
11 #include <fastboot.h>
12 #include <image-sparse.h>
13
14 #include <linux/mtd/mtd.h>
15 #include <jffs2/jffs2.h>
16 #include <nand.h>
17
18 struct fb_nand_sparse {
19 struct mtd_info *mtd;
20 struct part_info *part;
21 };
22
board_fastboot_erase_partition_setup(char * name)23 __weak int board_fastboot_erase_partition_setup(char *name)
24 {
25 return 0;
26 }
27
board_fastboot_write_partition_setup(char * name)28 __weak int board_fastboot_write_partition_setup(char *name)
29 {
30 return 0;
31 }
32
fb_nand_lookup(const char * partname,struct mtd_info ** mtd,struct part_info ** part,char * response)33 static int fb_nand_lookup(const char *partname,
34 struct mtd_info **mtd,
35 struct part_info **part,
36 char *response)
37 {
38 struct mtd_device *dev;
39 int ret;
40 u8 pnum;
41
42 ret = mtdparts_init();
43 if (ret) {
44 pr_err("Cannot initialize MTD partitions\n");
45 fastboot_fail("cannot init mtdparts", response);
46 return ret;
47 }
48
49 ret = find_dev_and_part(partname, &dev, &pnum, part);
50 if (ret) {
51 pr_err("cannot find partition: '%s'", partname);
52 fastboot_fail("cannot find partition", response);
53 return ret;
54 }
55
56 if (dev->id->type != MTD_DEV_TYPE_NAND) {
57 pr_err("partition '%s' is not stored on a NAND device",
58 partname);
59 fastboot_fail("not a NAND device", response);
60 return -EINVAL;
61 }
62
63 *mtd = get_nand_dev_by_index(dev->id->num);
64
65 return 0;
66 }
67
_fb_nand_erase(struct mtd_info * mtd,struct part_info * part)68 static int _fb_nand_erase(struct mtd_info *mtd, struct part_info *part)
69 {
70 nand_erase_options_t opts;
71 int ret;
72
73 memset(&opts, 0, sizeof(opts));
74 opts.offset = part->offset;
75 opts.length = part->size;
76 opts.quiet = 1;
77
78 printf("Erasing blocks 0x%llx to 0x%llx\n",
79 part->offset, part->offset + part->size);
80
81 ret = nand_erase_opts(mtd, &opts);
82 if (ret)
83 return ret;
84
85 printf("........ erased 0x%llx bytes from '%s'\n",
86 part->size, part->name);
87
88 return 0;
89 }
90
_fb_nand_write(struct mtd_info * mtd,struct part_info * part,void * buffer,u32 offset,size_t length,size_t * written)91 static int _fb_nand_write(struct mtd_info *mtd, struct part_info *part,
92 void *buffer, u32 offset,
93 size_t length, size_t *written)
94 {
95 int flags = WITH_WR_VERIFY;
96
97 #ifdef CONFIG_FASTBOOT_FLASH_NAND_TRIMFFS
98 flags |= WITH_DROP_FFS;
99 #endif
100
101 return nand_write_skip_bad(mtd, offset, &length, written,
102 part->size - (offset - part->offset),
103 buffer, flags);
104 }
105
fb_nand_sparse_write(struct sparse_storage * info,lbaint_t blk,lbaint_t blkcnt,const void * buffer)106 static lbaint_t fb_nand_sparse_write(struct sparse_storage *info,
107 lbaint_t blk, lbaint_t blkcnt, const void *buffer)
108 {
109 struct fb_nand_sparse *sparse = info->priv;
110 size_t written;
111 int ret;
112
113 ret = _fb_nand_write(sparse->mtd, sparse->part, (void *)buffer,
114 blk * info->blksz,
115 blkcnt * info->blksz, &written);
116 if (ret < 0) {
117 printf("Failed to write sparse chunk\n");
118 return ret;
119 }
120
121 /* TODO - verify that the value "written" includes the "bad-blocks" ... */
122
123 /*
124 * the return value must be 'blkcnt' ("good-blocks") plus the
125 * number of "bad-blocks" encountered within this space...
126 */
127 return written / info->blksz;
128 }
129
fb_nand_sparse_reserve(struct sparse_storage * info,lbaint_t blk,lbaint_t blkcnt)130 static lbaint_t fb_nand_sparse_reserve(struct sparse_storage *info,
131 lbaint_t blk, lbaint_t blkcnt)
132 {
133 int bad_blocks = 0;
134
135 /*
136 * TODO - implement a function to determine the total number
137 * of blocks which must be used in order to reserve the specified
138 * number ("blkcnt") of "good-blocks", starting at "blk"...
139 * ( possibly something like the "check_skip_len()" function )
140 */
141
142 /*
143 * the return value must be 'blkcnt' ("good-blocks") plus the
144 * number of "bad-blocks" encountered within this space...
145 */
146 return blkcnt + bad_blocks;
147 }
148
149 /**
150 * fastboot_nand_get_part_info() - Lookup NAND partion by name
151 *
152 * @part_name: Named device to lookup
153 * @part_info: Pointer to returned part_info pointer
154 * @response: Pointer to fastboot response buffer
155 */
fastboot_nand_get_part_info(const char * part_name,struct part_info ** part_info,char * response)156 int fastboot_nand_get_part_info(const char *part_name,
157 struct part_info **part_info, char *response)
158 {
159 struct mtd_info *mtd = NULL;
160
161 return fb_nand_lookup(part_name, &mtd, part_info, response);
162 }
163
164 /**
165 * fastboot_nand_flash_write() - Write image to NAND for fastboot
166 *
167 * @cmd: Named device to write image to
168 * @download_buffer: Pointer to image data
169 * @download_bytes: Size of image data
170 * @response: Pointer to fastboot response buffer
171 */
fastboot_nand_flash_write(const char * cmd,void * download_buffer,u32 download_bytes,char * response)172 void fastboot_nand_flash_write(const char *cmd, void *download_buffer,
173 u32 download_bytes, char *response)
174 {
175 struct part_info *part;
176 struct mtd_info *mtd = NULL;
177 int ret;
178
179 ret = fb_nand_lookup(cmd, &mtd, &part, response);
180 if (ret) {
181 pr_err("invalid NAND device");
182 fastboot_fail("invalid NAND device", response);
183 return;
184 }
185
186 ret = board_fastboot_write_partition_setup(part->name);
187 if (ret)
188 return;
189
190 if (is_sparse_image(download_buffer)) {
191 struct fb_nand_sparse sparse_priv;
192 struct sparse_storage sparse;
193
194 sparse_priv.mtd = mtd;
195 sparse_priv.part = part;
196
197 sparse.blksz = mtd->writesize;
198 sparse.start = part->offset / sparse.blksz;
199 sparse.size = part->size / sparse.blksz;
200 sparse.write = fb_nand_sparse_write;
201 sparse.reserve = fb_nand_sparse_reserve;
202 sparse.mssg = fastboot_fail;
203
204 printf("Flashing sparse image at offset " LBAFU "\n",
205 sparse.start);
206
207 sparse.priv = &sparse_priv;
208 ret = write_sparse_image(&sparse, cmd, download_buffer,
209 response);
210 if (!ret)
211 fastboot_okay(NULL, response);
212 } else {
213 printf("Flashing raw image at offset 0x%llx\n",
214 part->offset);
215
216 ret = _fb_nand_write(mtd, part, download_buffer, part->offset,
217 download_bytes, NULL);
218
219 printf("........ wrote %u bytes to '%s'\n",
220 download_bytes, part->name);
221 }
222
223 if (ret) {
224 fastboot_fail("error writing the image", response);
225 return;
226 }
227
228 fastboot_okay(NULL, response);
229 }
230
231 /**
232 * fastboot_nand_flash_erase() - Erase NAND for fastboot
233 *
234 * @cmd: Named device to erase
235 * @response: Pointer to fastboot response buffer
236 */
fastboot_nand_erase(const char * cmd,char * response)237 void fastboot_nand_erase(const char *cmd, char *response)
238 {
239 struct part_info *part;
240 struct mtd_info *mtd = NULL;
241 int ret;
242
243 ret = fb_nand_lookup(cmd, &mtd, &part, response);
244 if (ret) {
245 pr_err("invalid NAND device");
246 fastboot_fail("invalid NAND device", response);
247 return;
248 }
249
250 ret = board_fastboot_erase_partition_setup(part->name);
251 if (ret)
252 return;
253
254 ret = _fb_nand_erase(mtd, part);
255 if (ret) {
256 pr_err("failed erasing from device %s", mtd->name);
257 fastboot_fail("failed erasing from device", response);
258 return;
259 }
260
261 fastboot_okay(NULL, response);
262 }
263