]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * dfu_nand.c -- DFU for NAND routines. | |
3 | * | |
4 | * Copyright (C) 2012-2013 Texas Instruments, Inc. | |
5 | * | |
6 | * Based on dfu_mmc.c which is: | |
7 | * Copyright (C) 2012 Samsung Electronics | |
8 | * author: Lukasz Majewski <l.majewski@samsung.com> | |
9 | * | |
10 | * SPDX-License-Identifier: GPL-2.0+ | |
11 | */ | |
12 | ||
13 | #include <common.h> | |
14 | #include <malloc.h> | |
15 | #include <errno.h> | |
16 | #include <div64.h> | |
17 | #include <dfu.h> | |
18 | #include <linux/mtd/mtd.h> | |
19 | #include <jffs2/load_kernel.h> | |
20 | #include <nand.h> | |
21 | ||
22 | static int nand_block_op(enum dfu_op op, struct dfu_entity *dfu, | |
23 | u64 offset, void *buf, long *len) | |
24 | { | |
25 | loff_t start, lim; | |
26 | size_t count, actual; | |
27 | int ret; | |
28 | struct mtd_info *mtd; | |
29 | ||
30 | /* if buf == NULL return total size of the area */ | |
31 | if (buf == NULL) { | |
32 | *len = dfu->data.nand.size; | |
33 | return 0; | |
34 | } | |
35 | ||
36 | start = dfu->data.nand.start + offset + dfu->bad_skip; | |
37 | lim = dfu->data.nand.start + dfu->data.nand.size - start; | |
38 | count = *len; | |
39 | ||
40 | if (nand_curr_device < 0 || | |
41 | nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE || | |
42 | !nand_info[nand_curr_device]->name) { | |
43 | printf("%s: invalid nand device\n", __func__); | |
44 | return -1; | |
45 | } | |
46 | ||
47 | mtd = nand_info[nand_curr_device]; | |
48 | ||
49 | if (op == DFU_OP_READ) { | |
50 | ret = nand_read_skip_bad(mtd, start, &count, &actual, | |
51 | lim, buf); | |
52 | } else { | |
53 | nand_erase_options_t opts; | |
54 | ||
55 | memset(&opts, 0, sizeof(opts)); | |
56 | opts.offset = start; | |
57 | opts.length = count; | |
58 | opts.spread = 1; | |
59 | opts.quiet = 1; | |
60 | opts.lim = lim; | |
61 | /* first erase */ | |
62 | ret = nand_erase_opts(mtd, &opts); | |
63 | if (ret) | |
64 | return ret; | |
65 | /* then write */ | |
66 | ret = nand_write_skip_bad(mtd, start, &count, &actual, | |
67 | lim, buf, WITH_WR_VERIFY); | |
68 | } | |
69 | ||
70 | if (ret != 0) { | |
71 | printf("%s: nand_%s_skip_bad call failed at %llx!\n", | |
72 | __func__, op == DFU_OP_READ ? "read" : "write", | |
73 | start); | |
74 | return ret; | |
75 | } | |
76 | ||
77 | /* | |
78 | * Find out where we stopped writing data. This can be deeper into | |
79 | * the NAND than we expected due to having to skip bad blocks. So | |
80 | * we must take this into account for the next write, if any. | |
81 | */ | |
82 | if (actual > count) | |
83 | dfu->bad_skip += actual - count; | |
84 | ||
85 | return ret; | |
86 | } | |
87 | ||
88 | static inline int nand_block_write(struct dfu_entity *dfu, | |
89 | u64 offset, void *buf, long *len) | |
90 | { | |
91 | return nand_block_op(DFU_OP_WRITE, dfu, offset, buf, len); | |
92 | } | |
93 | ||
94 | static inline int nand_block_read(struct dfu_entity *dfu, | |
95 | u64 offset, void *buf, long *len) | |
96 | { | |
97 | return nand_block_op(DFU_OP_READ, dfu, offset, buf, len); | |
98 | } | |
99 | ||
100 | static int dfu_write_medium_nand(struct dfu_entity *dfu, | |
101 | u64 offset, void *buf, long *len) | |
102 | { | |
103 | int ret = -1; | |
104 | ||
105 | switch (dfu->layout) { | |
106 | case DFU_RAW_ADDR: | |
107 | ret = nand_block_write(dfu, offset, buf, len); | |
108 | break; | |
109 | default: | |
110 | printf("%s: Layout (%s) not (yet) supported!\n", __func__, | |
111 | dfu_get_layout(dfu->layout)); | |
112 | } | |
113 | ||
114 | return ret; | |
115 | } | |
116 | ||
117 | long dfu_get_medium_size_nand(struct dfu_entity *dfu) | |
118 | { | |
119 | return dfu->data.nand.size; | |
120 | } | |
121 | ||
122 | static int dfu_read_medium_nand(struct dfu_entity *dfu, u64 offset, void *buf, | |
123 | long *len) | |
124 | { | |
125 | int ret = -1; | |
126 | ||
127 | switch (dfu->layout) { | |
128 | case DFU_RAW_ADDR: | |
129 | ret = nand_block_read(dfu, offset, buf, len); | |
130 | break; | |
131 | default: | |
132 | printf("%s: Layout (%s) not (yet) supported!\n", __func__, | |
133 | dfu_get_layout(dfu->layout)); | |
134 | } | |
135 | ||
136 | return ret; | |
137 | } | |
138 | ||
139 | static int dfu_flush_medium_nand(struct dfu_entity *dfu) | |
140 | { | |
141 | int ret = 0; | |
142 | u64 off; | |
143 | ||
144 | /* in case of ubi partition, erase rest of the partition */ | |
145 | if (dfu->data.nand.ubi) { | |
146 | struct mtd_info *mtd; | |
147 | nand_erase_options_t opts; | |
148 | ||
149 | if (nand_curr_device < 0 || | |
150 | nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE || | |
151 | !nand_info[nand_curr_device]->name) { | |
152 | printf("%s: invalid nand device\n", __func__); | |
153 | return -1; | |
154 | } | |
155 | ||
156 | mtd = nand_info[nand_curr_device]; | |
157 | ||
158 | memset(&opts, 0, sizeof(opts)); | |
159 | off = dfu->offset; | |
160 | if ((off & (mtd->erasesize - 1)) != 0) { | |
161 | /* | |
162 | * last write ended with unaligned length | |
163 | * sector is erased, jump to next | |
164 | */ | |
165 | off = off & ~((mtd->erasesize - 1)); | |
166 | off += mtd->erasesize; | |
167 | } | |
168 | opts.offset = dfu->data.nand.start + off + | |
169 | dfu->bad_skip; | |
170 | opts.length = dfu->data.nand.start + | |
171 | dfu->data.nand.size - opts.offset; | |
172 | ret = nand_erase_opts(mtd, &opts); | |
173 | if (ret != 0) | |
174 | printf("Failure erase: %d\n", ret); | |
175 | } | |
176 | ||
177 | return ret; | |
178 | } | |
179 | ||
180 | unsigned int dfu_polltimeout_nand(struct dfu_entity *dfu) | |
181 | { | |
182 | /* | |
183 | * Currently, Poll Timeout != 0 is only needed on nand | |
184 | * ubi partition, as the not used sectors need an erase | |
185 | */ | |
186 | if (dfu->data.nand.ubi) | |
187 | return DFU_MANIFEST_POLL_TIMEOUT; | |
188 | ||
189 | return DFU_DEFAULT_POLL_TIMEOUT; | |
190 | } | |
191 | ||
192 | int dfu_fill_entity_nand(struct dfu_entity *dfu, char *devstr, char *s) | |
193 | { | |
194 | char *st; | |
195 | int ret, dev, part; | |
196 | ||
197 | dfu->data.nand.ubi = 0; | |
198 | dfu->dev_type = DFU_DEV_NAND; | |
199 | st = strsep(&s, " "); | |
200 | if (!strcmp(st, "raw")) { | |
201 | dfu->layout = DFU_RAW_ADDR; | |
202 | dfu->data.nand.start = simple_strtoul(s, &s, 16); | |
203 | s++; | |
204 | dfu->data.nand.size = simple_strtoul(s, &s, 16); | |
205 | } else if ((!strcmp(st, "part")) || (!strcmp(st, "partubi"))) { | |
206 | char mtd_id[32]; | |
207 | struct mtd_device *mtd_dev; | |
208 | u8 part_num; | |
209 | struct part_info *pi; | |
210 | ||
211 | dfu->layout = DFU_RAW_ADDR; | |
212 | ||
213 | dev = simple_strtoul(s, &s, 10); | |
214 | s++; | |
215 | part = simple_strtoul(s, &s, 10); | |
216 | ||
217 | sprintf(mtd_id, "%s%d,%d", "nand", dev, part - 1); | |
218 | printf("using id '%s'\n", mtd_id); | |
219 | ||
220 | mtdparts_init(); | |
221 | ||
222 | ret = find_dev_and_part(mtd_id, &mtd_dev, &part_num, &pi); | |
223 | if (ret != 0) { | |
224 | printf("Could not locate '%s'\n", mtd_id); | |
225 | return -1; | |
226 | } | |
227 | ||
228 | dfu->data.nand.start = pi->offset; | |
229 | dfu->data.nand.size = pi->size; | |
230 | if (!strcmp(st, "partubi")) | |
231 | dfu->data.nand.ubi = 1; | |
232 | } else { | |
233 | printf("%s: Memory layout (%s) not supported!\n", __func__, st); | |
234 | return -1; | |
235 | } | |
236 | ||
237 | dfu->get_medium_size = dfu_get_medium_size_nand; | |
238 | dfu->read_medium = dfu_read_medium_nand; | |
239 | dfu->write_medium = dfu_write_medium_nand; | |
240 | dfu->flush_medium = dfu_flush_medium_nand; | |
241 | dfu->poll_timeout = dfu_polltimeout_nand; | |
242 | ||
243 | /* initial state */ | |
244 | dfu->inited = 0; | |
245 | ||
246 | return 0; | |
247 | } |