clk: stm32mp1: correctly handle Clock Spreading Generator

[oweals/u-boot.git] / drivers / dfu / dfu_mmc.c

diff --git a/drivers/dfu/dfu_mmc.c b/drivers/dfu/dfu_mmc.c
index 39e10b1a5a67ea209af02245c7e5b2437af4905c..403fd5351d7738f1175dd5da2bc82829fb4d86dc 100644 (file)
--- a/drivers/dfu/dfu_mmc.c
+++ b/drivers/dfu/dfu_mmc.c
@@ -1,10 +1,9 @@
+// SPDX-License-Identifier: GPL-2.0+
 /*
  * dfu.c -- DFU back-end routines
  *
  * Copyright (C) 2012 Samsung Electronics
  * author: Lukasz Majewski <l.majewski@samsung.com>
- *
- * SPDX-License-Identifier:    GPL-2.0+
  */
 
 #include <common.h>
@@ -29,7 +28,7 @@ static int mmc_block_op(enum dfu_op op, struct dfu_entity *dfu,
 
        mmc = find_mmc_device(dfu->data.mmc.dev_num);
        if (!mmc) {
-               error("Device MMC %d - not found!", dfu->data.mmc.dev_num);
+               pr_err("Device MMC %d - not found!", dfu->data.mmc.dev_num);
                return -ENODEV;
        }
 
@@ -69,11 +68,11 @@ static int mmc_block_op(enum dfu_op op, struct dfu_entity *dfu,
                               buf);
                break;
        default:
-               error("Operation not supported\n");
+               pr_err("Operation not supported\n");
        }
 
        if (n != blk_count) {
-               error("MMC operation failed");
+               pr_err("MMC operation failed");
                if (dfu->data.mmc.hw_partition >= 0)
                        blk_select_hwpart_devnum(IF_TYPE_MMC,
                                                 dfu->data.mmc.dev_num,
@@ -109,17 +108,17 @@ static int mmc_file_buffer(struct dfu_entity *dfu, void *buf, long *len)
 static int mmc_file_op(enum dfu_op op, struct dfu_entity *dfu,
                        void *buf, u64 *len)
 {
-       const char *fsname, *opname;
-       char cmd_buf[DFU_CMD_BUF_SIZE];
-       char *str_env;
+       char dev_part_str[8];
        int ret;
+       int fstype;
+       loff_t size = 0;
 
        switch (dfu->layout) {
        case DFU_FS_FAT:
-               fsname = "fat";
+               fstype = FS_TYPE_FAT;
                break;
        case DFU_FS_EXT4:
-               fsname = "ext4";
+               fstype = FS_TYPE_EXT;
                break;
        default:
                printf("%s: Layout (%s) not (yet) supported!\n", __func__,
@@ -127,48 +126,43 @@ static int mmc_file_op(enum dfu_op op, struct dfu_entity *dfu,
                return -1;
        }
 
+       snprintf(dev_part_str, sizeof(dev_part_str), "%d:%d",
+                dfu->data.mmc.dev, dfu->data.mmc.part);
+
+       ret = fs_set_blk_dev("mmc", dev_part_str, fstype);
+       if (ret) {
+               puts("dfu: fs_set_blk_dev error!\n");
+               return ret;
+       }
+
        switch (op) {
        case DFU_OP_READ:
-               opname = "load";
+               ret = fs_read(dfu->name, (size_t)buf, 0, 0, &size);
+               if (ret) {
+                       puts("dfu: fs_read error!\n");
+                       return ret;
+               }
+               *len = size;
                break;
        case DFU_OP_WRITE:
-               opname = "write";
+               ret = fs_write(dfu->name, (size_t)buf, 0, *len, &size);
+               if (ret) {
+                       puts("dfu: fs_write error!\n");
+                       return ret;
+               }
                break;
        case DFU_OP_SIZE:
-               opname = "size";
+               ret = fs_size(dfu->name, &size);
+               if (ret) {
+                       puts("dfu: fs_size error!\n");
+                       return ret;
+               }
+               *len = size;
                break;
        default:
                return -1;
        }
 
-       sprintf(cmd_buf, "%s%s mmc %d:%d", fsname, opname,
-               dfu->data.mmc.dev, dfu->data.mmc.part);
-
-       if (op != DFU_OP_SIZE)
-               sprintf(cmd_buf + strlen(cmd_buf), " %p", buf);
-
-       sprintf(cmd_buf + strlen(cmd_buf), " %s", dfu->name);
-
-       if (op == DFU_OP_WRITE)
-               sprintf(cmd_buf + strlen(cmd_buf), " %llx", *len);
-
-       debug("%s: %s 0x%p\n", __func__, cmd_buf, cmd_buf);
-
-       ret = run_command(cmd_buf, 0);
-       if (ret) {
-               puts("dfu: Read error!\n");
-               return ret;
-       }
-
-       if (op != DFU_OP_WRITE) {
-               str_env = env_get("filesize");
-               if (str_env == NULL) {
-                       puts("dfu: Wrong file size!\n");
-                       return -1;
-               }
-               *len = simple_strtoul(str_env, NULL, 16);
-       }
-
        return ret;
 }
 
@@ -312,7 +306,7 @@ int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
        for (; parg < argv + sizeof(argv) / sizeof(*argv); ++parg) {
                *parg = strsep(&s, " ");
                if (*parg == NULL) {
-                       error("Invalid number of arguments.\n");
+                       pr_err("Invalid number of arguments.\n");
                        return -ENODEV;
                }
        }
@@ -327,13 +321,13 @@ int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
 
        mmc = find_mmc_device(dfu->data.mmc.dev_num);
        if (mmc == NULL) {
-               error("Couldn't find MMC device no. %d.\n",
+               pr_err("Couldn't find MMC device no. %d.\n",
                      dfu->data.mmc.dev_num);
                return -ENODEV;
        }
 
        if (mmc_init(mmc)) {
-               error("Couldn't init MMC device.\n");
+               pr_err("Couldn't init MMC device.\n");
                return -ENODEV;
        }
 
@@ -360,7 +354,7 @@ int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
                int mmcpart = third_arg;
 
                if (part_get_info(blk_dev, mmcpart, &partinfo) != 0) {
-                       error("Couldn't find part #%d on mmc device #%d\n",
+                       pr_err("Couldn't find part #%d on mmc device #%d\n",
                              mmcpart, mmcdev);
                        return -ENODEV;
                }
@@ -374,7 +368,7 @@ int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
        } else if (!strcmp(entity_type, "ext4")) {
                dfu->layout = DFU_FS_EXT4;
        } else {
-               error("Memory layout (%s) not supported!\n", entity_type);
+               pr_err("Memory layout (%s) not supported!\n", entity_type);
                return -ENODEV;
        }
 
@@ -397,7 +391,7 @@ int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
                dfu_file_buf = memalign(CONFIG_SYS_CACHELINE_SIZE,
                                        CONFIG_SYS_DFU_MAX_FILE_SIZE);
                if (!dfu_file_buf) {
-                       error("Could not memalign 0x%x bytes",
+                       pr_err("Could not memalign 0x%x bytes",
                              CONFIG_SYS_DFU_MAX_FILE_SIZE);
                        return -ENOMEM;
                }