Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
openocd: remove NULL comparisons with checkpatch [2/2]
[openocd.git] / src / flash / nand / tcl.c
diff --git a/src/flash/nand/tcl.c b/src/flash/nand/tcl.c
index 5e8b46e810be777d776d974b8ea1f7bb3ef2578c..6707314ccc824d3c87caebf02107c8b663aaa57c 100644 (file)
--- a/src/flash/nand/tcl.c
+++ b/src/flash/nand/tcl.c
@@ -37,20 +37,20 @@ COMMAND_HANDLER(handle_nand_list_command)
        int i;
 
        if (!nand_devices) {
-               command_print(CMD_CTX, "no NAND flash devices configured");
+               command_print(CMD, "no NAND flash devices configured");
                return ERROR_OK;
        }
 
        for (p = nand_devices, i = 0; p; p = p->next, i++) {
                if (p->device)
-                       command_print(CMD_CTX, "#%i: %s (%s) "
+                       command_print(CMD, "#%i: %s (%s) "
                                "pagesize: %i, buswidth: %i,\n\t"
                                "blocksize: %i, blocks: %i",
                                i, p->device->name, p->manufacturer->name,
                                p->page_size, p->bus_width,
                                p->erase_size, p->num_blocks);
                else
-                       command_print(CMD_CTX, "#%i: not probed", i);
+                       command_print(CMD, "#%i: not probed", i);
        }
 
        return ERROR_OK;
@@ -83,11 +83,11 @@ COMMAND_HANDLER(handle_nand_info_command)
 
        struct nand_device *p;
        int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &p);
-       if (ERROR_OK != retval)
+       if (retval != ERROR_OK)
                return retval;
 
-       if (NULL == p->device) {
-               command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]);
+       if (!p->device) {
+               command_print(CMD, "#%s: not probed", CMD_ARGV[0]);
                return ERROR_OK;
        }
 
@@ -97,7 +97,7 @@ COMMAND_HANDLER(handle_nand_info_command)
        if (last >= p->num_blocks)
                last = p->num_blocks - 1;
 
-       command_print(CMD_CTX,
+       command_print(CMD,
                "#%i: %s (%s) pagesize: %i, buswidth: %i, erasesize: %i",
                i++,
                p->device->name,
@@ -123,8 +123,8 @@ COMMAND_HANDLER(handle_nand_info_command)
                else
                        bad_state = " (block condition unknown)";
 
-               command_print(CMD_CTX,
-                       "\t#%i: 0x%8.8" PRIx32 " (%" PRId32 "kB) %s%s",
+               command_print(CMD,
+                       "\t#%i: 0x%8.8" PRIx32 " (%" PRIu32 "kB) %s%s",
                        j,
                        p->blocks[j].offset,
                        p->blocks[j].size / 1024,
@@ -142,12 +142,12 @@ COMMAND_HANDLER(handle_nand_probe_command)
 
        struct nand_device *p;
        int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &p);
-       if (ERROR_OK != retval)
+       if (retval != ERROR_OK)
                return retval;
 
        retval = nand_probe(p);
        if (retval == ERROR_OK) {
-               command_print(CMD_CTX, "NAND flash device '%s (%s)' found",
+               command_print(CMD, "NAND flash device '%s (%s)' found",
                        p->device->name, p->manufacturer->name);
        }
 
@@ -161,7 +161,7 @@ COMMAND_HANDLER(handle_nand_erase_command)
 
        struct nand_device *p;
        int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &p);
-       if (ERROR_OK != retval)
+       if (retval != ERROR_OK)
                return retval;
 
        unsigned long offset;
@@ -189,7 +189,7 @@ COMMAND_HANDLER(handle_nand_erase_command)
 
        retval = nand_erase(p, offset, offset + length - 1);
        if (retval == ERROR_OK) {
-               command_print(CMD_CTX, "erased blocks %lu to %lu "
+               command_print(CMD, "erased blocks %lu to %lu "
                        "on NAND flash device #%s '%s'",
                        offset, offset + length - 1,
                        CMD_ARGV[0], p->device->name);
@@ -208,7 +208,7 @@ COMMAND_HANDLER(handle_nand_check_bad_blocks_command)
 
        struct nand_device *p;
        int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &p);
-       if (ERROR_OK != retval)
+       if (retval != ERROR_OK)
                return retval;
 
        if (CMD_ARGC == 3) {
@@ -233,7 +233,7 @@ COMMAND_HANDLER(handle_nand_check_bad_blocks_command)
 
        retval = nand_build_bbt(p, first, last);
        if (retval == ERROR_OK) {
-               command_print(CMD_CTX, "checked NAND flash device for bad blocks, "
+               command_print(CMD, "checked NAND flash device for bad blocks, "
                        "use \"nand info\" command to list blocks");
        }
 
@@ -246,14 +246,14 @@ COMMAND_HANDLER(handle_nand_write_command)
        struct nand_fileio_state s;
        int retval = CALL_COMMAND_HANDLER(nand_fileio_parse_args,
                        &s, &nand, FILEIO_READ, false, true);
-       if (ERROR_OK != retval)
+       if (retval != ERROR_OK)
                return retval;
 
        uint32_t total_bytes = s.size;
        while (s.size > 0) {
                int bytes_read = nand_fileio_read(nand, &s);
                if (bytes_read <= 0) {
-                       command_print(CMD_CTX, "error while reading file");
+                       command_print(CMD, "error while reading file");
                        nand_fileio_cleanup(&s);
                        return ERROR_FAIL;
                }
@@ -261,8 +261,8 @@ COMMAND_HANDLER(handle_nand_write_command)
 
                retval = nand_write_page(nand, s.address / nand->page_size,
                                s.page, s.page_size, s.oob, s.oob_size);
-               if (ERROR_OK != retval) {
-                       command_print(CMD_CTX, "failed writing file %s "
+               if (retval != ERROR_OK) {
+                       command_print(CMD, "failed writing file %s "
                                "to NAND flash %s at offset 0x%8.8" PRIx32,
                                CMD_ARGV[1], CMD_ARGV[0], s.address);
                        nand_fileio_cleanup(&s);
@@ -272,7 +272,7 @@ COMMAND_HANDLER(handle_nand_write_command)
        }
 
        if (nand_fileio_finish(&s) == ERROR_OK) {
-               command_print(CMD_CTX, "wrote file %s to NAND flash %s up to "
+               command_print(CMD, "wrote file %s to NAND flash %s up to "
                        "offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
                        CMD_ARGV[1], CMD_ARGV[0], s.address, duration_elapsed(&s.bench),
                        duration_kbps(&s.bench, total_bytes));
@@ -286,7 +286,7 @@ COMMAND_HANDLER(handle_nand_verify_command)
        struct nand_fileio_state file;
        int retval = CALL_COMMAND_HANDLER(nand_fileio_parse_args,
                        &file, &nand, FILEIO_READ, false, true);
-       if (ERROR_OK != retval)
+       if (retval != ERROR_OK)
                return retval;
 
        struct nand_fileio_state dev;
@@ -295,14 +295,14 @@ COMMAND_HANDLER(handle_nand_verify_command)
        dev.size = file.size;
        dev.oob_format = file.oob_format;
        retval = nand_fileio_start(CMD, nand, NULL, FILEIO_NONE, &dev);
-       if (ERROR_OK != retval)
+       if (retval != ERROR_OK)
                return retval;
 
        while (file.size > 0) {
                retval = nand_read_page(nand, dev.address / dev.page_size,
                                dev.page, dev.page_size, dev.oob, dev.oob_size);
-               if (ERROR_OK != retval) {
-                       command_print(CMD_CTX, "reading NAND flash page failed");
+               if (retval != ERROR_OK) {
+                       command_print(CMD, "reading NAND flash page failed");
                        nand_fileio_cleanup(&dev);
                        nand_fileio_cleanup(&file);
                        return retval;
@@ -310,7 +310,7 @@ COMMAND_HANDLER(handle_nand_verify_command)
 
                int bytes_read = nand_fileio_read(nand, &file);
                if (bytes_read <= 0) {
-                       command_print(CMD_CTX, "error while reading file");
+                       command_print(CMD, "error while reading file");
                        nand_fileio_cleanup(&dev);
                        nand_fileio_cleanup(&file);
                        return ERROR_FAIL;
@@ -318,7 +318,7 @@ COMMAND_HANDLER(handle_nand_verify_command)
 
                if ((dev.page && memcmp(dev.page, file.page, dev.page_size)) ||
                                (dev.oob && memcmp(dev.oob, file.oob, dev.oob_size))) {
-                       command_print(CMD_CTX, "NAND flash contents differ "
+                       command_print(CMD, "NAND flash contents differ "
                                "at 0x%8.8" PRIx32, dev.address);
                        nand_fileio_cleanup(&dev);
                        nand_fileio_cleanup(&file);
@@ -330,7 +330,7 @@ COMMAND_HANDLER(handle_nand_verify_command)
        }
 
        if (nand_fileio_finish(&file) == ERROR_OK) {
-               command_print(CMD_CTX, "verified file %s in NAND flash %s "
+               command_print(CMD, "verified file %s in NAND flash %s "
                        "up to offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
                        CMD_ARGV[1], CMD_ARGV[0], dev.address, duration_elapsed(&file.bench),
                        duration_kbps(&file.bench, dev.size));
@@ -346,23 +346,23 @@ COMMAND_HANDLER(handle_nand_dump_command)
        struct nand_fileio_state s;
        int retval = CALL_COMMAND_HANDLER(nand_fileio_parse_args,
                        &s, &nand, FILEIO_WRITE, true, false);
-       if (ERROR_OK != retval)
+       if (retval != ERROR_OK)
                return retval;
 
        while (s.size > 0) {
                size_t size_written;
                retval = nand_read_page(nand, s.address / nand->page_size,
                                s.page, s.page_size, s.oob, s.oob_size);
-               if (ERROR_OK != retval) {
-                       command_print(CMD_CTX, "reading NAND flash page failed");
+               if (retval != ERROR_OK) {
+                       command_print(CMD, "reading NAND flash page failed");
                        nand_fileio_cleanup(&s);
                        return retval;
                }
 
-               if (NULL != s.page)
+               if (s.page)
                        fileio_write(s.fileio, s.page_size, s.page, &size_written);
 
-               if (NULL != s.oob)
+               if (s.oob)
                        fileio_write(s.fileio, s.oob_size, s.oob, &size_written);
 
                s.size -= nand->page_size;
@@ -374,7 +374,7 @@ COMMAND_HANDLER(handle_nand_dump_command)
                return retval;
 
        if (nand_fileio_finish(&s) == ERROR_OK) {
-               command_print(CMD_CTX, "dumped %zu bytes in %fs (%0.3f KiB/s)",
+               command_print(CMD, "dumped %zu bytes in %fs (%0.3f KiB/s)",
                        filesize, duration_elapsed(&s.bench),
                        duration_kbps(&s.bench, filesize));
        }
@@ -388,11 +388,11 @@ COMMAND_HANDLER(handle_nand_raw_access_command)
 
        struct nand_device *p;
        int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &p);
-       if (ERROR_OK != retval)
+       if (retval != ERROR_OK)
                return retval;
 
-       if (NULL == p->device) {
-               command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]);
+       if (!p->device) {
+               command_print(CMD, "#%s: not probed", CMD_ARGV[0]);
                return ERROR_OK;
        }
 
@@ -400,7 +400,7 @@ COMMAND_HANDLER(handle_nand_raw_access_command)
                COMMAND_PARSE_ENABLE(CMD_ARGV[1], p->use_raw);
 
        const char *msg = p->use_raw ? "enabled" : "disabled";
-       command_print(CMD_CTX, "raw access is %s", msg);
+       command_print(CMD, "raw access is %s", msg);
 
        return ERROR_OK;
 }
@@ -479,8 +479,8 @@ static int nand_init(struct command_context *cmd_ctx)
 {
        if (!nand_devices)
                return ERROR_OK;
-       struct command *parent = command_find_in_context(cmd_ctx, "nand");
-       return register_commands(cmd_ctx, parent, nand_exec_command_handlers);
+
+       return register_commands(cmd_ctx, "nand", nand_exec_command_handlers);
 }
 
 COMMAND_HANDLER(handle_nand_init_command)
@@ -501,15 +501,15 @@ COMMAND_HANDLER(handle_nand_init_command)
 
 static int nand_list_walker(struct nand_flash_controller *c, void *x)
 {
-       struct command_context *cmd_ctx = x;
-       command_print(cmd_ctx, "  %s", c->name);
+       struct command_invocation *cmd = x;
+       command_print(cmd, "  %s", c->name);
        return ERROR_OK;
 }
 
 COMMAND_HANDLER(handle_nand_list_drivers)
 {
-       command_print(CMD_CTX, "Available NAND flash controller drivers:");
-       return nand_driver_walk(&nand_list_walker, CMD_CTX);
+       command_print(CMD, "Available NAND flash controller drivers:");
+       return nand_driver_walk(&nand_list_walker, CMD);
 }
 
 static COMMAND_HELPER(create_nand_device, const char *bank_name,
@@ -527,14 +527,14 @@ static COMMAND_HELPER(create_nand_device, const char *bank_name,
                return ERROR_COMMAND_ARGUMENT_INVALID;
        }
 
-       if (NULL != controller->commands) {
+       if (controller->commands) {
                retval = register_commands(CMD_CTX, NULL,
                                controller->commands);
-               if (ERROR_OK != retval)
+               if (retval != ERROR_OK)
                        return retval;
        }
        c = malloc(sizeof(struct nand_device));
-       if (c == NULL) {
+       if (!c) {
                LOG_ERROR("End of memory");
                return ERROR_FAIL;
        }
@@ -552,7 +552,7 @@ static COMMAND_HELPER(create_nand_device, const char *bank_name,
        c->next = NULL;
 
        retval = CALL_COMMAND_HANDLER(controller->nand_device_command, c);
-       if (ERROR_OK != retval) {
+       if (retval != ERROR_OK) {
                LOG_ERROR("'%s' driver rejected nand flash. Usage: %s",
                        controller->name,
                        controller->usage);
@@ -560,7 +560,7 @@ static COMMAND_HELPER(create_nand_device, const char *bank_name,
                return retval;
        }
 
-       if (controller->usage == NULL)
+       if (!controller->usage)
                LOG_DEBUG("'%s' driver usage field missing", controller->name);
 
        nand_device_add(c);
@@ -580,7 +580,7 @@ COMMAND_HANDLER(handle_nand_device_command)
        const char *driver_name = CMD_ARGV[0];
        struct nand_flash_controller *controller;
        controller = nand_driver_find_by_name(CMD_ARGV[0]);
-       if (NULL == controller) {
+       if (!controller) {
                LOG_ERROR("No valid NAND flash driver found (%s)", driver_name);
                return CALL_COMMAND_HANDLER(handle_nand_list_drivers);
        }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)