Skip to content

R
rt-thread

luozhenger / rt-thread
与 Fork 源项目一致

Fork自 RT-Thread / rt-thread

通知 1
Star 0
Fork 0
R
rt-thread

体验新版 GitCode，发现更多精彩内容 >>

提交 68b7e7c4 编写于 作者: D dzzxzz@gmail.com
浏览文件
操作

fixed the coding style in the components/drivers 

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2431 bbd45198-f89e-11dd-88c7-29a3b14d5316
上级 87195193
展开全部 隐藏空白更改
内联 并排
Showing with 2033 addition and 1981 deletion
components/drivers/i2c/i2c_core.c
浏览文件 @ 68b7e7c4
/* /*
* File : i2c_core.c * File : i2c_core.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Development Team * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2012-04-25 weety first version * 2012-04-25 weety first version
*/ */
#include <rtdevice.h> #include <rtdevice.h>
static struct rt_mutex i2c_core_lock; static struct rt_mutex i2c_core_lock;
rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus, rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus,
const char *bus_name) const char *bus_name)
{ {
rt_err_t res = RT_EOK; rt_err_t res = RT_EOK;
rt_mutex_init(&bus->lock, "i2c_bus_lock", RT_IPC_FLAG_FIFO); rt_mutex_init(&bus->lock, "i2c_bus_lock", RT_IPC_FLAG_FIFO);
rt_mutex_take(&i2c_core_lock, RT_WAITING_FOREVER); rt_mutex_take(&i2c_core_lock, RT_WAITING_FOREVER);
if (bus->timeout == 0) if (bus->timeout == 0)
bus->timeout = RT_TICK_PER_SECOND; bus->timeout = RT_TICK_PER_SECOND;
res = rt_i2c_bus_device_device_init(bus, bus_name); res = rt_i2c_bus_device_device_init(bus, bus_name);
i2c_dbg("I2C bus [%s] registered\n", bus_name); i2c_dbg("I2C bus [%s] registered\n", bus_name);
rt_mutex_release(&i2c_core_lock); rt_mutex_release(&i2c_core_lock);
return res;
} return res;
}
struct rt_i2c_bus_device* rt_i2c_bus_device_find(const char *bus_name) struct rt_i2c_bus_device *rt_i2c_bus_device_find(const char *bus_name)
{ {
struct rt_i2c_bus_device *bus; struct rt_i2c_bus_device *bus;
rt_device_t dev = rt_device_find(bus_name); rt_device_t dev = rt_device_find(bus_name);
if (dev == RT_NULL || dev->type != RT_Device_Class_I2CBUS) if (dev == RT_NULL || dev->type != RT_Device_Class_I2CBUS)
{ {
i2c_dbg("I2C bus %s not exist\n", bus_name); i2c_dbg("I2C bus %s not exist\n", bus_name);
return RT_NULL;
} return RT_NULL;
}
bus = (struct rt_i2c_bus_device *)dev->user_data;
bus = (struct rt_i2c_bus_device *)dev->user_data;
return bus;
} return bus;
}
rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus, rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus,
struct rt_i2c_msg msgs[], struct rt_i2c_msg msgs[],
rt_uint32_t num) rt_uint32_t num)
{ {
rt_size_t ret; rt_size_t ret;
if (bus->ops->master_xfer) if (bus->ops->master_xfer)
{ {
#ifdef RT_I2C_DEBUG #ifdef RT_I2C_DEBUG
for (ret = 0; ret < num; ret++) for (ret = 0; ret < num; ret++)
{ {
i2c_dbg("msgs[%d] %c, addr=0x%02x, len=%d%s\n", ret, i2c_dbg("msgs[%d] %c, addr=0x%02x, len=%d%s\n", ret,
(msgs[ret].flags & RT_I2C_RD) ? 'R' : 'W', (msgs[ret].flags & RT_I2C_RD) ? 'R' : 'W',
msgs[ret].addr, msgs[ret].len); msgs[ret].addr, msgs[ret].len);
} }
#endif #endif
rt_mutex_take(&bus->lock, RT_WAITING_FOREVER); rt_mutex_take(&bus->lock, RT_WAITING_FOREVER);
ret = bus->ops->master_xfer(bus, msgs, num); ret = bus->ops->master_xfer(bus, msgs, num);
rt_mutex_release(&bus->lock); rt_mutex_release(&bus->lock);
return ret; return ret;
} }
else else
{ {
i2c_dbg("I2C bus operation not supported\n"); i2c_dbg("I2C bus operation not supported\n");
return 0;
} return 0;
} }
}
rt_size_t rt_i2c_master_send(struct rt_i2c_bus_device *bus, rt_size_t rt_i2c_master_send(struct rt_i2c_bus_device *bus,
rt_uint16_t addr, rt_uint16_t addr,
rt_uint16_t flags, rt_uint16_t flags,
const rt_uint8_t *buf, const rt_uint8_t *buf,
rt_uint32_t count) rt_uint32_t count)
{ {
rt_size_t ret; rt_size_t ret;
struct rt_i2c_msg msg; struct rt_i2c_msg msg;
msg.addr = addr; msg.addr = addr;
msg.flags = flags & RT_I2C_ADDR_10BIT; msg.flags = flags & RT_I2C_ADDR_10BIT;
msg.len = count; msg.len = count;
msg.buf = (rt_uint8_t *)buf; msg.buf = (rt_uint8_t *)buf;
ret = rt_i2c_transfer(bus, &msg, 1); ret = rt_i2c_transfer(bus, &msg, 1);
return (ret > 0) ? count : ret; return (ret > 0) ? count : ret;
} }
rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus,
rt_uint16_t addr,
rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus, rt_uint16_t flags,
rt_uint16_t addr, rt_uint8_t *buf,
rt_uint16_t flags, rt_uint32_t count)
rt_uint8_t *buf, {
rt_uint32_t count) rt_size_t ret;
{ struct rt_i2c_msg msg;
rt_size_t ret; RT_ASSERT(bus != RT_NULL);
struct rt_i2c_msg msg;
RT_ASSERT(bus != RT_NULL); msg.addr = addr;
msg.flags = flags & RT_I2C_ADDR_10BIT;
msg.addr = addr; msg.flags |= RT_I2C_RD;
msg.flags = flags & RT_I2C_ADDR_10BIT; msg.len = count;
msg.flags |= RT_I2C_RD; msg.buf = buf;
msg.len = count;
msg.buf = buf; ret = rt_i2c_transfer(bus, &msg, 1);
ret = rt_i2c_transfer(bus, &msg, 1); return (ret > 0) ? count : ret;
}
return (ret > 0) ? count : ret;
} rt_err_t rt_i2c_core_init(void)
{
return rt_mutex_init(&i2c_core_lock, "i2c_core_lock", RT_IPC_FLAG_FIFO);
rt_err_t rt_i2c_core_init(void) }
{
return rt_mutex_init (&i2c_core_lock, "i2c_core_lock", RT_IPC_FLAG_FIFO);
}
components/drivers/i2c/i2c_dev.c
浏览文件 @ 68b7e7c4
#include <rtdevice.h> /*
* File : i2c_dev.c
static rt_err_t i2c_bus_device_init(rt_device_t dev) * This file is part of RT-Thread RTOS
{ * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data; *
RT_ASSERT(bus != RT_NULL); * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
return RT_EOK; * http://www.rt-thread.org/license/LICENSE
} *
* Change Logs:
static rt_size_t i2c_bus_device_read (rt_device_t dev, * Date Author Notes
rt_off_t pos, * 2012-04-25 weety first version
void *buffer, */
rt_size_t count)
{ #include <rtdevice.h>
rt_uint16_t addr;
rt_uint16_t flags; static rt_err_t i2c_bus_device_init(rt_device_t dev)
struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data; {
struct rt_i2c_bus_device *bus = (struct rt_i2c_bus_device *)dev->user_data;
RT_ASSERT(bus != RT_NULL); RT_ASSERT(bus != RT_NULL);
RT_ASSERT(buffer != RT_NULL);
return RT_EOK;
i2c_dbg("I2C bus dev [%s] reading %u bytes.\n", dev->parent.name, count); }
addr = pos & 0xffff; static rt_size_t i2c_bus_device_read(rt_device_t dev,
flags = (pos >> 16) & 0xffff; rt_off_t pos,
void *buffer,
return rt_i2c_master_recv(bus, addr, flags, buffer, count); rt_size_t count)
} {
rt_uint16_t addr;
rt_uint16_t flags;
static rt_size_t i2c_bus_device_write (rt_device_t dev, struct rt_i2c_bus_device *bus = (struct rt_i2c_bus_device *)dev->user_data;
rt_off_t pos,
const void *buffer, RT_ASSERT(bus != RT_NULL);
rt_size_t count) RT_ASSERT(buffer != RT_NULL);
{
rt_uint16_t addr; i2c_dbg("I2C bus dev [%s] reading %u bytes.\n", dev->parent.name, count);
rt_uint16_t flags;
struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data; addr = pos & 0xffff;
flags = (pos >> 16) & 0xffff;
RT_ASSERT(bus != RT_NULL);
RT_ASSERT(buffer != RT_NULL); return rt_i2c_master_recv(bus, addr, flags, buffer, count);
}
i2c_dbg("I2C bus dev writing %u bytes.\n", dev->parent.name, count);
static rt_size_t i2c_bus_device_write(rt_device_t dev,
addr = pos & 0xffff; rt_off_t pos,
flags = (pos >> 16) & 0xffff; const void *buffer,
rt_size_t count)
return rt_i2c_master_send(bus, addr, flags, buffer, count); {
} rt_uint16_t addr;
rt_uint16_t flags;
static rt_err_t i2c_bus_device_control(rt_device_t dev, struct rt_i2c_bus_device *bus = (struct rt_i2c_bus_device *)dev->user_data;
rt_uint8_t cmd,
void *args) RT_ASSERT(bus != RT_NULL);
{ RT_ASSERT(buffer != RT_NULL);
rt_err_t ret;
struct rt_i2c_priv_data *priv_data; i2c_dbg("I2C bus dev writing %u bytes.\n", dev->parent.name, count);
struct rt_i2c_bus_device* bus = (struct rt_i2c_bus_device *)dev->user_data;
addr = pos & 0xffff;
RT_ASSERT(bus != RT_NULL); flags = (pos >> 16) & 0xffff;
switch (cmd) return rt_i2c_master_send(bus, addr, flags, buffer, count);
{ }
case RT_I2C_DEV_CTRL_10BIT: /* set 10-bit addr mode */
bus->flags |= RT_I2C_ADDR_10BIT; static rt_err_t i2c_bus_device_control(rt_device_t dev,
break; rt_uint8_t cmd,
case RT_I2C_DEV_CTRL_ADDR: void *args)
bus->addr = *(rt_uint16_t *)args; {
break; rt_err_t ret;
case RT_I2C_DEV_CTRL_TIMEOUT: struct rt_i2c_priv_data *priv_data;
bus->timeout = *(rt_uint32_t *)args; struct rt_i2c_bus_device *bus = (struct rt_i2c_bus_device *)dev->user_data;
break;
case RT_I2C_DEV_CTRL_RW: RT_ASSERT(bus != RT_NULL);
priv_data = (struct rt_i2c_priv_data *)args;
ret = rt_i2c_transfer(bus, priv_data->msgs, priv_data->number); switch (cmd)
if (ret < 0) {
{ /* set 10-bit addr mode */
return -RT_EIO; case RT_I2C_DEV_CTRL_10BIT:
} bus->flags |= RT_I2C_ADDR_10BIT;
break; break;
default: case RT_I2C_DEV_CTRL_ADDR:
break; bus->addr = *(rt_uint16_t *)args;
} break;
case RT_I2C_DEV_CTRL_TIMEOUT:
return RT_EOK; bus->timeout = *(rt_uint32_t *)args;
} break;
case RT_I2C_DEV_CTRL_RW:
priv_data = (struct rt_i2c_priv_data *)args;
rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device* bus, ret = rt_i2c_transfer(bus, priv_data->msgs, priv_data->number);
const char* name) if (ret < 0)
{ {
struct rt_device *device; return -RT_EIO;
RT_ASSERT(bus != RT_NULL); }
break;
device = &bus->parent; default:
break;
device->user_data = bus; }
/* set device type */ return RT_EOK;
device->type = RT_Device_Class_I2CBUS; }
/* initialize device interface */
device->init = i2c_bus_device_init; rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device *bus,
device->open = RT_NULL; const char *name)
device->close = RT_NULL; {
device->read = i2c_bus_device_read; struct rt_device *device;
device->write = i2c_bus_device_write; RT_ASSERT(bus != RT_NULL);
device->control = i2c_bus_device_control;
device = &bus->parent;
/* register to device manager */
rt_device_register(device, name, RT_DEVICE_FLAG_RDWR); device->user_data = bus;
return RT_EOK; /* set device type */
} device->type = RT_Device_Class_I2CBUS;
/* initialize device interface */
device->init = i2c_bus_device_init;
device->open = RT_NULL;
device->close = RT_NULL;
device->read = i2c_bus_device_read;
device->write = i2c_bus_device_write;
device->control = i2c_bus_device_control;
/* register to device manager */
rt_device_register(device, name, RT_DEVICE_FLAG_RDWR);
return RT_EOK;
}
components/drivers/include/drivers/i2c-bit-ops.h
浏览文件 @ 68b7e7c4
/* /*
* File : i2c-bit-ops.h * File : i2c-bit-ops.h
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Development Team * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2012-04-25 weety first version * 2012-04-25 weety first version
*/ */
#ifndef __I2C_BIT_OPS_H__ #ifndef __I2C_BIT_OPS_H__
#define __I2C_BIT_OPS_H__ #define __I2C_BIT_OPS_H__
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
struct rt_i2c_bit_ops struct rt_i2c_bit_ops
{ {
void *data; /* private data for lowlevel routines */ void *data; /* private data for lowlevel routines */
void (*set_sda) (void *data, rt_int32_t state); void (*set_sda)(void *data, rt_int32_t state);
void (*set_scl) (void *data, rt_int32_t state); void (*set_scl)(void *data, rt_int32_t state);
rt_int32_t (*get_sda) (void *data); rt_int32_t (*get_sda)(void *data);
rt_int32_t (*get_scl) (void *data); rt_int32_t (*get_scl)(void *data);
void (*udelay) (rt_uint32_t us); void (*udelay)(rt_uint32_t us);
rt_uint32_t delay_us; /* scl and sda line delay */ rt_uint32_t delay_us; /* scl and sda line delay */
rt_uint32_t timeout; /* in tick */ rt_uint32_t timeout; /* in tick */
}; };
rt_err_t rt_i2c_bit_add_bus(struct rt_i2c_bus_device *bus, rt_err_t rt_i2c_bit_add_bus(struct rt_i2c_bus_device *bus,
const char *bus_name); const char *bus_name);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
components/drivers/include/drivers/i2c.h
浏览文件 @ 68b7e7c4
/* /*
* File : i2c.h * File : i2c.h
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Development Team * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2012-04-25 weety first version * 2012-04-25 weety first version
*/ */
#ifndef __I2C_H__ #ifndef __I2C_H__
#define __I2C_H__ #define __I2C_H__
#include <rtthread.h> #include <rtthread.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define RT_I2C_WR 0x0000 #define RT_I2C_WR 0x0000
#define RT_I2C_RD (1u << 0) #define RT_I2C_RD (1u << 0)
#define RT_I2C_ADDR_10BIT (1u << 2) /* this is a ten bit chip address */ #define RT_I2C_ADDR_10BIT (1u << 2) /* this is a ten bit chip address */
#define RT_I2C_NO_START (1u << 4) #define RT_I2C_NO_START (1u << 4)
#define RT_I2C_IGNORE_NACK (1u << 5) #define RT_I2C_IGNORE_NACK (1u << 5)
#define RT_I2C_NO_READ_ACK (1u << 6) /* when I2C reading, we do not ACK */ #define RT_I2C_NO_READ_ACK (1u << 6) /* when I2C reading, we do not ACK */
struct rt_i2c_msg struct rt_i2c_msg
{ {
rt_uint16_t addr; rt_uint16_t addr;
rt_uint16_t flags; rt_uint16_t flags;
rt_uint16_t len; rt_uint16_t len;
rt_uint8_t *buf; rt_uint8_t *buf;
}; };
struct rt_i2c_bus_device; struct rt_i2c_bus_device;
struct rt_i2c_bus_device_ops struct rt_i2c_bus_device_ops
{ {
rt_size_t (*master_xfer) (struct rt_i2c_bus_device *bus, rt_size_t (*master_xfer)(struct rt_i2c_bus_device *bus,
struct rt_i2c_msg msgs[], struct rt_i2c_msg msgs[],
rt_uint32_t num); rt_uint32_t num);
rt_size_t (*slave_xfer) (struct rt_i2c_bus_device *bus, rt_size_t (*slave_xfer)(struct rt_i2c_bus_device *bus,
struct rt_i2c_msg msgs[], struct rt_i2c_msg msgs[],
rt_uint32_t num); rt_uint32_t num);
rt_err_t (*i2c_bus_control) (struct rt_i2c_bus_device *bus, rt_err_t (*i2c_bus_control)(struct rt_i2c_bus_device *bus,
rt_uint32_t, rt_uint32_t,
rt_uint32_t); rt_uint32_t);
}; };
/*for i2c bus driver*/ /*for i2c bus driver*/
struct rt_i2c_bus_device struct rt_i2c_bus_device
{ {
struct rt_device parent; struct rt_device parent;
const struct rt_i2c_bus_device_ops *ops; const struct rt_i2c_bus_device_ops *ops;
rt_uint16_t flags; rt_uint16_t flags;
rt_uint16_t addr; rt_uint16_t addr;
struct rt_mutex lock; struct rt_mutex lock;
rt_uint32_t timeout; rt_uint32_t timeout;
rt_uint32_t retries; rt_uint32_t retries;
void *priv; void *priv;
}; };
#ifdef RT_I2C_DEBUG #ifdef RT_I2C_DEBUG
#define i2c_dbg(fmt, ...) rt_kprintf(fmt, ##__VA_ARGS__) #define i2c_dbg(fmt, ...) rt_kprintf(fmt, ##__VA_ARGS__)
#else #else
#define i2c_dbg(fmt, ...) #define i2c_dbg(fmt, ...)
#endif #endif
rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus, rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus,
const char *bus_name); const char *bus_name);
struct rt_i2c_bus_device* rt_i2c_bus_device_find(const char *bus_name); struct rt_i2c_bus_device *rt_i2c_bus_device_find(const char *bus_name);
rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus, rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus,
struct rt_i2c_msg msgs[], struct rt_i2c_msg msgs[],
rt_uint32_t num); rt_uint32_t num);
rt_size_t rt_i2c_master_send(struct rt_i2c_bus_device *bus, rt_size_t rt_i2c_master_send(struct rt_i2c_bus_device *bus,
rt_uint16_t addr, rt_uint16_t addr,
rt_uint16_t flags, rt_uint16_t flags,
const rt_uint8_t *buf, const rt_uint8_t *buf,
rt_uint32_t count); rt_uint32_t count);
rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus, rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus,
rt_uint16_t addr, rt_uint16_t addr,
rt_uint16_t flags, rt_uint16_t flags,
rt_uint8_t *buf, rt_uint8_t *buf,
rt_uint32_t count); rt_uint32_t count);
rt_err_t rt_i2c_core_init(void); rt_err_t rt_i2c_core_init(void);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
components/drivers/include/drivers/i2c_dev.h
浏览文件 @ 68b7e7c4
#ifndef __I2C_DEV_H__ /*
#define __I2C_DEV_H__ * File : i2c_dev.h
* This file is part of RT-Thread RTOS
#include <rtthread.h> * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
*
#ifdef __cplusplus * The license and distribution terms for this file may be
extern "C" { * found in the file LICENSE in this distribution or at
#endif * http://www.rt-thread.org/license/LICENSE
*
#define RT_I2C_DEV_CTRL_10BIT 0x20 * Change Logs:
#define RT_I2C_DEV_CTRL_ADDR 0x21 * Date Author Notes
#define RT_I2C_DEV_CTRL_TIMEOUT 0x22 * 2012-04-25 weety first version
#define RT_I2C_DEV_CTRL_RW 0x23 */
struct rt_i2c_priv_data #ifndef __I2C_DEV_H__
{ #define __I2C_DEV_H__
struct rt_i2c_msg *msgs;
rt_size_t number; #include <rtthread.h>
};
#ifdef __cplusplus
rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device* bus, extern "C" {
const char* name); #endif
#define RT_I2C_DEV_CTRL_10BIT 0x20
#ifdef __cplusplus #define RT_I2C_DEV_CTRL_ADDR 0x21
} #define RT_I2C_DEV_CTRL_TIMEOUT 0x22
#endif #define RT_I2C_DEV_CTRL_RW 0x23
#endif struct rt_i2c_priv_data
{
struct rt_i2c_msg *msgs;
rt_size_t number;
};
rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device *bus,
const char *name);
#ifdef __cplusplus
}
#endif
#endif
components/drivers/mtd/mtd_nand.c
浏览文件 @ 68b7e7c4
/* /*
* File : mtd_core.c * File : mtd_core.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2011-12-05 Bernard the first version * 2011-12-05 Bernard the first version
*/ */
/* /*
* COPYRIGHT (C) 2012, Shanghai Real Thread * COPYRIGHT (C) 2012, Shanghai Real Thread
*/ */
#include <drivers/mtd_nand.h> #include <drivers/mtd_nand.h>
#ifdef RT_USING_MTD_NAND #ifdef RT_USING_MTD_NAND
/* /**
* RT-Thread Generic Device Interface * RT-Thread Generic Device Interface
*/ */
static rt_err_t _mtd_init(rt_device_t dev) static rt_err_t _mtd_init(rt_device_t dev)
{ {
return RT_EOK; return RT_EOK;
}
static rt_err_t _mtd_open(rt_device_t dev, rt_uint16_t oflag)
{
return RT_EOK;
}
static rt_err_t _mtd_close(rt_device_t dev)
{
return RT_EOK;
}
static rt_size_t _mtd_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
{
return size;
}
static rt_size_t _mtd_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
return size;
}
static rt_err_t _mtd_control(rt_device_t dev, rt_uint8_t cmd, void *args)
{
return RT_EOK;
}
rt_err_t rt_mtd_nand_register_device(const char* name, struct rt_mtd_nand_device* device)
{
rt_device_t dev;
dev = RT_DEVICE(device);
RT_ASSERT(dev != RT_NULL);
/* set device class and generic device interface */
dev->type = RT_Device_Class_MTD;
dev->init = _mtd_init;
dev->open = _mtd_open;
dev->read = _mtd_read;
dev->write = _mtd_write;
dev->close = _mtd_close;
dev->control = _mtd_control;
dev->rx_indicate = RT_NULL;
dev->tx_complete = RT_NULL;
/* register to RT-Thread device system */
return rt_device_register(dev, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
} }
#endif
static rt_err_t _mtd_open(rt_device_t dev, rt_uint16_t oflag)
{
return RT_EOK;
}
static rt_err_t _mtd_close(rt_device_t dev)
{
return RT_EOK;
}
static rt_size_t _mtd_read(rt_device_t dev,
rt_off_t pos,
void *buffer,
rt_size_t size)
{
return size;
}
static rt_size_t _mtd_write(rt_device_t dev,
rt_off_t pos,
const void *buffer,
rt_size_t size)
{
return size;
}
static rt_err_t _mtd_control(rt_device_t dev, rt_uint8_t cmd, void *args)
{
return RT_EOK;
}
rt_err_t rt_mtd_nand_register_device(const char *name,
struct rt_mtd_nand_device *device)
{
rt_device_t dev;
dev = RT_DEVICE(device);
RT_ASSERT(dev != RT_NULL);
/* set device class and generic device interface */
dev->type = RT_Device_Class_MTD;
dev->init = _mtd_init;
dev->open = _mtd_open;
dev->read = _mtd_read;
dev->write = _mtd_write;
dev->close = _mtd_close;
dev->control = _mtd_control;
dev->rx_indicate = RT_NULL;
dev->tx_complete = RT_NULL;
/* register to RT-Thread device system */
return rt_device_register(dev, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
}
#endif
components/drivers/mtd/mtd_nor.c
浏览文件 @ 68b7e7c4
/* /*
* File : mtd_nor.c * File : mtd_nor.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2012, Shanghai Real-Thread Technology Co., Ltd * COPYRIGHT (C) 2012, Shanghai Real-Thread Technology Co., Ltd
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2012-5-30 Bernard the first version * 2012-5-30 Bernard the first version
*/ */
#include <drivers/mtd_nor.h> #include <drivers/mtd_nor.h>
#ifdef RT_USING_MTD_NOR #ifdef RT_USING_MTD_NOR
/* /**
* RT-Thread Generic Device Interface * RT-Thread Generic Device Interface
*/ */
static rt_err_t _mtd_init(rt_device_t dev) static rt_err_t _mtd_init(rt_device_t dev)
{ {
return RT_EOK; return RT_EOK;
} }
static rt_err_t _mtd_open(rt_device_t dev, rt_uint16_t oflag) static rt_err_t _mtd_open(rt_device_t dev, rt_uint16_t oflag)
{ {
return RT_EOK; return RT_EOK;
} }
static rt_err_t _mtd_close(rt_device_t dev) static rt_err_t _mtd_close(rt_device_t dev)
{ {
return RT_EOK; return RT_EOK;
} }
static rt_size_t _mtd_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size) static rt_size_t _mtd_read(rt_device_t dev,
{ rt_off_t pos,
return size; void *buffer,
} rt_size_t size)
{
static rt_size_t _mtd_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size) return size;
{ }
return size;
} static rt_size_t _mtd_write(rt_device_t dev,
rt_off_t pos,
static rt_err_t _mtd_control(rt_device_t dev, rt_uint8_t cmd, void *args) const void *buffer,
{ rt_size_t size)
return RT_EOK; {
} return size;
}
rt_err_t rt_mtd_nor_register_device(const char* name, struct rt_mtd_nor_device* device)
{ static rt_err_t _mtd_control(rt_device_t dev, rt_uint8_t cmd, void *args)
rt_device_t dev; {
return RT_EOK;
dev = RT_DEVICE(device); }
RT_ASSERT(dev != RT_NULL);
rt_err_t rt_mtd_nor_register_device(const char *name,
/* set device class and generic device interface */ struct rt_mtd_nor_device *device)
dev->type = RT_Device_Class_MTD; {
dev->init = _mtd_init; rt_device_t dev;
dev->open = _mtd_open;
dev->read = _mtd_read; dev = RT_DEVICE(device);
dev->write = _mtd_write; RT_ASSERT(dev != RT_NULL);
dev->close = _mtd_close;
dev->control = _mtd_control; /* set device class and generic device interface */
dev->type = RT_Device_Class_MTD;
dev->rx_indicate = RT_NULL; dev->init = _mtd_init;
dev->tx_complete = RT_NULL; dev->open = _mtd_open;
dev->read = _mtd_read;
/* register to RT-Thread device system */ dev->write = _mtd_write;
return rt_device_register(dev, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE); dev->close = _mtd_close;
} dev->control = _mtd_control;
#endif
dev->rx_indicate = RT_NULL;
dev->tx_complete = RT_NULL;
/* register to RT-Thread device system */
return rt_device_register(dev, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
}
#endif
components/drivers/rtc/alarm.c
浏览文件 @ 68b7e7c4
此差异已折叠。
components/drivers/src/completion.c
浏览文件 @ 68b7e7c4
...@@ -89,6 +89,7 @@ rt_err_t rt_completion_wait(struct rt_completion *completion, ...@@ -89,6 +89,7 @@ rt_err_t rt_completion_wait(struct rt_completion *completion,
__exit: __exit:
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
return result; return result;
} }
......
components/drivers/src/pipe.c
浏览文件 @ 68b7e7c4
/* /*
* File : pipe.c * File : pipe.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2012, RT-Thread Development Team * COPYRIGHT (C) 2012, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2012-09-30 Bernard first version. * 2012-09-30 Bernard first version.
*/ */
#include <rthw.h> #include <rthw.h>
#include <rtthread.h> #include <rtthread.h>
#include <rtdevice.h> #include <rtdevice.h>
static rt_size_t rt_pipe_read(rt_device_t dev, static rt_size_t rt_pipe_read(rt_device_t dev,
rt_off_t pos, rt_off_t pos,
void *buffer, void *buffer,
rt_size_t size) rt_size_t size)
{ {
rt_uint32_t level; rt_uint32_t level;
rt_thread_t thread; rt_thread_t thread;
struct rt_pipe_device *pipe; struct rt_pipe_device *pipe;
rt_size_t read_nbytes; rt_size_t read_nbytes;
pipe = PIPE_DEVICE(dev); pipe = PIPE_DEVICE(dev);
RT_ASSERT(pipe != RT_NULL); RT_ASSERT(pipe != RT_NULL);
thread = rt_thread_self(); thread = rt_thread_self();
/* current context checking */ /* current context checking */
RT_DEBUG_NOT_IN_INTERRUPT; RT_DEBUG_NOT_IN_INTERRUPT;
do do
{ {
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
read_nbytes = rt_ringbuffer_get(&(pipe->ringbuffer), buffer, size); read_nbytes = rt_ringbuffer_get(&(pipe->ringbuffer), buffer, size);
if (read_nbytes == 0) if (read_nbytes == 0)
{ {
rt_thread_suspend(thread); rt_thread_suspend(thread);
/* waiting on suspended read list */ /* waiting on suspended read list */
rt_list_insert_before(&(pipe->suspended_read_list), &(thread->tlist)); rt_list_insert_before(&(pipe->suspended_read_list), &(thread->tlist));
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
rt_schedule(); rt_schedule();
} }
else else
{ {
if (!rt_list_isempty(&pipe->suspended_write_list)) if (!rt_list_isempty(&pipe->suspended_write_list))
{ {
/* get suspended thread */ /* get suspended thread */
thread = rt_list_entry(pipe->suspended_write_list.next, thread = rt_list_entry(pipe->suspended_write_list.next,
struct rt_thread, tlist); struct rt_thread, tlist);
/* resume the write thread */ /* resume the write thread */
rt_thread_resume(thread); rt_thread_resume(thread);
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
rt_schedule(); rt_schedule();
} }
else else
{ {
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
} }
break; break;
} }
} while (read_nbytes == 0); } while (read_nbytes == 0);
return read_nbytes; return read_nbytes;
} }
struct rt_pipe_device *_pipe = RT_NULL; struct rt_pipe_device *_pipe = RT_NULL;
static rt_size_t rt_pipe_write(rt_device_t dev, static rt_size_t rt_pipe_write(rt_device_t dev,
rt_off_t pos, rt_off_t pos,
const void *buffer, const void *buffer,
rt_size_t size) rt_size_t size)
{ {
rt_uint32_t level; rt_uint32_t level;
rt_thread_t thread; rt_thread_t thread;
struct rt_pipe_device *pipe; struct rt_pipe_device *pipe;
rt_size_t write_nbytes; rt_size_t write_nbytes;
pipe = PIPE_DEVICE(dev); pipe = PIPE_DEVICE(dev);
RT_ASSERT(pipe != RT_NULL); RT_ASSERT(pipe != RT_NULL);
if (_pipe == RT_NULL) if (_pipe == RT_NULL)
_pipe = pipe; _pipe = pipe;
thread = rt_thread_self(); thread = rt_thread_self();
/* current context checking */ /* current context checking */
RT_DEBUG_NOT_IN_INTERRUPT; RT_DEBUG_NOT_IN_INTERRUPT;
do do
{ {
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
write_nbytes = rt_ringbuffer_put(&(pipe->ringbuffer), buffer, size); write_nbytes = rt_ringbuffer_put(&(pipe->ringbuffer), buffer, size);
if (write_nbytes == 0) if (write_nbytes == 0)
{ {
/* pipe full, waiting on suspended write list */ /* pipe full, waiting on suspended write list */
rt_thread_suspend(thread); rt_thread_suspend(thread);
/* waiting on suspended read list */ /* waiting on suspended read list */
rt_list_insert_before(&(pipe->suspended_write_list), &(thread->tlist)); rt_list_insert_before(&(pipe->suspended_write_list), &(thread->tlist));
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
rt_schedule(); rt_schedule();
} }
else else
{ {
if (!rt_list_isempty(&pipe->suspended_read_list)) if (!rt_list_isempty(&pipe->suspended_read_list))
{ {
/* get suspended thread */ /* get suspended thread */
thread = rt_list_entry(pipe->suspended_read_list.next, thread = rt_list_entry(pipe->suspended_read_list.next,
struct rt_thread, tlist); struct rt_thread, tlist);
/* resume the read thread */ /* resume the read thread */
rt_thread_resume(thread); rt_thread_resume(thread);
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
rt_schedule(); rt_schedule();
} }
else else
{ {
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
} }
break; break;
} }
}while (write_nbytes == 0); }while (write_nbytes == 0);
return write_nbytes; return write_nbytes;
} }
static rt_err_t rt_pipe_control(rt_device_t dev, rt_uint8_t cmd, void *args) static rt_err_t rt_pipe_control(rt_device_t dev, rt_uint8_t cmd, void *args)
{ {
return RT_EOK; return RT_EOK;
} }
rt_err_t rt_pipe_create(const char *name, rt_size_t size) rt_err_t rt_pipe_create(const char *name, rt_size_t size)
{ {
rt_err_t result = RT_EOK; rt_err_t result = RT_EOK;
rt_uint8_t *rb_memptr = RT_NULL; rt_uint8_t *rb_memptr = RT_NULL;
struct rt_pipe_device *pipe = RT_NULL; struct rt_pipe_device *pipe = RT_NULL;
/* get aligned size */ /* get aligned size */
size = RT_ALIGN(size, RT_ALIGN_SIZE); size = RT_ALIGN(size, RT_ALIGN_SIZE);
pipe = (struct rt_pipe_device *)rt_calloc(1, sizeof(struct rt_pipe_device)); pipe = (struct rt_pipe_device *)rt_calloc(1, sizeof(struct rt_pipe_device));
if (pipe != RT_NULL) if (pipe != RT_NULL)
{ {
/* create ring buffer of pipe */ /* create ring buffer of pipe */
rb_memptr = rt_malloc(size); rb_memptr = rt_malloc(size);
if (rb_memptr == RT_NULL) if (rb_memptr == RT_NULL)
{ {
result = -RT_ENOMEM; result = -RT_ENOMEM;
goto __exit; goto __exit;
} }
/* initialize suspended list */ /* initialize suspended list */
rt_list_init(&pipe->suspended_read_list); rt_list_init(&pipe->suspended_read_list);
rt_list_init(&pipe->suspended_write_list); rt_list_init(&pipe->suspended_write_list);
/* initialize ring buffer */ /* initialize ring buffer */
rt_ringbuffer_init(&pipe->ringbuffer, rb_memptr, size); rt_ringbuffer_init(&pipe->ringbuffer, rb_memptr, size);
/* create device */ /* create device */
pipe->parent.type = RT_Device_Class_Char; pipe->parent.type = RT_Device_Class_Char;
pipe->parent.init = RT_NULL; pipe->parent.init = RT_NULL;
pipe->parent.open = RT_NULL; pipe->parent.open = RT_NULL;
pipe->parent.close = RT_NULL; pipe->parent.close = RT_NULL;
pipe->parent.read = rt_pipe_read; pipe->parent.read = rt_pipe_read;
pipe->parent.write = rt_pipe_write; pipe->parent.write = rt_pipe_write;
pipe->parent.control = rt_pipe_control; pipe->parent.control = rt_pipe_control;
return rt_device_register(&(pipe->parent), name, RT_DEVICE_FLAG_RDWR); return rt_device_register(&(pipe->parent), name, RT_DEVICE_FLAG_RDWR);
} }
else else
{ {
result = -RT_ENOMEM; result = -RT_ENOMEM;
} }
__exit: __exit:
if (pipe != RT_NULL) if (pipe != RT_NULL)
rt_free(pipe); rt_free(pipe);
if (rb_memptr != RT_NULL) if (rb_memptr != RT_NULL)
rt_free(rb_memptr); rt_free(rb_memptr);
return result; return result;
} }
RTM_EXPORT(rt_pipe_create); RTM_EXPORT(rt_pipe_create);
void rt_pipe_destroy(struct rt_pipe_device *pipe) void rt_pipe_destroy(struct rt_pipe_device *pipe)
{ {
if (pipe == RT_NULL) if (pipe == RT_NULL)
return; return;
/* un-register pipe device */ /* un-register pipe device */
rt_device_unregister(&(pipe->parent)); rt_device_unregister(&(pipe->parent));
/* release memory */ /* release memory */
rt_free(pipe->ringbuffer.buffer_ptr); rt_free(pipe->ringbuffer.buffer_ptr);
rt_free(pipe); rt_free(pipe);
return; return;
} }
RTM_EXPORT(rt_pipe_destroy); RTM_EXPORT(rt_pipe_destroy);
components/drivers/src/ringbuffer.c
浏览文件 @ 68b7e7c4
/* /*
* File : ringbuffer.c * File : ringbuffer.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2012, RT-Thread Development Team * COPYRIGHT (C) 2012, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2012-09-30 Bernard first version. * 2012-09-30 Bernard first version.
*/ */
#include <rtthread.h> #include <rtthread.h>
#include <rtdevice.h> #include <rtdevice.h>
#include <string.h> #include <string.h>
void rt_ringbuffer_init(struct rt_ringbuffer *rb, void rt_ringbuffer_init(struct rt_ringbuffer *rb,
rt_uint8_t *pool, rt_uint8_t *pool,
rt_uint16_t size) rt_uint16_t size)
{ {
RT_ASSERT(rb != RT_NULL); RT_ASSERT(rb != RT_NULL);
/* initialize read and write index */ /* initialize read and write index */
rb->read_index = rb->write_index = 0; rb->read_index = rb->write_index = 0;
/* set buffer pool and size */ /* set buffer pool and size */
rb->buffer_ptr = pool; rb->buffer_ptr = pool;
rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE); rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
} }
RTM_EXPORT(rt_ringbuffer_init); RTM_EXPORT(rt_ringbuffer_init);
rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb, rt_size_t rt_ringbuffer_put(struct rt_ringbuffer *rb,
const rt_uint8_t *ptr, const rt_uint8_t *ptr,
rt_uint16_t length) rt_uint16_t length)
{ {
rt_uint16_t size; rt_uint16_t size;
rt_uint16_t mask; rt_uint16_t mask;
rt_uint16_t write_position; rt_uint16_t write_position;
RT_ASSERT(rb != RT_NULL); RT_ASSERT(rb != RT_NULL);
mask = rb->buffer_size - 1; mask = rb->buffer_size - 1;
/* whether has enough space */ /* whether has enough space */
size = rb->buffer_size - (rb->write_index - rb->read_index); size = rb->buffer_size - (rb->write_index - rb->read_index);
/* no space */ /* no space */
if (size == 0) return 0; if (size == 0)
/* drop some data */ return 0;
if (size < length) length = size; /* drop some data */
if (size < length)
write_position = (rb->write_index & mask); length = size;
if (rb->buffer_size - write_position> length)
{ write_position = (rb->write_index & mask);
/* read_index - write_index = empty space */ if (rb->buffer_size - write_position> length)
memcpy(&rb->buffer_ptr[write_position], ptr, length); {
} /* read_index - write_index = empty space */
else memcpy(&rb->buffer_ptr[write_position], ptr, length);
{ }
memcpy(&rb->buffer_ptr[write_position], ptr, else
rb->buffer_size - write_position); {
memcpy(&rb->buffer_ptr[0], &ptr[rb->buffer_size - write_position], memcpy(&rb->buffer_ptr[write_position], ptr,
length - (rb->buffer_size - write_position)); rb->buffer_size - write_position);
} memcpy(&rb->buffer_ptr[0], &ptr[rb->buffer_size - write_position],
rb->write_index += length; length - (rb->buffer_size - write_position));
}
return length; rb->write_index += length;
}
RTM_EXPORT(rt_ringbuffer_put); return length;
}
/** RTM_EXPORT(rt_ringbuffer_put);
* put a character into ring buffer
*/ /**
rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer* rb, const rt_uint8_t ch) * put a character into ring buffer
{ */
rt_uint16_t mask; rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch)
{
RT_ASSERT(rb != RT_NULL); rt_uint16_t mask;
/* whether has enough space */
mask = rb->buffer_size - 1; RT_ASSERT(rb != RT_NULL);
/* whether has enough space */
/* whether has enough space */ mask = rb->buffer_size - 1;
if (rb->write_index - rb->read_index == rb->buffer_size) return 0;
/* whether has enough space */
/* put character */ if (rb->write_index - rb->read_index == rb->buffer_size)
rb->buffer_ptr[rb->write_index & mask] = ch; return 0;
rb->write_index += 1;
/* put character */
return 1; rb->buffer_ptr[rb->write_index & mask] = ch;
} rb->write_index += 1;
RTM_EXPORT(rt_ringbuffer_putchar);
return 1;
/** }
* get data from ring buffer RTM_EXPORT(rt_ringbuffer_putchar);
*/
rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb, /**
rt_uint8_t *ptr, * get data from ring buffer
rt_uint16_t length) */
{ rt_size_t rt_ringbuffer_get(struct rt_ringbuffer *rb,
rt_size_t size; rt_uint8_t *ptr,
rt_uint16_t mask; rt_uint16_t length)
rt_uint16_t read_position; {
rt_size_t size;
RT_ASSERT(rb != RT_NULL); rt_uint16_t mask;
/* whether has enough data */ rt_uint16_t read_position;
mask = rb->buffer_size - 1;
size = rb->write_index - rb->read_index; RT_ASSERT(rb != RT_NULL);
/* whether has enough data */
/* no data */ mask = rb->buffer_size - 1;
if (size == 0) return 0; size = rb->write_index - rb->read_index;
/* less data */
if (size < length) length = size; /* no data */
if (size == 0)
read_position = rb->read_index & mask; return 0;
if (rb->buffer_size - read_position >= length) /* less data */
{ if (size < length)
/* copy all of data */ length = size;
memcpy(ptr, &rb->buffer_ptr[read_position], length);
} read_position = rb->read_index & mask;
else if (rb->buffer_size - read_position >= length)
{ {
/* copy first and second */ /* copy all of data */
memcpy(ptr, &rb->buffer_ptr[read_position], memcpy(ptr, &rb->buffer_ptr[read_position], length);
rb->buffer_size - read_position); }
memcpy(&ptr[rb->buffer_size - read_position], &rb->buffer_ptr[0], else
length - rb->buffer_size + read_position); {
} /* copy first and second */
rb->read_index += length; memcpy(ptr, &rb->buffer_ptr[read_position],
rb->buffer_size - read_position);
return length; memcpy(&ptr[rb->buffer_size - read_position], &rb->buffer_ptr[0],
} length - rb->buffer_size + read_position);
RTM_EXPORT(rt_ringbuffer_get); }
rb->read_index += length;
/**
* get a character from a ringbuffer return length;
*/ }
rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch) RTM_EXPORT(rt_ringbuffer_get);
{
rt_uint16_t mask; /**
* get a character from a ringbuffer
RT_ASSERT(rb != RT_NULL); */
rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch)
/* ringbuffer is empty */ {
if (rb->read_index == rb->write_index) return 0; rt_uint16_t mask;
mask = rb->buffer_size - 1; RT_ASSERT(rb != RT_NULL);
/* put character */ /* ringbuffer is empty */
*ch = rb->buffer_ptr[rb->read_index & mask]; if (rb->read_index == rb->write_index)
rb->read_index += 1; return 0;
return 1; mask = rb->buffer_size - 1;
}
RTM_EXPORT(rt_ringbuffer_getchar); /* put character */
*ch = rb->buffer_ptr[rb->read_index & mask];
rb->read_index += 1;
return 1;
}
RTM_EXPORT(rt_ringbuffer_getchar);
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或