[HUST CSE] Fix many abnormal symbols in annotations and format code

components/drivers/audio/audio.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/audio/audio_pipe.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/audio/audio_pipe.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/can/can.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/cputime/cputime.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/cputime/cputime_cortexm.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/fdt/libfdt/fdt.c

@@ -55,195 +55,195 @@
 
 int fdt_check_header(const void *fdt)
 {
-	if (fdt_magic(fdt) == FDT_MAGIC) {
-		/* Complete tree */
-		if (fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)
-			return -FDT_ERR_BADVERSION;
-		if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION)
-			return -FDT_ERR_BADVERSION;
-	} else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
-		/* Unfinished sequential-write blob */
-		if (fdt_size_dt_struct(fdt) == 0)
-			return -FDT_ERR_BADSTATE;
-	} else {
-		return -FDT_ERR_BADMAGIC;
-	}
+    if (fdt_magic(fdt) == FDT_MAGIC) {
+        /* Complete tree */
+        if (fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)
+            return -FDT_ERR_BADVERSION;
+        if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION)
+            return -FDT_ERR_BADVERSION;
+    } else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
+        /* Unfinished sequential-write blob */
+        if (fdt_size_dt_struct(fdt) == 0)
+            return -FDT_ERR_BADSTATE;
+    } else {
+        return -FDT_ERR_BADMAGIC;
+    }
 
-	return 0;
+    return 0;
 }
 
 const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int len)
 {
-	unsigned absoffset = offset + fdt_off_dt_struct(fdt);
+    unsigned absoffset = offset + fdt_off_dt_struct(fdt);
 
-	if ((absoffset < offset)
-	    || ((absoffset + len) < absoffset)
-	    || (absoffset + len) > fdt_totalsize(fdt))
-		return NULL;
+    if ((absoffset < offset)
+        || ((absoffset + len) < absoffset)
+        || (absoffset + len) > fdt_totalsize(fdt))
+        return NULL;
 
-	if (fdt_version(fdt) >= 0x11)
-		if (((offset + len) < offset)
-		    || ((offset + len) > fdt_size_dt_struct(fdt)))
-			return NULL;
+    if (fdt_version(fdt) >= 0x11)
+        if (((offset + len) < offset)
+            || ((offset + len) > fdt_size_dt_struct(fdt)))
+            return NULL;
 
-	return _fdt_offset_ptr(fdt, offset);
+    return _fdt_offset_ptr(fdt, offset);
 }
 
 uint32_t fdt_next_tag(const void *fdt, int startoffset, int *nextoffset)
 {
-	const fdt32_t *tagp, *lenp;
-	uint32_t tag;
-	int offset = startoffset;
-	const char *p;
+    const fdt32_t *tagp, *lenp;
+    uint32_t tag;
+    int offset = startoffset;
+    const char *p;
 
-	*nextoffset = -FDT_ERR_TRUNCATED;
-	tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);
-	if (!tagp)
-		return FDT_END; /* premature end */
-	tag = fdt32_to_cpu(*tagp);
-	offset += FDT_TAGSIZE;
+    *nextoffset = -FDT_ERR_TRUNCATED;
+    tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);
+    if (!tagp)
+        return FDT_END; /* premature end */
+    tag = fdt32_to_cpu(*tagp);
+    offset += FDT_TAGSIZE;
 
-	*nextoffset = -FDT_ERR_BADSTRUCTURE;
-	switch (tag) {
-	case FDT_BEGIN_NODE:
-		/* skip name */
-		do {
-			p = fdt_offset_ptr(fdt, offset++, 1);
-		} while (p && (*p != '\0'));
-		if (!p)
-			return FDT_END; /* premature end */
-		break;
+    *nextoffset = -FDT_ERR_BADSTRUCTURE;
+    switch (tag) {
+    case FDT_BEGIN_NODE:
+        /* skip name */
+        do {
+            p = fdt_offset_ptr(fdt, offset++, 1);
+        } while (p && (*p != '\0'));
+        if (!p)
+            return FDT_END; /* premature end */
+        break;
 
-	case FDT_PROP:
-		lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));
-		if (!lenp)
-			return FDT_END; /* premature end */
-		/* skip-name offset, length and value */
-		offset += sizeof(struct fdt_property) - FDT_TAGSIZE
-			+ fdt32_to_cpu(*lenp);
-		break;
+    case FDT_PROP:
+        lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));
+        if (!lenp)
+            return FDT_END; /* premature end */
+        /* skip-name offset, length and value */
+        offset += sizeof(struct fdt_property) - FDT_TAGSIZE
+            + fdt32_to_cpu(*lenp);
+        break;
 
-	case FDT_END:
-	case FDT_END_NODE:
-	case FDT_NOP:
-		break;
+    case FDT_END:
+    case FDT_END_NODE:
+    case FDT_NOP:
+        break;
 
-	default:
-		return FDT_END;
-	}
+    default:
+        return FDT_END;
+    }
 
-	if (!fdt_offset_ptr(fdt, startoffset, offset - startoffset))
-		return FDT_END; /* premature end */
+    if (!fdt_offset_ptr(fdt, startoffset, offset - startoffset))
+        return FDT_END; /* premature end */
 
-	*nextoffset = FDT_TAGALIGN(offset);
-	return tag;
+    *nextoffset = FDT_TAGALIGN(offset);
+    return tag;
 }
 
 int _fdt_check_node_offset(const void *fdt, int offset)
 {
-	if ((offset < 0) || (offset % FDT_TAGSIZE)
-	    || (fdt_next_tag(fdt, offset, &offset) != FDT_BEGIN_NODE))
-		return -FDT_ERR_BADOFFSET;
+    if ((offset < 0) || (offset % FDT_TAGSIZE)
+        || (fdt_next_tag(fdt, offset, &offset) != FDT_BEGIN_NODE))
+        return -FDT_ERR_BADOFFSET;
 
-	return offset;
+    return offset;
 }
 
 int _fdt_check_prop_offset(const void *fdt, int offset)
 {
-	if ((offset < 0) || (offset % FDT_TAGSIZE)
-	    || (fdt_next_tag(fdt, offset, &offset) != FDT_PROP))
-		return -FDT_ERR_BADOFFSET;
+    if ((offset < 0) || (offset % FDT_TAGSIZE)
+        || (fdt_next_tag(fdt, offset, &offset) != FDT_PROP))
+        return -FDT_ERR_BADOFFSET;
 
-	return offset;
+    return offset;
 }
 
 int fdt_next_node(const void *fdt, int offset, int *depth)
 {
-	int nextoffset = 0;
-	uint32_t tag;
+    int nextoffset = 0;
+    uint32_t tag;
 
-	if (offset >= 0)
-		if ((nextoffset = _fdt_check_node_offset(fdt, offset)) < 0)
-			return nextoffset;
+    if (offset >= 0)
+        if ((nextoffset = _fdt_check_node_offset(fdt, offset)) < 0)
+            return nextoffset;
 
-	do {
-		offset = nextoffset;
-		tag = fdt_next_tag(fdt, offset, &nextoffset);
+    do {
+        offset = nextoffset;
+        tag = fdt_next_tag(fdt, offset, &nextoffset);
 
-		switch (tag) {
-		case FDT_PROP:
-		case FDT_NOP:
-			break;
+        switch (tag) {
+        case FDT_PROP:
+        case FDT_NOP:
+            break;
 
-		case FDT_BEGIN_NODE:
-			if (depth)
-				(*depth)++;
-			break;
+        case FDT_BEGIN_NODE:
+            if (depth)
+                (*depth)++;
+            break;
 
-		case FDT_END_NODE:
-			if (depth && ((--(*depth)) < 0))
-				return nextoffset;
-			break;
+        case FDT_END_NODE:
+            if (depth && ((--(*depth)) < 0))
+                return nextoffset;
+            break;
 
-		case FDT_END:
-			if ((nextoffset >= 0)
-			    || ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))
-				return -FDT_ERR_NOTFOUND;
-			else
-				return nextoffset;
-		}
-	} while (tag != FDT_BEGIN_NODE);
+        case FDT_END:
+            if ((nextoffset >= 0)
+                || ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))
+                return -FDT_ERR_NOTFOUND;
+            else
+                return nextoffset;
+        }
+    } while (tag != FDT_BEGIN_NODE);
 
-	return offset;
+    return offset;
 }
 
 int fdt_first_subnode(const void *fdt, int offset)
 {
-	int depth = 0;
+    int depth = 0;
 
-	offset = fdt_next_node(fdt, offset, &depth);
-	if (offset < 0 || depth != 1)
-		return -FDT_ERR_NOTFOUND;
+    offset = fdt_next_node(fdt, offset, &depth);
+    if (offset < 0 || depth != 1)
+        return -FDT_ERR_NOTFOUND;
 
-	return offset;
+    return offset;
 }
 
 int fdt_next_subnode(const void *fdt, int offset)
 {
-	int depth = 1;
+    int depth = 1;
 
-	/*
-	 * With respect to the parent, the depth of the next subnode will be
-	 * the same as the last.
-	 */
-	do {
-		offset = fdt_next_node(fdt, offset, &depth);
-		if (offset < 0 || depth < 1)
-			return -FDT_ERR_NOTFOUND;
-	} while (depth > 1);
+    /*
+     * With respect to the parent, the depth of the next subnode will be
+     * the same as the last.
+     */
+    do {
+        offset = fdt_next_node(fdt, offset, &depth);
+        if (offset < 0 || depth < 1)
+            return -FDT_ERR_NOTFOUND;
+    } while (depth > 1);
 
-	return offset;
+    return offset;
 }
 
 const char *_fdt_find_string(const char *strtab, int tabsize, const char *s)
 {
-	int len = strlen(s) + 1;
-	const char *last = strtab + tabsize - len;
-	const char *p;
+    int len = strlen(s) + 1;
+    const char *last = strtab + tabsize - len;
+    const char *p;
 
-	for (p = strtab; p <= last; p++)
-		if (memcmp(p, s, len) == 0)
-			return p;
-	return NULL;
+    for (p = strtab; p <= last; p++)
+        if (memcmp(p, s, len) == 0)
+            return p;
+    return NULL;
 }
 
 int fdt_move(const void *fdt, void *buf, int bufsize)
 {
-	FDT_CHECK_HEADER(fdt);
+    FDT_CHECK_HEADER(fdt);
 
-	if (fdt_totalsize(fdt) > bufsize)
-		return -FDT_ERR_NOSPACE;
+    if (fdt_totalsize(fdt) > bufsize)
+        return -FDT_ERR_NOSPACE;
 
-	memmove(buf, fdt, fdt_totalsize(fdt));
-	return 0;
+    memmove(buf, fdt, fdt_totalsize(fdt));
+    return 0;
 }

components/drivers/fdt/libfdt/fdt.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/fdt/libfdt/fdt_empty_tree.c

@@ -57,28 +57,28 @@
 
 int fdt_create_empty_tree(void *buf, int bufsize)
 {
-	int err;
+    int err;
 
-	err = fdt_create(buf, bufsize);
-	if (err)
-		return err;
+    err = fdt_create(buf, bufsize);
+    if (err)
+        return err;
 
-	err = fdt_finish_reservemap(buf);
-	if (err)
-		return err;
+    err = fdt_finish_reservemap(buf);
+    if (err)
+        return err;
 
-	err = fdt_begin_node(buf, "");
-	if (err)
-		return err;
+    err = fdt_begin_node(buf, "");
+    if (err)
+        return err;
 
-	err =  fdt_end_node(buf);
-	if (err)
-		return err;
+    err =  fdt_end_node(buf);
+    if (err)
+        return err;
 
-	err = fdt_finish(buf);
-	if (err)
-		return err;
+    err = fdt_finish(buf);
+    if (err)
+        return err;
 
-	return fdt_open_into(buf, buf, bufsize);
+    return fdt_open_into(buf, buf, bufsize);
 }
 

components/drivers/fdt/libfdt/fdt_strerror.c

@@ -54,47 +54,47 @@
 #include "libfdt_internal.h"
 
 struct fdt_errtabent {
-	const char *str;
+    const char *str;
 };
 
 #define FDT_ERRTABENT(val) \
-	[(val)] = { .str = #val, }
+    [(val)] = { .str = #val, }
 
 static struct fdt_errtabent fdt_errtable[] = {
-	FDT_ERRTABENT(FDT_ERR_NOTFOUND),
-	FDT_ERRTABENT(FDT_ERR_EXISTS),
-	FDT_ERRTABENT(FDT_ERR_NOSPACE),
+    FDT_ERRTABENT(FDT_ERR_NOTFOUND),
+    FDT_ERRTABENT(FDT_ERR_EXISTS),
+    FDT_ERRTABENT(FDT_ERR_NOSPACE),
 
-	FDT_ERRTABENT(FDT_ERR_BADOFFSET),
-	FDT_ERRTABENT(FDT_ERR_BADPATH),
-	FDT_ERRTABENT(FDT_ERR_BADPHANDLE),
-	FDT_ERRTABENT(FDT_ERR_BADSTATE),
+    FDT_ERRTABENT(FDT_ERR_BADOFFSET),
+    FDT_ERRTABENT(FDT_ERR_BADPATH),
+    FDT_ERRTABENT(FDT_ERR_BADPHANDLE),
+    FDT_ERRTABENT(FDT_ERR_BADSTATE),
 
-	FDT_ERRTABENT(FDT_ERR_TRUNCATED),
-	FDT_ERRTABENT(FDT_ERR_BADMAGIC),
-	FDT_ERRTABENT(FDT_ERR_BADVERSION),
-	FDT_ERRTABENT(FDT_ERR_BADSTRUCTURE),
-	FDT_ERRTABENT(FDT_ERR_BADLAYOUT),
-	FDT_ERRTABENT(FDT_ERR_INTERNAL),
-	FDT_ERRTABENT(FDT_ERR_BADNCELLS),
-	FDT_ERRTABENT(FDT_ERR_BADVALUE),
-	FDT_ERRTABENT(FDT_ERR_BADOVERLAY),
-	FDT_ERRTABENT(FDT_ERR_NOPHANDLES),
+    FDT_ERRTABENT(FDT_ERR_TRUNCATED),
+    FDT_ERRTABENT(FDT_ERR_BADMAGIC),
+    FDT_ERRTABENT(FDT_ERR_BADVERSION),
+    FDT_ERRTABENT(FDT_ERR_BADSTRUCTURE),
+    FDT_ERRTABENT(FDT_ERR_BADLAYOUT),
+    FDT_ERRTABENT(FDT_ERR_INTERNAL),
+    FDT_ERRTABENT(FDT_ERR_BADNCELLS),
+    FDT_ERRTABENT(FDT_ERR_BADVALUE),
+    FDT_ERRTABENT(FDT_ERR_BADOVERLAY),
+    FDT_ERRTABENT(FDT_ERR_NOPHANDLES),
 };
-#define FDT_ERRTABSIZE	(sizeof(fdt_errtable) / sizeof(fdt_errtable[0]))
+#define FDT_ERRTABSIZE  (sizeof(fdt_errtable) / sizeof(fdt_errtable[0]))
 
 const char *fdt_strerror(int errval)
 {
-	if (errval > 0)
-		return "<valid offset/length>";
-	else if (errval == 0)
-		return "<no error>";
-	else if (errval > -FDT_ERRTABSIZE) {
-		const char *s = fdt_errtable[-errval].str;
+    if (errval > 0)
+        return "<valid offset/length>";
+    else if (errval == 0)
+        return "<no error>";
+    else if (errval > -FDT_ERRTABSIZE) {
+        const char *s = fdt_errtable[-errval].str;
 
-		if (s)
-			return s;
-	}
+        if (s)
+            return s;
+    }
 
-	return "<unknown error>";
+    return "<unknown error>";
 }

components/drivers/fdt/libfdt/fdt_sw.c

@@ -55,232 +55,232 @@
 
 static int _fdt_sw_check_header(void *fdt)
 {
-	if (fdt_magic(fdt) != FDT_SW_MAGIC)
-		return -FDT_ERR_BADMAGIC;
-	/* FIXME: should check more details about the header state */
-	return 0;
+    if (fdt_magic(fdt) != FDT_SW_MAGIC)
+        return -FDT_ERR_BADMAGIC;
+    /* FIXME: should check more details about the header state */
+    return 0;
 }
 
 #define FDT_SW_CHECK_HEADER(fdt) \
-	{ \
-		int err; \
-		if ((err = _fdt_sw_check_header(fdt)) != 0) \
-			return err; \
-	}
+    { \
+        int err; \
+        if ((err = _fdt_sw_check_header(fdt)) != 0) \
+            return err; \
+    }
 
 static void *_fdt_grab_space(void *fdt, size_t len)
 {
-	int offset = fdt_size_dt_struct(fdt);
-	int spaceleft;
+    int offset = fdt_size_dt_struct(fdt);
+    int spaceleft;
 
-	spaceleft = fdt_totalsize(fdt) - fdt_off_dt_struct(fdt)
-		- fdt_size_dt_strings(fdt);
+    spaceleft = fdt_totalsize(fdt) - fdt_off_dt_struct(fdt)
+        - fdt_size_dt_strings(fdt);
 
-	if ((offset + len < offset) || (offset + len > spaceleft))
-		return NULL;
+    if ((offset + len < offset) || (offset + len > spaceleft))
+        return NULL;
 
-	fdt_set_size_dt_struct(fdt, offset + len);
-	return _fdt_offset_ptr_w(fdt, offset);
+    fdt_set_size_dt_struct(fdt, offset + len);
+    return _fdt_offset_ptr_w(fdt, offset);
 }
 
 int fdt_create(void *buf, int bufsize)
 {
-	void *fdt = buf;
+    void *fdt = buf;
 
-	if (bufsize < sizeof(struct fdt_header))
-		return -FDT_ERR_NOSPACE;
+    if (bufsize < sizeof(struct fdt_header))
+        return -FDT_ERR_NOSPACE;
 
-	memset(buf, 0, bufsize);
+    memset(buf, 0, bufsize);
 
-	fdt_set_magic(fdt, FDT_SW_MAGIC);
-	fdt_set_version(fdt, FDT_LAST_SUPPORTED_VERSION);
-	fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);
-	fdt_set_totalsize(fdt,  bufsize);
+    fdt_set_magic(fdt, FDT_SW_MAGIC);
+    fdt_set_version(fdt, FDT_LAST_SUPPORTED_VERSION);
+    fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);
+    fdt_set_totalsize(fdt,  bufsize);
 
-	fdt_set_off_mem_rsvmap(fdt, FDT_ALIGN(sizeof(struct fdt_header),
-					      sizeof(struct fdt_reserve_entry)));
-	fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt));
-	fdt_set_off_dt_strings(fdt, bufsize);
+    fdt_set_off_mem_rsvmap(fdt, FDT_ALIGN(sizeof(struct fdt_header),
+                          sizeof(struct fdt_reserve_entry)));
+    fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt));
+    fdt_set_off_dt_strings(fdt, bufsize);
 
-	return 0;
+    return 0;
 }
 
 int fdt_resize(void *fdt, void *buf, int bufsize)
 {
-	size_t headsize, tailsize;
-	char *oldtail, *newtail;
+    size_t headsize, tailsize;
+    char *oldtail, *newtail;
 
-	FDT_SW_CHECK_HEADER(fdt);
+    FDT_SW_CHECK_HEADER(fdt);
 
-	headsize = fdt_off_dt_struct(fdt);
-	tailsize = fdt_size_dt_strings(fdt);
+    headsize = fdt_off_dt_struct(fdt);
+    tailsize = fdt_size_dt_strings(fdt);
 
-	if ((headsize + tailsize) > bufsize)
-		return -FDT_ERR_NOSPACE;
+    if ((headsize + tailsize) > bufsize)
+        return -FDT_ERR_NOSPACE;
 
-	oldtail = (char *)fdt + fdt_totalsize(fdt) - tailsize;
-	newtail = (char *)buf + bufsize - tailsize;
+    oldtail = (char *)fdt + fdt_totalsize(fdt) - tailsize;
+    newtail = (char *)buf + bufsize - tailsize;
 
-	/* Two cases to avoid clobbering data if the old and new
-	 * buffers partially overlap */
-	if (buf <= fdt) {
-		memmove(buf, fdt, headsize);
-		memmove(newtail, oldtail, tailsize);
-	} else {
-		memmove(newtail, oldtail, tailsize);
-		memmove(buf, fdt, headsize);
-	}
+    /* Two cases to avoid clobbering data if the old and new
+     * buffers partially overlap */
+    if (buf <= fdt) {
+        memmove(buf, fdt, headsize);
+        memmove(newtail, oldtail, tailsize);
+    } else {
+        memmove(newtail, oldtail, tailsize);
+        memmove(buf, fdt, headsize);
+    }
 
-	fdt_set_off_dt_strings(buf, bufsize);
-	fdt_set_totalsize(buf, bufsize);
+    fdt_set_off_dt_strings(buf, bufsize);
+    fdt_set_totalsize(buf, bufsize);
 
-	return 0;
+    return 0;
 }
 
 int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size)
 {
-	struct fdt_reserve_entry *re;
-	int offset;
+    struct fdt_reserve_entry *re;
+    int offset;
 
-	FDT_SW_CHECK_HEADER(fdt);
+    FDT_SW_CHECK_HEADER(fdt);
 
-	if (fdt_size_dt_struct(fdt))
-		return -FDT_ERR_BADSTATE;
+    if (fdt_size_dt_struct(fdt))
+        return -FDT_ERR_BADSTATE;
 
-	offset = fdt_off_dt_struct(fdt);
-	if ((offset + sizeof(*re)) > fdt_totalsize(fdt))
-		return -FDT_ERR_NOSPACE;
+    offset = fdt_off_dt_struct(fdt);
+    if ((offset + sizeof(*re)) > fdt_totalsize(fdt))
+        return -FDT_ERR_NOSPACE;
 
-	re = (struct fdt_reserve_entry *)((char *)fdt + offset);
-	re->address = cpu_to_fdt64(addr);
-	re->size = cpu_to_fdt64(size);
+    re = (struct fdt_reserve_entry *)((char *)fdt + offset);
+    re->address = cpu_to_fdt64(addr);
+    re->size = cpu_to_fdt64(size);
 
-	fdt_set_off_dt_struct(fdt, offset + sizeof(*re));
+    fdt_set_off_dt_struct(fdt, offset + sizeof(*re));
 
-	return 0;
+    return 0;
 }
 
 int fdt_finish_reservemap(void *fdt)
 {
-	return fdt_add_reservemap_entry(fdt, 0, 0);
+    return fdt_add_reservemap_entry(fdt, 0, 0);
 }
 
 int fdt_begin_node(void *fdt, const char *name)
 {
-	struct fdt_node_header *nh;
-	int namelen = strlen(name) + 1;
+    struct fdt_node_header *nh;
+    int namelen = strlen(name) + 1;
 
-	FDT_SW_CHECK_HEADER(fdt);
+    FDT_SW_CHECK_HEADER(fdt);
 
-	nh = _fdt_grab_space(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));
-	if (! nh)
-		return -FDT_ERR_NOSPACE;
+    nh = _fdt_grab_space(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));
+    if (! nh)
+        return -FDT_ERR_NOSPACE;
 
-	nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
-	memcpy(nh->name, name, namelen);
-	return 0;
+    nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
+    memcpy(nh->name, name, namelen);
+    return 0;
 }
 
 int fdt_end_node(void *fdt)
 {
-	fdt32_t *en;
+    fdt32_t *en;
 
-	FDT_SW_CHECK_HEADER(fdt);
+    FDT_SW_CHECK_HEADER(fdt);
 
-	en = _fdt_grab_space(fdt, FDT_TAGSIZE);
-	if (! en)
-		return -FDT_ERR_NOSPACE;
+    en = _fdt_grab_space(fdt, FDT_TAGSIZE);
+    if (! en)
+        return -FDT_ERR_NOSPACE;
 
-	*en = cpu_to_fdt32(FDT_END_NODE);
-	return 0;
+    *en = cpu_to_fdt32(FDT_END_NODE);
+    return 0;
 }
 
 static int _fdt_find_add_string(void *fdt, const char *s)
 {
-	char *strtab = (char *)fdt + fdt_totalsize(fdt);
-	const char *p;
-	int strtabsize = fdt_size_dt_strings(fdt);
-	int len = strlen(s) + 1;
-	int struct_top, offset;
+    char *strtab = (char *)fdt + fdt_totalsize(fdt);
+    const char *p;
+    int strtabsize = fdt_size_dt_strings(fdt);
+    int len = strlen(s) + 1;
+    int struct_top, offset;
 
-	p = _fdt_find_string(strtab - strtabsize, strtabsize, s);
-	if (p)
-		return p - strtab;
+    p = _fdt_find_string(strtab - strtabsize, strtabsize, s);
+    if (p)
+        return p - strtab;
 
-	/* Add it */
-	offset = -strtabsize - len;
-	struct_top = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
-	if (fdt_totalsize(fdt) + offset < struct_top)
-		return 0; /* no more room :( */
+    /* Add it */
+    offset = -strtabsize - len;
+    struct_top = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
+    if (fdt_totalsize(fdt) + offset < struct_top)
+        return 0; /* no more room :( */
 
-	memcpy(strtab + offset, s, len);
-	fdt_set_size_dt_strings(fdt, strtabsize + len);
-	return offset;
+    memcpy(strtab + offset, s, len);
+    fdt_set_size_dt_strings(fdt, strtabsize + len);
+    return offset;
 }
 
 int fdt_property(void *fdt, const char *name, const void *val, int len)
 {
-	struct fdt_property *prop;
-	int nameoff;
+    struct fdt_property *prop;
+    int nameoff;
 
-	FDT_SW_CHECK_HEADER(fdt);
+    FDT_SW_CHECK_HEADER(fdt);
 
-	nameoff = _fdt_find_add_string(fdt, name);
-	if (nameoff == 0)
-		return -FDT_ERR_NOSPACE;
+    nameoff = _fdt_find_add_string(fdt, name);
+    if (nameoff == 0)
+        return -FDT_ERR_NOSPACE;
 
-	prop = _fdt_grab_space(fdt, sizeof(*prop) + FDT_TAGALIGN(len));
-	if (! prop)
-		return -FDT_ERR_NOSPACE;
+    prop = _fdt_grab_space(fdt, sizeof(*prop) + FDT_TAGALIGN(len));
+    if (! prop)
+        return -FDT_ERR_NOSPACE;
 
-	prop->tag = cpu_to_fdt32(FDT_PROP);
-	prop->nameoff = cpu_to_fdt32(nameoff);
-	prop->len = cpu_to_fdt32(len);
-	memcpy(prop->data, val, len);
-	return 0;
+    prop->tag = cpu_to_fdt32(FDT_PROP);
+    prop->nameoff = cpu_to_fdt32(nameoff);
+    prop->len = cpu_to_fdt32(len);
+    memcpy(prop->data, val, len);
+    return 0;
 }
 
 int fdt_finish(void *fdt)
 {
-	char *p = (char *)fdt;
-	fdt32_t *end;
-	int oldstroffset, newstroffset;
-	uint32_t tag;
-	int offset, nextoffset;
+    char *p = (char *)fdt;
+    fdt32_t *end;
+    int oldstroffset, newstroffset;
+    uint32_t tag;
+    int offset, nextoffset;
 
-	FDT_SW_CHECK_HEADER(fdt);
+    FDT_SW_CHECK_HEADER(fdt);
 
-	/* Add terminator */
-	end = _fdt_grab_space(fdt, sizeof(*end));
-	if (! end)
-		return -FDT_ERR_NOSPACE;
-	*end = cpu_to_fdt32(FDT_END);
+    /* Add terminator */
+    end = _fdt_grab_space(fdt, sizeof(*end));
+    if (! end)
+        return -FDT_ERR_NOSPACE;
+    *end = cpu_to_fdt32(FDT_END);
 
-	/* Relocate the string table */
-	oldstroffset = fdt_totalsize(fdt) - fdt_size_dt_strings(fdt);
-	newstroffset = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
-	memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));
-	fdt_set_off_dt_strings(fdt, newstroffset);
+    /* Relocate the string table */
+    oldstroffset = fdt_totalsize(fdt) - fdt_size_dt_strings(fdt);
+    newstroffset = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
+    memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));
+    fdt_set_off_dt_strings(fdt, newstroffset);
 
-	/* Walk the structure, correcting string offsets */
-	offset = 0;
-	while ((tag = fdt_next_tag(fdt, offset, &nextoffset)) != FDT_END) {
-		if (tag == FDT_PROP) {
-			struct fdt_property *prop =
-				_fdt_offset_ptr_w(fdt, offset);
-			int nameoff;
+    /* Walk the structure, correcting string offsets */
+    offset = 0;
+    while ((tag = fdt_next_tag(fdt, offset, &nextoffset)) != FDT_END) {
+        if (tag == FDT_PROP) {
+            struct fdt_property *prop =
+                _fdt_offset_ptr_w(fdt, offset);
+            int nameoff;
 
-			nameoff = fdt32_to_cpu(prop->nameoff);
-			nameoff += fdt_size_dt_strings(fdt);
-			prop->nameoff = cpu_to_fdt32(nameoff);
-		}
-		offset = nextoffset;
-	}
-	if (nextoffset < 0)
-		return nextoffset;
+            nameoff = fdt32_to_cpu(prop->nameoff);
+            nameoff += fdt_size_dt_strings(fdt);
+            prop->nameoff = cpu_to_fdt32(nameoff);
+        }
+        offset = nextoffset;
+    }
+    if (nextoffset < 0)
+        return nextoffset;
 
-	/* Finally, adjust the header */
-	fdt_set_totalsize(fdt, newstroffset + fdt_size_dt_strings(fdt));
-	fdt_set_magic(fdt, FDT_MAGIC);
-	return 0;
+    /* Finally, adjust the header */
+    fdt_set_totalsize(fdt, newstroffset + fdt_size_dt_strings(fdt));
+    fdt_set_magic(fdt, FDT_MAGIC);
+    return 0;
 }

components/drivers/fdt/libfdt/fdt_wip.c

@@ -54,84 +54,84 @@
 #include "libfdt_internal.h"
 
 int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset,
-					const char *name, int namelen,
-					uint32_t idx, const void *val,
-					int len)
+                    const char *name, int namelen,
+                    uint32_t idx, const void *val,
+                    int len)
 {
-	void *propval;
-	int proplen;
+    void *propval;
+    int proplen;
 
-	propval = fdt_getprop_namelen_w(fdt, nodeoffset, name, namelen,
-					&proplen);
-	if (!propval)
-		return proplen;
+    propval = fdt_getprop_namelen_w(fdt, nodeoffset, name, namelen,
+                    &proplen);
+    if (!propval)
+        return proplen;
 
-	if (proplen < (len + idx))
-		return -FDT_ERR_NOSPACE;
+    if (proplen < (len + idx))
+        return -FDT_ERR_NOSPACE;
 
-	memcpy((char *)propval + idx, val, len);
-	return 0;
+    memcpy((char *)propval + idx, val, len);
+    return 0;
 }
 
 int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
-			const void *val, int len)
+            const void *val, int len)
 {
-	const void *propval;
-	int proplen;
+    const void *propval;
+    int proplen;
 
-	propval = fdt_getprop(fdt, nodeoffset, name, &proplen);
-	if (! propval)
-		return proplen;
+    propval = fdt_getprop(fdt, nodeoffset, name, &proplen);
+    if (! propval)
+        return proplen;
 
-	if (proplen != len)
-		return -FDT_ERR_NOSPACE;
+    if (proplen != len)
+        return -FDT_ERR_NOSPACE;
 
-	return fdt_setprop_inplace_namelen_partial(fdt, nodeoffset, name,
-						   strlen(name), 0,
-						   val, len);
+    return fdt_setprop_inplace_namelen_partial(fdt, nodeoffset, name,
+                           strlen(name), 0,
+                           val, len);
 }
 
 static void _fdt_nop_region(void *start, int len)
 {
-	fdt32_t *p;
+    fdt32_t *p;
 
-	for (p = start; (char *)p < ((char *)start + len); p++)
-		*p = cpu_to_fdt32(FDT_NOP);
+    for (p = start; (char *)p < ((char *)start + len); p++)
+        *p = cpu_to_fdt32(FDT_NOP);
 }
 
 int fdt_nop_property(void *fdt, int nodeoffset, const char *name)
 {
-	struct fdt_property *prop;
-	int len;
+    struct fdt_property *prop;
+    int len;
 
-	prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
-	if (! prop)
-		return len;
+    prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
+    if (! prop)
+        return len;
 
-	_fdt_nop_region(prop, len + sizeof(*prop));
+    _fdt_nop_region(prop, len + sizeof(*prop));
 
-	return 0;
+    return 0;
 }
 
 int _fdt_node_end_offset(void *fdt, int offset)
 {
-	int depth = 0;
+    int depth = 0;
 
-	while ((offset >= 0) && (depth >= 0))
-		offset = fdt_next_node(fdt, offset, &depth);
+    while ((offset >= 0) && (depth >= 0))
+        offset = fdt_next_node(fdt, offset, &depth);
 
-	return offset;
+    return offset;
 }
 
 int fdt_nop_node(void *fdt, int nodeoffset)
 {
-	int endoffset;
+    int endoffset;
 
-	endoffset = _fdt_node_end_offset(fdt, nodeoffset);
-	if (endoffset < 0)
-		return endoffset;
+    endoffset = _fdt_node_end_offset(fdt, nodeoffset);
+    if (endoffset < 0)
+        return endoffset;
 
-	_fdt_nop_region(fdt_offset_ptr_w(fdt, nodeoffset, 0),
-			endoffset - nodeoffset);
-	return 0;
+    _fdt_nop_region(fdt_offset_ptr_w(fdt, nodeoffset, 0),
+            endoffset - nodeoffset);
+    return 0;
 }

components/drivers/fdt/libfdt/libfdt_env.h

@@ -70,40 +70,40 @@ typedef uint32_t FDT_BITWISE fdt32_t;
 typedef uint64_t FDT_BITWISE fdt64_t;
 typedef uint64_t unaligned_fdt64_t __attribute__((aligned(4)));
 
-#define EXTRACT_BYTE(x, n)	((unsigned long long)((uint8_t *)&x)[n])
+#define EXTRACT_BYTE(x, n)  ((unsigned long long)((uint8_t *)&x)[n])
 #define CPU_TO_FDT16(x) ((EXTRACT_BYTE(x, 0) << 8) | EXTRACT_BYTE(x, 1))
 #define CPU_TO_FDT32(x) ((EXTRACT_BYTE(x, 0) << 24) | (EXTRACT_BYTE(x, 1) << 16) | \
-			 (EXTRACT_BYTE(x, 2) << 8) | EXTRACT_BYTE(x, 3))
+             (EXTRACT_BYTE(x, 2) << 8) | EXTRACT_BYTE(x, 3))
 #define CPU_TO_FDT64(x) ((EXTRACT_BYTE(x, 0) << 56) | (EXTRACT_BYTE(x, 1) << 48) | \
-			 (EXTRACT_BYTE(x, 2) << 40) | (EXTRACT_BYTE(x, 3) << 32) | \
-			 (EXTRACT_BYTE(x, 4) << 24) | (EXTRACT_BYTE(x, 5) << 16) | \
-			 (EXTRACT_BYTE(x, 6) << 8) | EXTRACT_BYTE(x, 7))
+             (EXTRACT_BYTE(x, 2) << 40) | (EXTRACT_BYTE(x, 3) << 32) | \
+             (EXTRACT_BYTE(x, 4) << 24) | (EXTRACT_BYTE(x, 5) << 16) | \
+             (EXTRACT_BYTE(x, 6) << 8) | EXTRACT_BYTE(x, 7))
 
 static inline uint16_t fdt16_to_cpu(fdt16_t x)
 {
-	return (FDT_FORCE uint16_t)CPU_TO_FDT16(x);
+    return (FDT_FORCE uint16_t)CPU_TO_FDT16(x);
 }
 static inline fdt16_t cpu_to_fdt16(uint16_t x)
 {
-	return (FDT_FORCE fdt16_t)CPU_TO_FDT16(x);
+    return (FDT_FORCE fdt16_t)CPU_TO_FDT16(x);
 }
 
 static inline uint32_t fdt32_to_cpu(fdt32_t x)
 {
-	return (FDT_FORCE uint32_t)CPU_TO_FDT32(x);
+    return (FDT_FORCE uint32_t)CPU_TO_FDT32(x);
 }
 static inline fdt32_t cpu_to_fdt32(uint32_t x)
 {
-	return (FDT_FORCE fdt32_t)CPU_TO_FDT32(x);
+    return (FDT_FORCE fdt32_t)CPU_TO_FDT32(x);
 }
 
 static inline uint64_t fdt64_to_cpu(fdt64_t x)
 {
-	return (FDT_FORCE uint64_t)CPU_TO_FDT64(x);
+    return (FDT_FORCE uint64_t)CPU_TO_FDT64(x);
 }
 static inline fdt64_t cpu_to_fdt64(uint64_t x)
 {
-	return (FDT_FORCE fdt64_t)CPU_TO_FDT64(x);
+    return (FDT_FORCE fdt64_t)CPU_TO_FDT64(x);
 }
 #undef CPU_TO_FDT64
 #undef CPU_TO_FDT32

components/drivers/fdt/libfdt/libfdt_internal.h

@@ -52,15 +52,15 @@
  */
 #include "fdt.h"
 
-#define FDT_ALIGN(x, a)		(((x) + (a) - 1) & ~((a) - 1))
-#define FDT_TAGALIGN(x)		(FDT_ALIGN((x), FDT_TAGSIZE))
+#define FDT_ALIGN(x, a)     (((x) + (a) - 1) & ~((a) - 1))
+#define FDT_TAGALIGN(x)     (FDT_ALIGN((x), FDT_TAGSIZE))
 
 #define FDT_CHECK_HEADER(fdt) \
-	{ \
-		int __err; \
-		if ((__err = fdt_check_header(fdt)) != 0) \
-			return __err; \
-	}
+    { \
+        int __err; \
+        if ((__err = fdt_check_header(fdt)) != 0) \
+            return __err; \
+    }
 
 int _fdt_check_node_offset(const void *fdt, int offset);
 int _fdt_check_prop_offset(const void *fdt, int offset);
@@ -69,27 +69,27 @@ int _fdt_node_end_offset(void *fdt, int nodeoffset);
 
 static inline const void *_fdt_offset_ptr(const void *fdt, int offset)
 {
-	return (const char *)fdt + fdt_off_dt_struct(fdt) + offset;
+    return (const char *)fdt + fdt_off_dt_struct(fdt) + offset;
 }
 
 static inline void *_fdt_offset_ptr_w(void *fdt, int offset)
 {
-	return (void *)(uintptr_t)_fdt_offset_ptr(fdt, offset);
+    return (void *)(uintptr_t)_fdt_offset_ptr(fdt, offset);
 }
 
 static inline const struct fdt_reserve_entry *_fdt_mem_rsv(const void *fdt, int n)
 {
-	const struct fdt_reserve_entry *rsv_table =
-		(const struct fdt_reserve_entry *)
-		((const char *)fdt + fdt_off_mem_rsvmap(fdt));
+    const struct fdt_reserve_entry *rsv_table =
+        (const struct fdt_reserve_entry *)
+        ((const char *)fdt + fdt_off_mem_rsvmap(fdt));
 
-	return rsv_table + n;
+    return rsv_table + n;
 }
 static inline struct fdt_reserve_entry *_fdt_mem_rsv_w(void *fdt, int n)
 {
-	return (void *)(uintptr_t)_fdt_mem_rsv(fdt, n);
+    return (void *)(uintptr_t)_fdt_mem_rsv(fdt, n);
 }
 
-#define FDT_SW_MAGIC		(~FDT_MAGIC)
+#define FDT_SW_MAGIC        (~FDT_MAGIC)
 
 #endif /* _LIBFDT_INTERNAL_H */

components/drivers/fdt/src/dtb_base.c

@@ -213,16 +213,16 @@ int dtb_node_get_addr_and_size_by_index(const struct dtb_node *node, int index,
     int onesize, na, ns;
 
     na = dtb_node_n_addr_cells(node);
-	ns = dtb_node_n_size_cells(node);
+    ns = dtb_node_n_size_cells(node);
 
     prop = dtb_node_get_dtb_node_property_value(node, "reg", &psize);
-	if (prop == NULL)
+    if (prop == NULL)
     {
-		return -1;
+        return -1;
     }
 
-	psize /= 4;
-	onesize = na + ns;
+    psize /= 4;
+    onesize = na + ns;
 
     if (psize >= (index + 1) * onesize)
     {

components/drivers/fdt/src/dtb_get.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  */

components/drivers/fdt/src/dtb_head.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -38,4 +38,4 @@ int device_tree_setup(void *mem_addr)
     }
 
     return -1;
-}
+}

components/drivers/fdt/src/dtb_load.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  */

components/drivers/fdt/src/dtb_set.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  */

components/drivers/hwcrypto/hw_bignum.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hw_bignum.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hw_crc.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hw_crc.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hw_gcm.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hw_gcm.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hw_hash.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hw_hash.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hw_rng.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hw_rng.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hw_symmetric.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hw_symmetric.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hwcrypto.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwcrypto/hwcrypto.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/hwtimer/hwtimer.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/i2c/i2c-bit-ops.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/i2c/i2c_core.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/i2c/i2c_dev.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/include/drivers/adc.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/include/drivers/alarm.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/include/drivers/audio.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/include/drivers/can.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2022, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/include/drivers/cputime.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/include/drivers/crypto.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/include/drivers/dac.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/include/drivers/gpt.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/include/drivers/hwtimer.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/include/drivers/i2c-bit-ops.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/drivers/include/drivers/i2c.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2023, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *