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