lby/mr-library
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

更新

Browse Source
This commit is contained in:
MacRsh
2023-03-15 01:38:43 +08:00
parent c0c976c549
commit 30316f810e
9 changed files with 308 additions and 374 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
LICENSE
View File

@@ -42,7 +42,7 @@
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
separable from, or merely test_link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including

272
device/serial.c
View File

@@ -1,272 +0,0 @@
/*
* Copyright (c), mr-library Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-03-09 MacRsh first version
*/
#include "serial.h"
mr_err_t mr_serial_init(mr_serial_t serial, struct mr_serial_config *config)
{
mr_err_t error_code = MR_ERR_OK;
struct mr_serial_fifo *fifo = MR_NULL;
/* Check that the fifo has been allocated */
if (serial->rx_fifo != MR_NULL || serial->tx_fifo != MR_NULL)
return -MR_ERR_GENERIC;
if (config->fifo_size != 0)
{
if (config->fifo_size < MR_SERIAL_FIFO_MIN_SIZE)
config->fifo_size = MR_SERIAL_FIFO_MIN_SIZE;
/* Allocation the rx-fifo memory */
fifo = (struct mr_serial_fifo *) mr_malloc(sizeof(struct mr_serial_fifo *) + config->fifo_size);
if (fifo == MR_NULL)
return -MR_ERR_NO_MEMORY;
mr_ringbuffer_init(&fifo->ringbuffer, fifo->pool, config->fifo_size);
serial->rx_fifo = fifo;
fifo = MR_NULL;
/* Allocation the tx-fifo memory */
fifo = (struct mr_serial_fifo *) mr_malloc(sizeof(struct mr_serial_fifo *) + config->fifo_size);
if (fifo == MR_NULL)
return -MR_ERR_NO_MEMORY;
mr_ringbuffer_init(&fifo->ringbuffer, fifo->pool, config->fifo_size);
serial->tx_fifo = fifo;
fifo = MR_NULL;
}
/* Initialize the underlying hardware */
if (serial->ops->configure != MR_NULL)
{
error_code = serial->ops->configure(serial, config);
if (error_code != MR_ERR_OK)
return error_code;
serial->config = *config;
return MR_ERR_OK;
} else
return -MR_ERR_IO;
}
mr_err_t mr_serial_uninit(mr_serial_t serial)
{
struct mr_serial_fifo *fifo = MR_NULL;
if (serial->config.fifo_size != 0)
{
/* Check that the fifo has been allocated */
if (serial->rx_fifo == MR_NULL || serial->tx_fifo == MR_NULL)
return -MR_ERR_GENERIC;
/* Release the rx-fifo memory */
fifo = (struct mr_serial_fifo *) serial->rx_fifo;
mr_free(fifo);
serial->rx_fifo = MR_NULL;
/* Release the tx-fifo memory */
fifo = (struct mr_serial_fifo *) serial->tx_fifo;
mr_free(fifo);
serial->tx_fifo = MR_NULL;
}
/* Uninitialize the underlying hardware */
if (serial->ops->configure != MR_NULL)
{
serial->config.baud_rate = 0;
return serial->ops->configure(serial, &serial->config);
} else
return -MR_ERR_IO;
}
mr_size_t mr_serial_write(mr_serial_t serial, const mr_uint8_t *buffer, mr_size_t count)
{
mr_size_t send_count = count;
if (serial->ops->write_byte != MR_NULL)
{
while (send_count--)
{
serial->ops->write_byte(serial, *buffer);
buffer++;
}
return count;
} else
{
// MR_LOG_E();
return 0;
}
}
mr_size_t mr_serial_write_byte(mr_serial_t serial, mr_uint8_t data)
{
if (serial->ops->write_byte != MR_NULL)
{
serial->ops->write_byte(serial, data);
return 1;
} else
{
// MR_LOG_E();
return 0;
}
}
mr_size_t mr_serial_read(mr_serial_t serial, mr_uint8_t *buffer, mr_size_t count)
{
struct mr_serial_fifo *fifo = MR_NULL;
mr_size_t recv_count;
if (serial->config.fifo_size != 0)
{
fifo = (struct mr_serial_fifo *) serial->rx_fifo;
do
{
recv_count = mr_ringbuffer_get_data_length(&fifo->ringbuffer);
} while (recv_count < count);
return mr_ringbuffer_read(&fifo->ringbuffer, buffer, count);
} else
return 0;
}
mr_size_t mr_serial_read_byte(mr_serial_t serial, mr_uint8_t *data)
{
struct mr_serial_fifo *fifo = MR_NULL;
mr_size_t recv_count;
if (serial->config.fifo_size != 0)
{
fifo = (struct mr_serial_fifo *) serial->rx_fifo;
do
{
recv_count = mr_ringbuffer_get_data_length(&fifo->ringbuffer);
} while (recv_count < 1);
return mr_ringbuffer_read_byte(&fifo->ringbuffer, data);
} else
return 0;
}
static mr_err_t mr_device_serial_open(mr_device_t device)
{
mr_serial_t serial = (mr_serial_t) device;
return mr_serial_init(serial, &serial->config);
}
static mr_err_t mr_device_serial_close(mr_device_t device)
{
mr_serial_t serial = (mr_serial_t) device;
return mr_serial_uninit(serial);
}
static mr_err_t mr_device_serial_ioctl(mr_device_t device, int cmd, void *args)
{
mr_serial_t serial = (mr_serial_t) device;
struct mr_serial_config config = serial->config;
switch (cmd & _MR_CMD_MASK)
{
case MR_CMD_CONFIG:
{
config = *(struct mr_serial_config *) args;
/* The fifo size cannot be changed once the device is opened */
if ((config.fifo_size != serial->config.fifo_size) && (device->ref_count > 0))
return -MR_ERR_BUSY;
else
return mr_serial_init(serial, &config);
}
case MR_CMD_SET_RX_CALLBACK:
{
device->rx_callback = (mr_err_t (*)(mr_device_t device, void *args)) args;
return MR_ERR_OK;
}
default:return -MR_ERR_UNSUPPORTED;
}
}
static mr_size_t mr_device_serial_read(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t count)
{
mr_serial_t serial = (mr_serial_t) device;
if (count == 0) return 0;
return mr_serial_read(serial, buffer, count);
}
static mr_size_t mr_device_serial_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t count)
{
mr_serial_t serial = (mr_serial_t) device;
if (count == 0) return 0;
return mr_serial_write(serial, buffer, count);
}
mr_err_t mr_serial_add_to_container(mr_serial_t serial, const char *name, struct mr_serial_ops *ops, void *data)
{
mr_err_t error_code = MR_ERR_OK;
struct mr_serial_config default_config = MR_SERIAL_CONFIG_DEFAULT;
const static struct mr_serial_ops null_ops = {MR_NULL};
const static struct mr_device_ops device_ops =
{
.open = mr_device_serial_open,
.close = mr_device_serial_close,
.ioctl = mr_device_serial_ioctl,
.read = mr_device_serial_read,
.write = mr_device_serial_write,
};
/* Initialize the device and add the device to the container */
mr_device_init(&serial->device, name);
error_code = mr_device_add_to_container(&serial->device, MR_DEVICE_TYPE_SERIAL, MR_OPEN_RDWR, &device_ops, data);
if (error_code != MR_ERR_OK)
return error_code;
/* Initialize the serial fields */
serial->config = default_config;
serial->tx_fifo = MR_NULL;
serial->rx_fifo = MR_NULL;
/* Set serial's operations as null_ops if ops is null */
serial->ops = (ops == MR_NULL) ? &null_ops : ops;
return MR_ERR_OK;
}
void mr_hw_serial_isr(mr_serial_t serial, mr_uint16_t event)
{
switch (event & _MR_SERIAL_EVENT_MASK)
{
case MR_SERIAL_EVENT_RX_INT:
{
struct mr_serial_fifo *fifo = (struct mr_serial_fifo *) serial->rx_fifo;
mr_uint8_t data = 0;
/* Read data into the ring buffer */
data = serial->ops->read_byte(serial);
mr_ringbuffer_write_byte_force(&fifo->ringbuffer, data);
/* Invoke the rx-callback function */
if (serial->device.rx_callback != MR_NULL)
{
mr_size_t rx_length = 0;
rx_length = mr_ringbuffer_get_data_length(&fifo->ringbuffer);
serial->device.rx_callback(&serial->device, &rx_length);
}
break;
}
default:break;
}
}

206
device/serial/serial.c Normal file
View File

@@ -0,0 +1,206 @@
/*
* Copyright (c), mr-library Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-03-09 MacRsh first version
*/
#include "serial.h"
static mr_err_t mr_serial_open(mr_device_t device)
{
mr_serial_t serial = (mr_serial_t)device;
struct mr_serial_config default_config = MR_SERIAL_CONFIG_DEFAULT;
struct mr_serial_fifo *fifo = MR_NULL;
/* Allocation the fifo memory */
if (serial->fifo_bufsz != 0)
{
fifo = (struct mr_serial_fifo *)mr_malloc(sizeof(struct mr_serial_fifo *) + serial->fifo_bufsz);
if (fifo == MR_NULL)
return - MR_ERR_NO_MEMORY;
mr_ringbuffer_init(&fifo->ringbuffer, fifo->pool, serial->fifo_bufsz);
serial->fifo_rx = fifo;
fifo = MR_NULL;
fifo = (struct mr_serial_fifo *)mr_malloc(sizeof(struct mr_serial_fifo *) + serial->fifo_bufsz);
if (fifo == MR_NULL)
return - MR_ERR_NO_MEMORY;
mr_ringbuffer_init(&fifo->ringbuffer, fifo->pool, serial->fifo_bufsz);
serial->fifo_tx = fifo;
fifo = MR_NULL;
}
/* Setting serial to default-config */
if (serial->config.baud_rate == 0)
serial->config = default_config;
return serial->ops->configure(serial, &serial->config);
}
static mr_err_t mr_serial_close(mr_device_t device)
{
mr_serial_t serial = (mr_serial_t)device;
struct mr_serial_fifo *fifo = MR_NULL;
/* Release the fifo memory */
if (serial->fifo_bufsz != 0)
{
//TODO 检测写FIFO是否输出完毕，为输出完毕则在此输出，然后再关闭串口设备
fifo = (struct mr_serial_fifo *)serial->fifo_rx;
mr_free(fifo);
serial->fifo_rx = MR_NULL;
fifo = (struct mr_serial_fifo *)serial->fifo_tx;
mr_free(fifo);
serial->fifo_tx = MR_NULL;
}
/* Setting serial to close-config */
serial->config.baud_rate = 0;
return serial->ops->configure(serial, &serial->config);
}
static mr_err_t mr_serial_ioctl(mr_device_t device, int cmd, void *args)
{
mr_err_t ret = MR_ERR_OK;
mr_serial_t serial = (mr_serial_t)device;
switch (cmd & _MR_CMD_MASK)
{
case MR_CMD_CONFIG:
{
if (args)
{
ret = serial->ops->configure(serial, (struct mr_serial_config *)args);
if (ret == MR_ERR_OK)
serial->config = *(struct mr_serial_config *)args;
}
break;
}
default: ret = - MR_ERR_UNSUPPORTED;
}
return ret;
}
static mr_size_t mr_serial_read(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size)
{
mr_serial_t serial = (mr_serial_t)device;
struct mr_serial_fifo *fifo = MR_NULL;
mr_size_t length;
fifo = (struct mr_serial_fifo *)serial->fifo_rx;
do
{
length = mr_ringbuffer_get_data_length(&fifo->ringbuffer);
} while (length < size);
return mr_ringbuffer_read(&fifo->ringbuffer, buffer, size);
}
static mr_size_t mr_serial_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size)
{
mr_serial_t serial = (mr_serial_t)device;
struct mr_serial_fifo *fifo = MR_NULL;
mr_size_t length = 0;
fifo = (struct mr_serial_fifo *)serial->fifo_tx;
do
{
length += mr_ringbuffer_write(&fifo->ringbuffer, &buffer[length], size - length);
} while (length < size);
return length;
}
static mr_err_t _hw_serial_configure(mr_serial_t serial, struct mr_serial_config *config)
{
MR_LOG_D("Serial configure error: -MR_ERR_IO");
return - MR_ERR_IO;
}
static void _hw_serial_write_byte(mr_serial_t serial, mr_uint8_t data)
{
MR_LOG_D("Serial write error: -MR_ERR_IO");
}
static int _hw_serial_read_byte(mr_serial_t serial)
{
MR_LOG_D("Serial read error: -MR_ERR_IO");
return - 1;
}
mr_err_t mr_hw_serial_add_to_container(mr_serial_t serial, const char *name, struct mr_serial_ops *ops, void *data)
{
mr_err_t ret = MR_ERR_OK;
const static struct mr_device_ops device_ops =
{
.open = mr_serial_open,
.close = mr_serial_close,
.ioctl = mr_serial_ioctl,
.read = mr_serial_read,
.write = mr_serial_write,
};
MR_ASSERT(serial != MR_NULL);
MR_ASSERT(ops != MR_NULL);
/* Add the serial device to the container */
ret =
mr_device_add_to_container(&serial->device, name, MR_DEVICE_TYPE_SERIAL, MR_OPEN_RDWR, &device_ops, data);
if (ret != MR_ERR_OK)
return ret;
/* Initialize the serial fields */
serial->config.baud_rate = 0;
serial->fifo_bufsz = MR_SERIAL_FIFO_BUFSZ;
serial->fifo_rx = MR_NULL;
serial->fifo_tx = MR_NULL;
/* Set serial operations as protect functions if ops is null */
ops->configure = ops->configure ? ops->configure : _hw_serial_configure;
ops->write_byte = ops->write_byte ? ops->write_byte : _hw_serial_write_byte;
ops->read_byte = ops->read_byte ? ops->read_byte : _hw_serial_read_byte;
serial->ops = ops;
return MR_ERR_OK;
}
void mr_hw_serial_isr(mr_serial_t serial, mr_uint16_t event)
{
switch (event & _MR_SERIAL_EVENT_MASK)
{
case MR_SERIAL_EVENT_RX_INT:
{
struct mr_serial_fifo *fifo = (struct mr_serial_fifo *)serial->fifo_rx;
mr_uint8_t data;
/* Read data into the ring buffer */
data = serial->ops->read_byte(serial);
mr_ringbuffer_write_byte_force(&fifo->ringbuffer, data);
/* Invoke the rx-callback function */
if (serial->device.rx_callback != MR_NULL)
{
mr_size_t rx_length = 0;
rx_length = mr_ringbuffer_get_data_length(&fifo->ringbuffer);
serial->device.rx_callback(&serial->device, &rx_length);
}
break;
}
default:break;
}
}

39
device/serial.h → device/serial/serial.h
View File

@@ -30,12 +30,17 @@
#define MR_SERIAL_NRZ_NORMAL 0
#define MR_SERIAL_NRZ_INVERTED 1
#define MR_SERIAL_FLOW_CONTROL_NONE 0
#define MR_SERIAL_FLOW_CONTROL_CTSRTS 1
#define MR_SERIAL_FIFO_BUFSZ 32
#define MR_SERIAL_FIFO_MIN_SIZE MR_SERIAL_FIFO_MIN
#define MR_SERIAL_EVENT_RX_INT 0x1000
#define _MR_SERIAL_EVENT_MASK 0xf000
/* Default config for serial_configure structure */
/* Default config for mr_serial_configure structure */
#define MR_SERIAL_CONFIG_DEFAULT \
{ \
115200, \
@@ -44,20 +49,20 @@
MR_SERIAL_PARITY_NONE, \
MR_SERIAL_BIT_ORDER_LSB, \
MR_SERIAL_NRZ_NORMAL, \
MR_SERIAL_FIFO_MIN_SIZE \
MR_SERIAL_FLOW_CONTROL_NONE \
}
struct mr_serial_config
{
mr_uint32_t baud_rate;
mr_uint32_t data_bits: 4;
mr_uint32_t stop_bits: 2;
mr_uint32_t parity: 2;
mr_uint32_t bit_order: 1;
mr_uint32_t invert: 1;
mr_uint32_t fifo_size: 16;
mr_uint32_t reserved: 6;
mr_uint16_t data_bits: 4;
mr_uint16_t stop_bits: 2;
mr_uint16_t parity: 2;
mr_uint16_t bit_order: 1;
mr_uint16_t invert: 1;
mr_uint16_t flow_control: 1;
mr_uint16_t reserved: 5;
};
struct mr_serial_fifo
@@ -71,7 +76,7 @@ struct mr_serial_ops
{
mr_err_t (*configure)(mr_serial_t serial, struct mr_serial_config *config);
void (*write_byte)(mr_serial_t serial, mr_uint8_t data);
mr_uint8_t (*read_byte)(mr_serial_t serial);
int (*read_byte)(mr_serial_t serial);
};
struct mr_serial
@@ -79,20 +84,14 @@ struct mr_serial
struct mr_device device;
struct mr_serial_config config;
void *rx_fifo;
void *tx_fifo;
mr_size_t fifo_bufsz;
void *fifo_rx;
void *fifo_tx;
const struct mr_serial_ops *ops;
};
mr_err_t mr_serial_init(mr_serial_t serial, struct mr_serial_config *config);
mr_err_t mr_serial_uninit(mr_serial_t serial);
mr_size_t mr_serial_write_byte(mr_serial_t serial, mr_uint8_t data);
mr_size_t mr_serial_write(mr_serial_t serial, const mr_uint8_t *buffer, mr_size_t count);
mr_size_t mr_serial_read(mr_serial_t serial, mr_uint8_t *buffer, mr_size_t count);
mr_size_t mr_serial_read_byte(mr_serial_t serial, mr_uint8_t *data);
mr_err_t mr_serial_add_to_container(mr_serial_t serial, const char *name, struct mr_serial_ops *ops, void *data);
mr_err_t mr_hw_serial_add_to_container(mr_serial_t serial, const char *name, struct mr_serial_ops *ops, void *data);
void mr_hw_serial_isr(mr_serial_t serial, mr_uint16_t event);
#endif

117
include/mrdef.h
View File

@@ -66,6 +66,7 @@ typedef mr_base_t mr_off_t; /**< Type for offset */
#define MR_OPEN_RDONLY 0x1000 /**< Read only */
#define MR_OPEN_WRONLY 0x2000 /**< Write only */
#define MR_OPEN_RDWR 0x3000 /**< Read and Write */
#define MR_OPEN_NONBLOCKING 0x4000
#define MR_OPEN_ACTIVE 0x8000 /**< Active */
#define _MR_OPEN_FLAG_MASK 0xf000
@@ -127,32 +128,32 @@ typedef mr_base_t mr_off_t; /**< Type for offset */
typedef enum mr_bool
{
MR_FALSE = 0, MR_TRUE = 1
MR_FALSE = 0, MR_TRUE = 1
} mr_bool_t;
typedef enum mr_level
{
MR_LOW = 0, MR_HIGH = 1
MR_LOW = 0, MR_HIGH = 1
} mr_level_t;
struct mr_list
{
struct mr_list *next; /**< point to next node. */
struct mr_list *prev; /**< point to prev node. */
struct mr_list *next; /**< point to next node. */
struct mr_list *prev; /**< point to prev node. */
};
typedef struct mr_list *mr_list_t;
enum mr_container_type
{
MR_CONTAINER_TYPE_MISC,
MR_CONTAINER_TYPE_DEVICE,
_MR_CONTAINER_TYPE_MASK,
MR_CONTAINER_TYPE_MISC,
MR_CONTAINER_TYPE_DEVICE,
_MR_CONTAINER_TYPE_MASK,
};
struct mr_container
{
enum mr_container_type type;
struct mr_list list;
enum mr_container_type type;
struct mr_list list;
};
typedef struct mr_container *mr_container_t;
@@ -162,87 +163,87 @@ typedef struct mr_container *mr_container_t;
struct mr_object
{
char name[MR_NAME_MAX];
mr_uint8_t type;
struct mr_list list;
char name[MR_NAME_MAX];
mr_uint8_t type;
struct mr_list list;
};
typedef struct mr_object *mr_object_t;
struct mr_mutex
{
enum
{
MR_UNLOCK = 0,
MR_LOCK,
} lock;
mr_object_t owner;
enum
{
MR_UNLOCK = 0,
MR_LOCK,
} lock;
mr_object_t owner;
};
typedef struct mr_mutex *mr_mutex_t;
enum mr_ringbuffer_state
{
MR_RINGBUFFER_EMPTY,
MR_RINGBUFFER_FULL,
MR_RINGBUFFER_HALF_FULL,
MR_RINGBUFFER_EMPTY,
MR_RINGBUFFER_FULL,
MR_RINGBUFFER_HALF_FULL,
};
struct mr_ringbuffer
{
mr_uint8_t *buffer;
mr_uint16_t read_mirror: 1;
mr_uint16_t read_index: 15;
mr_uint16_t write_mirror: 1;
mr_uint16_t write_index: 15;
mr_uint16_t buffer_size;
mr_uint8_t *buffer;
mr_uint16_t read_mirror: 1;
mr_uint16_t read_index: 15;
mr_uint16_t write_mirror: 1;
mr_uint16_t write_index: 15;
mr_uint16_t bufsz;
};
typedef struct mr_ringbuffer *mr_ringbuffer_t;
enum mr_device_type
{
MR_DEVICE_TYPE_NULL,
MR_DEVICE_TYPE_PIN,
MR_DEVICE_TYPE_SPI_BUS,
MR_DEVICE_TYPE_SPI,
MR_DEVICE_TYPE_I2C_BUS,
MR_DEVICE_TYPE_I2C,
MR_DEVICE_TYPE_SERIAL,
MR_DEVICE_TYPE_ADC,
MR_DEVICE_TYPE_DAC,
MR_DEVICE_TYPE_NULL,
MR_DEVICE_TYPE_PIN,
MR_DEVICE_TYPE_SPI_BUS,
MR_DEVICE_TYPE_SPI,
MR_DEVICE_TYPE_I2C_BUS,
MR_DEVICE_TYPE_I2C,
MR_DEVICE_TYPE_SERIAL,
MR_DEVICE_TYPE_ADC,
MR_DEVICE_TYPE_DAC,
MR_DEVICE_TYPE_PWM,
MR_DEVICE_TYPE_TIMER,
MR_DEVICE_TYPE_WDT,
MR_DEVICE_TYPE_FLASH,
MR_DEVICE_TYPE_SDRAM,
/* ... */
MR_DEVICE_TYPE_PWM,
MR_DEVICE_TYPE_TIMER,
MR_DEVICE_TYPE_WDT,
MR_DEVICE_TYPE_FLASH,
MR_DEVICE_TYPE_SDRAM,
/* ... */
MR_DEVICE_TYPE_LINK,
MR_DEVICE_TYPE_LINK_SERVICE,
MR_DEVICE_TYPE_LINK,
MR_DEVICE_TYPE_LINK_SERVICE,
};
typedef struct mr_device *mr_device_t;
struct mr_device_ops
{
mr_err_t (*open)(mr_device_t device);
mr_err_t (*close)(mr_device_t device);
mr_err_t (*ioctl)(mr_device_t device, int cmd, void *args);
mr_size_t (*read)(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t count);
mr_size_t (*write)(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t count);
mr_err_t (*open)(mr_device_t device);
mr_err_t (*close)(mr_device_t device);
mr_err_t (*ioctl)(mr_device_t device, int cmd, void *args);
mr_size_t (*read)(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size);
mr_size_t (*write)(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size);
};
struct mr_device
{
struct mr_object object;
struct mr_object object;
mr_err_t (*rx_callback)(mr_device_t device, void *args);
mr_err_t (*tx_callback)(mr_device_t device, void *args);
enum mr_device_type type;
mr_uint16_t support_flag;
mr_uint16_t open_flag;
mr_uint8_t ref_count;
void *data;
mr_err_t (*rx_callback)(mr_device_t device, void *args);
mr_err_t (*tx_callback)(mr_device_t device, void *args);
enum mr_device_type type;
mr_uint16_t support_flag;
mr_uint16_t open_flag;
mr_uint8_t ref_count;
void *data;
const struct mr_device_ops *ops;
const struct mr_device_ops *ops;
};
#endif

14
include/mrlib.h
View File

@@ -38,15 +38,15 @@ mr_size_t mr_ringbuffer_read_byte(mr_ringbuffer_t ringbuffer, mr_uint8_t *data);
mr_device_t mr_device_find(const char *name);
mr_err_t mr_device_add_to_container(mr_device_t device,
const char *name,
enum mr_device_type type,
mr_uint16_t support_flag,
const struct mr_device_ops *ops,
void *data);
const char *name,
enum mr_device_type type,
mr_uint16_t support_flag,
const struct mr_device_ops *ops,
void *data);
mr_err_t mr_device_open(mr_device_t device, mr_uint16_t flags);
mr_err_t mr_device_close(mr_device_t device);
mr_err_t mr_device_ioctl(mr_device_t device, int cmd, void *args);
mr_size_t mr_device_read(mr_device_t device, mr_off_t pos, void *buf, mr_size_t count);
mr_size_t mr_device_write(mr_device_t device, mr_off_t pos, const void *buf, mr_size_t count);
mr_size_t mr_device_read(mr_device_t device, mr_off_t pos, void *buf, mr_size_t size);
mr_size_t mr_device_write(mr_device_t device, mr_off_t pos, const void *buf, mr_size_t size);
#endif

6
include/mrlog.h
View File

@@ -2,8 +2,8 @@
// Created by 10632 on 2023/3/13.
//
#ifndef DESIGN_MR_LIBRARY_INCLUDE_MRLOG_H_
#define DESIGN_MR_LIBRARY_INCLUDE_MRLOG_H_
#ifndef _MR_LOG_H_
#define _MR_LOG_H_
#include <mrdef.h>
@@ -52,4 +52,4 @@ MR_INLINE void mr_assert_handler()
#define MR_LOG_E(string, error) do{}while(0)
#define MR_LOG_W(string) do{}while(0)
#endif //DESIGN_MR_LIBRARY_INCLUDE_MRLOG_H_
#endif

18
include/mrserve.h
View File

@@ -28,25 +28,25 @@ do{ \
MR_INLINE void mr_list_init(mr_list_t list)
{
list->next = list;
list->prev = list;
list->next = list;
list->prev = list;
}
MR_INLINE void mr_list_insert_after(mr_list_t list, mr_list_t node)
{
list->next->prev = node;
node->next = list->next;
list->next->prev = node;
node->next = list->next;
list->next = node;
node->prev = list;
list->next = node;
node->prev = list;
}
MR_INLINE void mr_list_remove(mr_list_t node)
{
node->next->prev = node->prev;
node->prev->next = node->next;
node->next->prev = node->prev;
node->prev->next = node->next;
node->next = node->prev = node;
node->next = node->prev = node;
}
#endif

8
mrconfig.h
View File

@@ -1,14 +1,14 @@
#ifndef _MR_CONFIG_H_
#define _MR_CONFIG_H_
#define MR_CONF_ENABLE 1
#define MR_CONF_DISABLE 0
#define MR_CONF_ENABLE 1
#define MR_CONF_DISABLE 0
#include <board.h>
#define MR_NAME_MAX 10
#define MR_NAME_MAX 10
#define MR_LIBRARY MR_CONF_ENABLE
#define MR_LIBRARY MR_CONF_ENABLE
#define MR_DEVICE_PIN CONF_ENABLE
#define MR_DEVICE_SPI CONF_ENABLE