Mirrors_Framework/rt-thread
1
0
Fork 0
mirror of https://github.com/RT-Thread/rt-thread.git synced 2026-09-21 18:57:16 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into dev

Browse Source
This commit is contained in:
Bernard Xiong
2018-09-21 17:09:46 +08:00
committed by GitHub
parent f7423741f2 b611f317fe
commit b5202d17fb
336 changed files with 404337 additions and 1010 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/dfs/filesystems/ramfs/dfs_ramfs.c
+1
View File
@@ -453,6 +453,7 @@ struct dfs_ramfs* dfs_ramfs_create(rt_uint8_t *pool, rt_size_t size)
/* initialize ramfs object */
ramfs->magic = RAMFS_MAGIC;
ramfs->memheap.parent.type = RT_Object_Class_MemHeap | RT_Object_Class_Static;
/* initialize root directory */
memset(&(ramfs->root), 0x00, sizeof(ramfs->root));
components/drivers/Kconfig
+14 -1
View File
@@ -90,6 +90,20 @@ config RT_USING_MTD_NAND
default n
endif
config RT_USING_MTD
bool "Using Memory Technology Device (MTD)"
default n
if RT_USING_MTD
config MTD_USING_NOR
bool "Using MTD Nor Flash device"
default n
config MTD_USING_NAND
bool "Using MTD Nand Flash device"
default n
endif
config RT_USING_RTC
bool "Using RTC device drivers"
default n
@@ -138,7 +152,6 @@ config RT_USING_SDIO
config RT_MMCSD_MAX_PARTITION
int "mmcsd max partition"
default 16
config RT_SDIO_DEBUG
bool "Enable SDIO debug log output"
default n
components/drivers/hwtimer/hwtimer.c
+1 -1
View File
@@ -30,7 +30,7 @@ rt_inline rt_uint32_t timeout_calc(rt_hwtimer_t *timer, rt_hwtimerval_t *tv)
float overflow;
float timeout;
rt_uint32_t counter;
int i, index;
int i, index = 0;
float tv_sec;
float devi_min = 1;
float devi;
components/drivers/include/drivers/mtd.h
+109
View File
@@ -0,0 +1,109 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*/
/*
* File : mtd.h
*
* Change Logs:
* Date Author Notes
2018-09-10 heyuanjie87 first version
*/
#ifndef __MTD_H__
#define __MTD_H__
#include <rtthread.h>
#include <stddef.h>
#include <stdint.h>
#define MTD_TYPE_NOR 1
#define MTD_TYPE_NAND 2
/**
* MTD operation modes
*
* @MTD_OPM_PLACE_OOB: OOB data are placed at the given offset (default)
* @MTD_OPM_AUTO_OOB: OOB data are automatically placed at the free areas
* @MTD_OPM_RAW: data are transferred as-is, with no error correction;
*/
enum mtd_opm
{
MTD_OPM_PLACE_OOB = 0,
MTD_OPM_AUTO_OOB = 1,
MTD_OPM_RAW = 2,
};
#ifndef loff_t
typedef long loff_t;
#endif
struct mtd_oob_region
{
uint8_t offset;
uint8_t length;
};
typedef struct mtd_info
{
struct rt_device parent;
const struct mtd_ops *ops;
uint16_t oob_size;
uint16_t sector_size; /* Minimal writable flash unit size */
uint32_t block_size:28; /* Erase size for the device */
uint32_t type:4;
size_t size; /* Total size of the MTD */
loff_t offset; /* At which this MTD starts, from the beginning of the MEMORY */
struct mtd_info *master;
void *priv;
}rt_mtd_t;
struct mtd_io_desc
{
uint8_t mode; /* operation mode(enum mtd_opm) */
uint8_t ooblen; /* number of oob bytes to write/read */
uint8_t oobretlen; /* number of oob bytes written/read */
uint8_t ooboffs; /* offset in the oob area */
uint8_t *oobbuf;
size_t datlen; /* number of data bytes to write/read */
size_t datretlen; /* number of data bytes written/read */
uint8_t *datbuf; /* if NULL only oob are read/written */
};
struct mtd_ops
{
int(*erase)(rt_mtd_t *mtd, loff_t addr, size_t len); /* return 0 if success */
int(*read) (rt_mtd_t *mtd, loff_t from, struct mtd_io_desc *ops); /* return 0 if success */
int(*write) (rt_mtd_t *mtd, loff_t to, struct mtd_io_desc *ops); /* return 0 if success */
int(*isbad) (rt_mtd_t *mtd, uint32_t block); /* return 1 if bad, 0 not bad */
int(*markbad) (rt_mtd_t *mtd, uint32_t block); /* return 0 if success */
};
struct mtd_part
{
const char *name; /* name of the MTD partion */
loff_t offset; /* start addr of partion */
size_t size; /* size of partion */
};
int rt_mtd_erase(rt_mtd_t *mtd, loff_t addr, size_t size);
int rt_mtd_block_erase(rt_mtd_t *mtd, uint32_t block);
int rt_mtd_read_oob(rt_mtd_t *mtd, loff_t from, struct mtd_io_desc *desc);
int rt_mtd_write_oob(rt_mtd_t *mtd, loff_t to, struct mtd_io_desc *desc);
int rt_mtd_read(rt_mtd_t *mtd, loff_t from, uint8_t *buf, size_t len);
int rt_mtd_write(rt_mtd_t *mtd, loff_t to, const uint8_t *buf, size_t len);
int rt_mtd_block_markbad(rt_mtd_t *mtd, uint32_t block);
int rt_mtd_block_isbad(rt_mtd_t *mtd, uint32_t block);
rt_mtd_t* rt_mtd_get(const char *name);
int rt_mtd_register(rt_mtd_t *master, const struct mtd_part *parts, int np);
#endif
components/drivers/include/drivers/mtdnand.h
+105
View File
@@ -0,0 +1,105 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*/
/*
* File : mtdnand.h
*
* Change Logs:
* Date Author Notes
2018-09-10 heyuanjie87 first version
*/
#ifndef _MTDNAND_H_
#define _MTDNAND_H_
#include "mtd.h"
/* Status bits */
#define NAND_STATUS_FAIL 0x01
#define NAND_STATUS_FAIL_N1 0x02
#define NAND_STATUS_WP 0x80
typedef enum
{
NAND_CMD_PAGE_RD, /* read data to chip's page buffer,do WaitBusy after this cmd in low driver */
NAND_CMD_PAGE_WR0, /* write data to chip's page buffer */
NAND_CMD_PAGE_WR1, /* do flash programe */
NAND_CMD_BLK_ERASE, /* erase block */
NAND_CMD_ECC_EN, /* enable gen HWECC */
NAND_CMD_ECC_DIS /* disable gen HWECC */
} nand_cmd_t;
typedef enum
{
NAND_ECCM_NONE,
NAND_ECCM_HW,
} nand_eccmode_t;
struct nand_chip;
struct nand_ops;
/**
* struct nand_buffers - buffer structure for read/write
* @ecccalc: buffer pointer for calculated ECC, size is oobsize.
* @ecccode: buffer pointer for ECC read from flash, size is oobsize.
*
*/
struct nand_buffers
{
uint8_t *ecccalc;
uint8_t *ecccode;
};
struct nand_ecc
{
uint8_t mode; /* nand_eccmode_t */
uint8_t bytes; /* gen ecc bytes per ecc step(usually 3) */
uint16_t stepsize:12; /* min 256 */
uint16_t _step:4; /* */
/* driver must set the two interface if HWECC */
void (*calculate)(struct nand_chip *chip, const uint8_t *dat, uint8_t *ecc_code);
/* return max bit flips if can't correct,return -1 ECC is error(0 success) */
int(*correct)(struct nand_chip *chip, uint8_t *dat, uint8_t *read_ecc, uint8_t *calc_ecc);
/* ignore if NONECC */
const struct mtd_oob_region *layout;
};
typedef struct nand_chip
{
rt_mtd_t parent;
/* driver must init these */
const struct nand_ops *ops;
struct nand_ecc ecc;
const struct mtd_oob_region *freelayout;
/* driver do not touch */
struct nand_buffers buffers;
uint8_t *oob_poi;
uint8_t *pagebuf;
uint32_t size;
uint16_t oobsize;
uint8_t pages_pb;
uint16_t page_size;
int(*read_page)(struct nand_chip *chip, uint8_t *buf, int oob_required, int page);
int(*write_page)(struct nand_chip *chip, const uint8_t *buf, int oob_required, int page);
}rt_nand_t;
struct nand_ops
{
int(*cmdfunc)(rt_nand_t *nand, int cmd, int page, int offset); /* send nand operation cmd, return Status bits(0 success),
if nand is busy please wait in low driver */
int(*read_buf)(rt_nand_t *nand, uint8_t *buf, int len); /* read data from nand chip's page buffer */
int(*write_buf)(rt_nand_t *nand, const uint8_t *buf, int len);/* write data to nand chip's page buffer */
int(*isbad)(rt_nand_t *nand, uint32_t blk); /* if NULL OOB[0] used as bad mark(not 0xff is bad) */
int(*markbad)(rt_nand_t *nand, uint32_t blk); /* if NULL OOB[0] used as bad mark(set to 0x00) */
};
int rt_mtd_nand_init(rt_nand_t *nand, int blk_size, int page_size, int oob_size);
#endif /* MTD_NAND_H_ */
components/drivers/include/drivers/mtdnor.h
+39
View File
@@ -0,0 +1,39 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*/
/*
* File : mtdnor.h
*
* Change Logs:
* Date Author Notes
2018-09-10 heyuanjie87 first version
*/
#ifndef __MTDNOR_H__
#define __MTDNOR_H__
#include <drivers/mtd.h>
struct nor_ops;
typedef struct
{
rt_mtd_t parent;
const struct nor_ops *ops; /* operations interface */
}rt_nor_t;
struct nor_ops
{
int (*erase)(rt_nor_t *nor, loff_t addr, size_t len); /* return success erased len or error code */
int (*read)(rt_nor_t *nor, loff_t addr, uint8_t *buf, size_t len); /* return success data size or error code */
int (*write)(rt_nor_t *nor, loff_t addr, const uint8_t *buf, size_t len); /* return success data size or error code */
};
int rt_mtd_nor_init(rt_nor_t *nor, int blksize);
#endif
components/drivers/include/rtdevice.h
+9 -16
View File
@@ -1,21 +1,7 @@
/*
* File : rtdevice.h
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
@@ -121,6 +107,13 @@ extern "C" {
#include "drivers/wlan.h"
#endif
#ifdef MTD_USING_NOR
#include "drivers/mtdnor.h"
#endif
#ifdef MTD_USING_NAND
#include "drivers/mtdnand.h"
#endif
#ifdef __cplusplus
}
#endif
components/drivers/mtd/SConscript
+11
View File
@@ -9,6 +9,17 @@ depend = []
CPPPATH = [cwd + '/../include']
group = []
if GetDepend(['RT_USING_MTD']):
src += ['mtd.c']
depend += ['RT_USING_MTD']
if GetDepend(['MTD_USING_NOR']):
src += ['mtdnor.c']
depend += ['MTD_USING_NOR']
if GetDepend(['MTD_USING_NAND']):
src += ['mtdnand.c']
depend += ['MTD_USING_NAND']
if GetDepend(['RT_USING_MTD_NOR']):
src += ['mtd_nor.c']
depend += ['RT_USING_MTD_NOR']
components/drivers/mtd/mtd.c
+240
View File
@@ -0,0 +1,240 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*/
/*
* File : mtd.c
*
* Change Logs:
* Date Author Notes
2018-09-10 heyuanjie87 first version
*/
#include <drivers/mtd.h>
static rt_mtd_t* mtd_part_alloc(rt_mtd_t *master, const struct mtd_part *part)
{
rt_mtd_t *slave;
slave = rt_malloc(sizeof(rt_mtd_t));
if (slave == RT_NULL)
goto out;
slave->master = master;
*slave = *master;
slave->size = part->size;
slave->offset = part->offset;
out:
return slave;
}
rt_mtd_t* rt_mtd_get(const char *name)
{
rt_mtd_t *mtd;
mtd = (rt_mtd_t *)rt_device_find(name);
if (mtd == RT_NULL)
return RT_NULL;
if (mtd->parent.type != RT_Device_Class_MTD)
return RT_NULL;
return mtd;
}
/*
* Register MTD driver
*
* @parts partion description
* @np number of partitions
* @return number of unregistered partitions
*
*/
int rt_mtd_register(rt_mtd_t *master, const struct mtd_part *parts, int np)
{
int ret;
rt_mtd_t *slave;
master->master = master;
master->parent.type = RT_Device_Class_MTD;
if (np > 0)
{
master->offset = parts->offset;
master->size = parts->size;
ret = rt_device_register((rt_device_t)master, parts->name, 0);
if (ret != 0)
goto _out;
np --;
parts ++;
}
while (np > 0)
{
slave = mtd_part_alloc(master, parts);
if (!slave)
break;
ret = rt_device_register((rt_device_t)slave, parts->name, 0);
if (ret)
break;
parts ++;
np --;
}
_out:
return np;
}
int rt_mtd_block_erase(rt_mtd_t *mtd, uint32_t block)
{
uint32_t total_blks;
loff_t addr;
total_blks = mtd->size/mtd->block_size;
if (block >= total_blks)
return -EINVAL;
addr = mtd->offset + mtd->block_size * block;
return mtd->ops->erase(mtd->master, addr, mtd->block_size);
}
int rt_mtd_block_isbad(rt_mtd_t *mtd, uint32_t block)
{
uint32_t total_blks, offset_blk;
if (!mtd->ops->isbad)
return 0;
total_blks = mtd->size / mtd->block_size;
if (block >= total_blks)
return -EINVAL;
offset_blk = mtd->offset / mtd->block_size;
return mtd->ops->isbad(mtd->master, block + offset_blk);
}
int rt_mtd_block_markbad(rt_mtd_t *mtd, uint32_t block)
{
uint32_t total_blks, offset_blk;
if (!mtd->ops->markbad)
return -EOPNOTSUPP;
total_blks = mtd->size / mtd->block_size;
if (block >= total_blks)
return -EINVAL;
offset_blk = mtd->offset / mtd->block_size;
return mtd->ops->markbad(mtd->master, block + offset_blk);
}
int rt_mtd_erase(rt_mtd_t *mtd, loff_t addr, size_t size)
{
if (addr > mtd->size || (addr + size) > mtd->size)
return -EINVAL;
addr += mtd->offset;
return mtd->ops->erase(mtd->master, addr, size);
}
/*
* Read data only
*
* @from offset to read from
* @return success size or error code
*/
int rt_mtd_read(rt_mtd_t *mtd, loff_t from, uint8_t *buf, size_t len)
{
int ret;
struct mtd_io_desc desc = {0};
if (from < 0 || from >= (loff_t)mtd->size || len > mtd->size - from)
return -EINVAL;
if (!len)
return 0;
desc.datbuf = buf;
desc.datlen = len;
ret = mtd->ops->read(mtd->master, from + mtd->offset, &desc);
if (ret)
return ret;
return desc.datretlen;
}
/**
* Write data only
*
* @to offset to write from
* @return success size or error code
*/
int rt_mtd_write(rt_mtd_t *mtd, loff_t to, const uint8_t *buf, size_t len)
{
int ret;
struct mtd_io_desc desc = {0};
if (to < 0 || to >= (loff_t)mtd->size || len > mtd->size - to)
return -EINVAL;
if (!mtd->ops->write)
return -EROFS;
if (!len)
return 0;
desc.datbuf = (uint8_t*)buf;
desc.datlen = len;
ret = mtd->ops->write(mtd->master, to + mtd->offset, &desc);
if (ret)
return ret;
return desc.datretlen;
}
/**
* Read data and/or out-of-band
*
* @from offset to read from
* @desc sector operation description structure
* @return error code, 0 success
*/
int rt_mtd_read_oob(rt_mtd_t *mtd, loff_t from, struct mtd_io_desc *desc)
{
desc->datretlen = 0;
desc->oobretlen = 0;
if (from < 0 || from >= (loff_t)mtd->size)
return -EINVAL;
if (desc->datbuf && (desc->datlen > (mtd->size - from)))
return -EINVAL;
return mtd->ops->read(mtd->master, from + mtd->offset, desc);
}
/**
* Write data and/or out-of-band
*
* @to offset to read from
* @desc sector operation description structure
* @return error code, 0 success
*/
int rt_mtd_write_oob(rt_mtd_t *mtd, loff_t to, struct mtd_io_desc *desc)
{
desc->datretlen = 0;
desc->oobretlen = 0;
if (to < 0 || to >= (loff_t)mtd->size)
return -EINVAL;
if (desc->datbuf && (desc->datlen >(mtd->size - to)))
return -EINVAL;
return mtd->ops->write(mtd->master, to + mtd->offset, desc);
}
components/drivers/mtd/mtdnand.c
+650
View File
File diff suppressed because it is too large Load Diff
components/drivers/mtd/mtdnor.c
+78
View File
@@ -0,0 +1,78 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*/
/*
* File : mtdnor.c
*
* Change Logs:
* Date Author Notes
2018-09-10 heyuanjie87 first version
*/
#include <drivers/mtdnor.h>
#ifdef MTD_USING_NOR
static int _nor_erase(rt_mtd_t *mtd, loff_t addr, size_t len)
{
rt_nor_t *nor;
nor = (rt_nor_t *)mtd;
return nor->ops->erase(nor, addr, len);
}
static int _nor_read(rt_mtd_t *mtd, loff_t from, struct mtd_io_desc *desc)
{
rt_nor_t *nor;
int ret;
nor = (rt_nor_t *)mtd;
ret = nor->ops->read(nor, from, desc->datbuf, desc->datlen);
if (ret > 0)
{
desc->datretlen = ret;
ret = 0;
}
return ret;
}
static int _nor_write(rt_mtd_t *mtd, loff_t to, struct mtd_io_desc *desc)
{
rt_nor_t *nor;
int ret;
nor = (rt_nor_t *)mtd;
ret = nor->ops->write(nor, to, desc->datbuf, desc->datlen);
if (ret > 0)
{
desc->datretlen = ret;
ret = 0;
}
return ret;
}
static const struct mtd_ops _ops =
{
_nor_erase,
_nor_read,
_nor_write,
0,
0
};
int rt_mtd_nor_init(rt_nor_t *nor, int blksize)
{
nor->parent.sector_size = 1;
nor->parent.block_size = blksize;
nor->parent.ops = &_ops;
nor->parent.type = MTD_TYPE_NOR;
nor->parent.oob_size = 0;
return 0;
}
#endif
components/drivers/spi/spi_core.c
-1
View File
@@ -360,7 +360,6 @@ struct rt_spi_message *rt_spi_transfer_message(struct rt_spi_device *device,
{
/* configure SPI bus failed */
rt_set_errno(-RT_EIO);
result = 0;
goto __exit;
}
}
components/libc/compilers/armlibc/stdio.c
+18 -2
View File
@@ -65,11 +65,27 @@ int libc_stdio_get_console(void)
int libc_stdio_read(void *buffer, size_t size)
{
return read(std_fd, buffer, size);
if (std_fd >= 0)
{
return read(std_fd, buffer, size);
}
else
{
rt_kprintf("Illegal stdio input!\n");
return 0;
}
}
int libc_stdio_write(const void *buffer, size_t size)
{
return write(std_fd, buffer, size);
if (std_fd >= 0)
{
return write(std_fd, buffer, size);
}
else
{
rt_kprintf("Illegal stdio output!\n");
return size;
}
}
#endif
components/libc/libdl/arch/x86.c
+50
View File
@@ -0,0 +1,50 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2018/09/15 parai first version
*/
#include "../dlmodule.h"
#include "../dlelf.h"
#ifdef __x86__
#define R_X86_64_GLOB_DAT 6 /* Create GOT entry */
#define R_X86_64_JUMP_SLOT 7 /* Create PLT entry */
#define R_X86_64_RELATIVE 8 /* Adjust by program base */
int dlmodule_relocate(struct rt_dlmodule *module, Elf32_Rel *rel, Elf32_Addr sym_val)
{
Elf32_Addr *where, tmp;
Elf32_Sword addend, offset;
rt_uint32_t upper, lower, sign, j1, j2;
where = (Elf32_Addr *)((rt_uint8_t *)module->mem_space
+ rel->r_offset
- module->vstart_addr);
switch (ELF32_R_TYPE(rel->r_info))
{
case R_X86_64_GLOB_DAT:
case R_X86_64_JUMP_SLOT:
*where = (Elf32_Addr)sym_val;
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_X86_64_JUMP_SLOT: 0x%x -> 0x%x 0x%x\n",
(uint32_t)where, *where, sym_val));
break;
case R_X86_64_RELATIVE:
*where = (Elf32_Addr)sym_val + *where;
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_X86_64_RELATIVE: 0x%x -> 0x%x 0x%x\n",
(uint32_t)where, *where, sym_val));
break;
default:
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("X86ELF: invalid relocate TYPE %d\n", ELF32_R_TYPE(rel->r_info)));
return -1;
}
return 0;
}
#endif
components/net/at/at_socket/at_socket.c
+32 -2
View File
@@ -200,7 +200,7 @@ static void at_do_event_changes(struct at_socket *sock, at_event_t event, rt_boo
{
if (is_plus)
{
sock->sendevent++;
sock->sendevent = 1;
#ifdef SAL_USING_POSIX
rt_wqueue_wakeup(&sock->wait_head, (void*) POLLOUT);
@@ -209,7 +209,7 @@ static void at_do_event_changes(struct at_socket *sock, at_event_t event, rt_boo
}
else if (sock->sendevent)
{
sock->sendevent --;
sock->sendevent = 0;
}
break;
}
@@ -252,6 +252,30 @@ static void at_do_event_changes(struct at_socket *sock, at_event_t event, rt_boo
}
}
static void at_do_event_clean(struct at_socket *sock, at_event_t event)
{
switch (event)
{
case AT_EVENT_SEND:
{
sock->sendevent = 0;
break;
}
case AT_EVENT_RECV:
{
sock->rcvevent = 0;
break;
}
case AT_EVENT_ERROR:
{
sock->errevent = 0;
break;
}
default:
LOG_E("Not supported event (%d)", event);
}
}
static struct at_socket *alloc_socket(void)
{
static rt_mutex_t at_slock = RT_NULL;
@@ -565,6 +589,8 @@ __exit:
at_do_event_changes(sock, AT_EVENT_ERROR, RT_TRUE);
}
at_do_event_changes(sock, AT_EVENT_SEND, RT_TRUE);
return result;
}
@@ -688,6 +714,10 @@ __exit:
{
at_do_event_changes(sock, AT_EVENT_RECV, RT_TRUE);
}
else
{
at_do_event_clean(sock, AT_EVENT_RECV);
}
}
else
{
components/net/at/src/at_client.c
+1 -1
View File
@@ -870,7 +870,7 @@ int at_client_init(const char *dev_name, rt_size_t recv_bufsz)
if (idx >= AT_CLIENT_NUM_MAX)
{
LOG_E("AT client initialize filed! Check the maximum number(%d) of AT client.", AT_CLIENT_NUM_MAX);
LOG_E("AT client initialize failed! Check the maximum number(%d) of AT client.", AT_CLIENT_NUM_MAX);
result = -RT_EFULL;
goto __exit;
}