1 // SPDX-License-Identifier: GPL-2.0+
3 * dfu.c -- DFU back-end routines
5 * Copyright (C) 2012 Samsung Electronics
6 * author: Lukasz Majewski <l.majewski@samsung.com>
18 static unsigned char *dfu_file_buf
;
19 static u64 dfu_file_buf_len
;
20 static long dfu_file_buf_filled
;
22 static int mmc_block_op(enum dfu_op op
, struct dfu_entity
*dfu
,
23 u64 offset
, void *buf
, long *len
)
26 u32 blk_start
, blk_count
, n
= 0;
27 int ret
, part_num_bkp
= 0;
29 mmc
= find_mmc_device(dfu
->data
.mmc
.dev_num
);
31 pr_err("Device MMC %d - not found!", dfu
->data
.mmc
.dev_num
);
36 * We must ensure that we work in lba_blk_size chunks, so ALIGN
39 *len
= ALIGN(*len
, dfu
->data
.mmc
.lba_blk_size
);
41 blk_start
= dfu
->data
.mmc
.lba_start
+
42 (u32
)lldiv(offset
, dfu
->data
.mmc
.lba_blk_size
);
43 blk_count
= *len
/ dfu
->data
.mmc
.lba_blk_size
;
44 if (blk_start
+ blk_count
>
45 dfu
->data
.mmc
.lba_start
+ dfu
->data
.mmc
.lba_size
) {
46 puts("Request would exceed designated area!\n");
50 if (dfu
->data
.mmc
.hw_partition
>= 0) {
51 part_num_bkp
= mmc_get_blk_desc(mmc
)->hwpart
;
52 ret
= blk_select_hwpart_devnum(IF_TYPE_MMC
,
53 dfu
->data
.mmc
.dev_num
,
54 dfu
->data
.mmc
.hw_partition
);
59 debug("%s: %s dev: %d start: %d cnt: %d buf: 0x%p\n", __func__
,
60 op
== DFU_OP_READ
? "MMC READ" : "MMC WRITE",
61 dfu
->data
.mmc
.dev_num
, blk_start
, blk_count
, buf
);
64 n
= blk_dread(mmc_get_blk_desc(mmc
), blk_start
, blk_count
, buf
);
67 n
= blk_dwrite(mmc_get_blk_desc(mmc
), blk_start
, blk_count
,
71 pr_err("Operation not supported\n");
75 pr_err("MMC operation failed");
76 if (dfu
->data
.mmc
.hw_partition
>= 0)
77 blk_select_hwpart_devnum(IF_TYPE_MMC
,
78 dfu
->data
.mmc
.dev_num
,
83 if (dfu
->data
.mmc
.hw_partition
>= 0) {
84 ret
= blk_select_hwpart_devnum(IF_TYPE_MMC
,
85 dfu
->data
.mmc
.dev_num
,
94 static int mmc_file_buffer(struct dfu_entity
*dfu
, void *buf
, long *len
)
96 if (dfu_file_buf_len
+ *len
> CONFIG_SYS_DFU_MAX_FILE_SIZE
) {
101 /* Add to the current buffer. */
102 memcpy(dfu_file_buf
+ dfu_file_buf_len
, buf
, *len
);
103 dfu_file_buf_len
+= *len
;
108 static int mmc_file_op(enum dfu_op op
, struct dfu_entity
*dfu
,
111 char dev_part_str
[8];
116 switch (dfu
->layout
) {
118 fstype
= FS_TYPE_FAT
;
121 fstype
= FS_TYPE_EXT
;
124 printf("%s: Layout (%s) not (yet) supported!\n", __func__
,
125 dfu_get_layout(dfu
->layout
));
129 snprintf(dev_part_str
, sizeof(dev_part_str
), "%d:%d",
130 dfu
->data
.mmc
.dev
, dfu
->data
.mmc
.part
);
132 ret
= fs_set_blk_dev("mmc", dev_part_str
, fstype
);
134 puts("dfu: fs_set_blk_dev error!\n");
140 ret
= fs_read(dfu
->name
, (size_t)buf
, 0, 0, &size
);
142 puts("dfu: fs_read error!\n");
148 ret
= fs_write(dfu
->name
, (size_t)buf
, 0, *len
, &size
);
150 puts("dfu: fs_write error!\n");
155 ret
= fs_size(dfu
->name
, &size
);
157 puts("dfu: fs_size error!\n");
169 int dfu_write_medium_mmc(struct dfu_entity
*dfu
,
170 u64 offset
, void *buf
, long *len
)
174 switch (dfu
->layout
) {
176 ret
= mmc_block_op(DFU_OP_WRITE
, dfu
, offset
, buf
, len
);
180 ret
= mmc_file_buffer(dfu
, buf
, len
);
183 printf("%s: Layout (%s) not (yet) supported!\n", __func__
,
184 dfu_get_layout(dfu
->layout
));
190 int dfu_flush_medium_mmc(struct dfu_entity
*dfu
)
194 if (dfu
->layout
!= DFU_RAW_ADDR
) {
196 ret
= mmc_file_op(DFU_OP_WRITE
, dfu
, dfu_file_buf
,
199 /* Now that we're done */
200 dfu_file_buf_len
= 0;
206 int dfu_get_medium_size_mmc(struct dfu_entity
*dfu
, u64
*size
)
210 switch (dfu
->layout
) {
212 *size
= dfu
->data
.mmc
.lba_size
* dfu
->data
.mmc
.lba_blk_size
;
216 dfu_file_buf_filled
= -1;
217 ret
= mmc_file_op(DFU_OP_SIZE
, dfu
, NULL
, size
);
220 if (*size
> CONFIG_SYS_DFU_MAX_FILE_SIZE
)
224 printf("%s: Layout (%s) not (yet) supported!\n", __func__
,
225 dfu_get_layout(dfu
->layout
));
230 static int mmc_file_unbuffer(struct dfu_entity
*dfu
, u64 offset
, void *buf
,
236 if (dfu_file_buf_filled
== -1) {
237 ret
= mmc_file_op(DFU_OP_READ
, dfu
, dfu_file_buf
, &file_len
);
240 dfu_file_buf_filled
= file_len
;
242 if (offset
+ *len
> dfu_file_buf_filled
)
245 /* Add to the current buffer. */
246 memcpy(buf
, dfu_file_buf
+ offset
, *len
);
251 int dfu_read_medium_mmc(struct dfu_entity
*dfu
, u64 offset
, void *buf
,
256 switch (dfu
->layout
) {
258 ret
= mmc_block_op(DFU_OP_READ
, dfu
, offset
, buf
, len
);
262 ret
= mmc_file_unbuffer(dfu
, offset
, buf
, len
);
265 printf("%s: Layout (%s) not (yet) supported!\n", __func__
,
266 dfu_get_layout(dfu
->layout
));
272 void dfu_free_entity_mmc(struct dfu_entity
*dfu
)
281 * @param s Parameter string containing space-separated arguments:
283 * raw (raw read/write)
286 * part (partition image)
288 * lba_start and lba_size, for raw write
289 * mmc_dev and mmc_part, for filesystems and part
291 * mmcpart <num> (access to HW eMMC partitions)
293 int dfu_fill_entity_mmc(struct dfu_entity
*dfu
, char *devstr
, char *s
)
295 const char *entity_type
;
302 const char **parg
= argv
;
304 dfu
->data
.mmc
.dev_num
= simple_strtoul(devstr
, NULL
, 10);
306 for (; parg
< argv
+ sizeof(argv
) / sizeof(*argv
); ++parg
) {
307 *parg
= strsep(&s
, " ");
309 pr_err("Invalid number of arguments.\n");
314 entity_type
= argv
[0];
316 * Base 0 means we'll accept (prefixed with 0x or 0) base 16, 8,
319 second_arg
= simple_strtoul(argv
[1], NULL
, 0);
320 third_arg
= simple_strtoul(argv
[2], NULL
, 0);
322 mmc
= find_mmc_device(dfu
->data
.mmc
.dev_num
);
324 pr_err("Couldn't find MMC device no. %d.\n",
325 dfu
->data
.mmc
.dev_num
);
330 pr_err("Couldn't init MMC device.\n");
334 dfu
->data
.mmc
.hw_partition
= -EINVAL
;
335 if (!strcmp(entity_type
, "raw")) {
336 dfu
->layout
= DFU_RAW_ADDR
;
337 dfu
->data
.mmc
.lba_start
= second_arg
;
338 dfu
->data
.mmc
.lba_size
= third_arg
;
339 dfu
->data
.mmc
.lba_blk_size
= mmc
->read_bl_len
;
342 * Check for an extra entry at dfu_alt_info env variable
343 * specifying the mmc HW defined partition number
346 if (!strcmp(strsep(&s
, " "), "mmcpart"))
347 dfu
->data
.mmc
.hw_partition
=
348 simple_strtoul(s
, NULL
, 0);
350 } else if (!strcmp(entity_type
, "part")) {
351 disk_partition_t partinfo
;
352 struct blk_desc
*blk_dev
= mmc_get_blk_desc(mmc
);
353 int mmcdev
= second_arg
;
354 int mmcpart
= third_arg
;
357 if (part_get_info(blk_dev
, mmcpart
, &partinfo
) != 0) {
358 pr_err("Couldn't find part #%d on mmc device #%d\n",
364 * Check for an extra entry at dfu_alt_info env variable
365 * specifying the mmc HW defined partition number
368 if (!strcmp(strsep(&s
, " "), "offset"))
369 offset
= simple_strtoul(s
, NULL
, 0);
371 dfu
->layout
= DFU_RAW_ADDR
;
372 dfu
->data
.mmc
.lba_start
= partinfo
.start
+ offset
;
373 dfu
->data
.mmc
.lba_size
= partinfo
.size
-offset
;
374 dfu
->data
.mmc
.lba_blk_size
= partinfo
.blksz
;
375 } else if (!strcmp(entity_type
, "fat")) {
376 dfu
->layout
= DFU_FS_FAT
;
377 } else if (!strcmp(entity_type
, "ext4")) {
378 dfu
->layout
= DFU_FS_EXT4
;
380 pr_err("Memory layout (%s) not supported!\n", entity_type
);
384 /* if it's NOT a raw write */
385 if (strcmp(entity_type
, "raw")) {
386 dfu
->data
.mmc
.dev
= second_arg
;
387 dfu
->data
.mmc
.part
= third_arg
;
390 dfu
->dev_type
= DFU_DEV_MMC
;
391 dfu
->get_medium_size
= dfu_get_medium_size_mmc
;
392 dfu
->read_medium
= dfu_read_medium_mmc
;
393 dfu
->write_medium
= dfu_write_medium_mmc
;
394 dfu
->flush_medium
= dfu_flush_medium_mmc
;
396 dfu
->free_entity
= dfu_free_entity_mmc
;
398 /* Check if file buffer is ready */
400 dfu_file_buf
= memalign(CONFIG_SYS_CACHELINE_SIZE
,
401 CONFIG_SYS_DFU_MAX_FILE_SIZE
);
403 pr_err("Could not memalign 0x%x bytes",
404 CONFIG_SYS_DFU_MAX_FILE_SIZE
);