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

1.代码格式优化。

Browse Source
This commit is contained in:
MacRsh
2023-07-19 19:12:16 +08:00
parent eeb0f883fd
commit 8dfb4f3e1b
30 changed files with 131 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@@ -158,8 +158,8 @@ 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_ssize_t (*read)(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size);
mr_ssize_t (*write)(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size);
mr_ssize_t (*read)(mr_device_t device, mr_pos_t pos, void *buffer, mr_size_t size);
mr_ssize_t (*write)(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size);
};
```

4
bsp/wch/driver/drv_adc.c
View File

@@ -28,7 +28,7 @@ static struct ch32_adc ch32_adc[] =
static struct mr_adc adc_device[mr_array_get_length(ch32_adc)];
mr_err_t ch32_adc_configure(mr_adc_t adc, mr_uint8_t state)
mr_err_t ch32_adc_configure(mr_adc_t adc, mr_state_t state)
{
struct ch32_adc *driver = (struct ch32_adc *)adc->device.data;
ADC_InitTypeDef ADC_InitStructure = {0};
@@ -87,7 +87,7 @@ mr_err_t ch32_adc_channel_configure(mr_adc_t adc, struct mr_adc_config *config)
return MR_ERR_OK;
}
mr_uint32_t ch32_adc_read(mr_adc_t adc, mr_uint16_t channel)
mr_uint32_t ch32_adc_read(mr_adc_t adc, mr_pos_t channel)
{
struct ch32_adc *driver = (struct ch32_adc *)adc->device.data;
mr_uint32_t data = 0;

4
bsp/wch/driver/drv_dac.c
View File

@@ -28,7 +28,7 @@ static struct ch32_dac ch32_dac[] =
static struct mr_dac dac_device[mr_array_get_length(ch32_dac)];
mr_err_t ch32_dac_configure(mr_dac_t dac, mr_uint8_t state)
mr_err_t ch32_dac_configure(mr_dac_t dac, mr_state_t state)
{
struct ch32_dac *driver = (struct ch32_dac *)dac->device.data;
DAC_InitTypeDef DAC_InitType = {0};
@@ -86,7 +86,7 @@ mr_err_t ch32_dac_channel_configure(mr_dac_t dac, struct mr_dac_config *config)
return MR_ERR_OK;
}
void ch32_dac_write(mr_dac_t dac, mr_uint16_t channel, mr_uint32_t value)
void ch32_dac_write(mr_dac_t dac, mr_pos_t channel, mr_uint32_t value)
{
struct ch32_dac *driver = (struct ch32_dac *)dac->device.data;

12
bsp/wch/driver/drv_gpio.c
View File

@@ -101,21 +101,21 @@ static mr_err_t ch32_pin_configure(mr_pin_t pin, struct mr_pin_config *config)
break;
}
case MR_PIN_MODE_RISING:
case MR_PIN_MODE_IRQ_RISING:
{
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
break;
}
case MR_PIN_MODE_FALLING:
case MR_PIN_MODE_IRQ_FALLING:
{
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
break;
}
case MR_PIN_MODE_EDGE:
case MR_PIN_MODE_IRQ_EDGE:
{
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
@@ -126,7 +126,7 @@ static mr_err_t ch32_pin_configure(mr_pin_t pin, struct mr_pin_config *config)
return -MR_ERR_GENERIC;
}
if (config->mode >= MR_PIN_MODE_RISING)
if (config->mode >= MR_PIN_MODE_IRQ_RISING)
{
if ((mask[config->number % 16] != -1 && mask[config->number % 16] != config->number))
{
@@ -190,12 +190,12 @@ static mr_err_t ch32_pin_configure(mr_pin_t pin, struct mr_pin_config *config)
return MR_ERR_OK;
}
static void ch32_pin_write(mr_pin_t pin, mr_uint16_t number, mr_uint8_t value)
static void ch32_pin_write(mr_pin_t pin, mr_pos_t number, mr_uint8_t value)
{
GPIO_WriteBit(PIN_STPORT(number), PIN_STPIN(number), value);
}
static mr_uint8_t ch32_pin_read(mr_pin_t pin, mr_uint16_t number)
static mr_uint8_t ch32_pin_read(mr_pin_t pin, mr_pos_t number)
{
return GPIO_ReadInputDataBit(PIN_STPORT(number), PIN_STPIN(number));
}

4
bsp/wch/driver/drv_pwm.c
View File

@@ -77,12 +77,12 @@ static mr_err_t ch32_pwm_configure(mr_pwm_t pwm, struct mr_pwm_config *config)
}
static mr_err_t ch32_pwm_write(mr_pwm_t pwm, mr_uint8_t channel, mr_uint32_t duty)
static mr_err_t ch32_pwm_write(mr_pwm_t pwm, mr_pos_t channel, mr_uint32_t duty)
{
}
static mr_uint32_t ch32_pwm_read(mr_pwm_t pwm, mr_uint8_t channel)
static mr_uint32_t ch32_pwm_read(mr_pwm_t pwm, mr_pos_t channel)
{
}

4
bsp/wch/driver/drv_spi.c
View File

@@ -263,7 +263,7 @@ static mr_uint8_t ch32_spi_read(mr_spi_bus_t spi_bus)
return SPI_I2S_ReceiveData(driver->info.Instance);
}
static void ch32_spi_cs_crtl(mr_spi_bus_t spi_bus, mr_uint16_t cs_pin, mr_uint8_t state)
static void ch32_spi_cs_crtl(mr_spi_bus_t spi_bus, mr_pos_t cs_pin, mr_state_t state)
{
if (state == MR_ENABLE)
{
@@ -274,7 +274,7 @@ static void ch32_spi_cs_crtl(mr_spi_bus_t spi_bus, mr_uint16_t cs_pin, mr_uint8_
}
}
static mr_uint8_t ch32_spi_cs_read(mr_spi_bus_t spi_bus, mr_uint16_t cs_pin)
static mr_uint8_t ch32_spi_cs_read(mr_spi_bus_t spi_bus, mr_pos_t cs_pin)
{
return GPIO_ReadOutputDataBit(PIN_STPORT(cs_pin), PIN_STPIN(cs_pin));
}

10
device/adc/adc.c
View File

@@ -46,7 +46,7 @@ static mr_err_t mr_adc_ioctl(mr_device_t device, int cmd, void *args)
}
}
static mr_ssize_t mr_adc_read(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size)
static mr_ssize_t mr_adc_read(mr_device_t device, mr_pos_t pos, void *buffer, mr_size_t size)
{
mr_adc_t adc = (mr_adc_t)device;
mr_uint32_t *recv_buffer = (mr_uint32_t *)buffer;
@@ -59,14 +59,14 @@ static mr_ssize_t mr_adc_read(mr_device_t device, mr_off_t pos, void *buffer, mr
for (recv_size = 0; recv_size < size; recv_size += sizeof(*recv_buffer))
{
*recv_buffer = adc->ops->read(adc, (mr_uint16_t)pos);
*recv_buffer = adc->ops->read(adc, pos);
recv_buffer++;
}
return (mr_ssize_t)recv_size;
}
static mr_err_t _err_io_adc_configure(mr_adc_t adc, mr_uint8_t state)
static mr_err_t _err_io_adc_configure(mr_adc_t adc, mr_state_t state)
{
MR_ASSERT(0);
return -MR_ERR_IO;
@@ -78,7 +78,7 @@ static mr_err_t _err_io_adc_channel_configure(mr_adc_t adc, struct mr_adc_config
return -MR_ERR_IO;
}
static mr_uint32_t _err_io_adc_read(mr_adc_t adc, mr_uint16_t channel)
static mr_uint32_t _err_io_adc_read(mr_adc_t adc, mr_pos_t channel)
{
MR_ASSERT(0);
return 0;
@@ -114,4 +114,4 @@ mr_err_t mr_adc_device_add(mr_adc_t adc, const char *name, void *data, struct mr
return mr_device_add(&adc->device, name, MR_OPEN_RDONLY);
}
#endif
#endif /* MR_CONF_ADC */

12
device/adc/adc.h
View File

@@ -20,17 +20,17 @@
struct mr_adc_config
{
mr_uint16_t channel;
mr_uint8_t state;
mr_pos_t channel;
mr_state_t state;
};
typedef struct mr_adc *mr_adc_t;
struct mr_adc_ops
{
mr_err_t (*configure)(mr_adc_t adc, mr_uint8_t state);
mr_err_t (*configure)(mr_adc_t adc, mr_state_t state);
mr_err_t (*channel_configure)(mr_adc_t adc, struct mr_adc_config *config);
mr_uint32_t (*read)(mr_adc_t adc, mr_uint16_t channel);
mr_uint32_t (*read)(mr_adc_t adc, mr_pos_t channel);
};
struct mr_adc
@@ -42,6 +42,6 @@ struct mr_adc
mr_err_t mr_adc_device_add(mr_adc_t adc, const char *name, void *data, struct mr_adc_ops *ops);
#endif /* MR_CONF_ADC */
#endif /* MR_CONF_ADC */
#endif /* _ADC_H_ */
#endif /* _ADC_H_ */

10
device/dac/dac.c
View File

@@ -46,7 +46,7 @@ static mr_err_t mr_dac_ioctl(mr_device_t device, int cmd, void *args)
}
}
static mr_ssize_t mr_dac_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size)
static mr_ssize_t mr_dac_write(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size)
{
mr_dac_t dac = (mr_dac_t)device;
mr_uint32_t *send_buffer = (mr_uint32_t *)buffer;
@@ -59,14 +59,14 @@ static mr_ssize_t mr_dac_write(mr_device_t device, mr_off_t pos, const void *buf
for (send_size = 0; send_size < size; send_size += sizeof(*send_buffer))
{
dac->ops->write(dac, (mr_uint16_t)pos, *send_buffer);
dac->ops->write(dac, pos, *send_buffer);
send_buffer++;
}
return (mr_ssize_t)send_size;
}
static mr_err_t _err_io_dac_configure(mr_dac_t dac, mr_uint8_t state)
static mr_err_t _err_io_dac_configure(mr_dac_t dac, mr_state_t state)
{
MR_ASSERT(0);
return -MR_ERR_IO;
@@ -78,7 +78,7 @@ static mr_err_t _err_io_dac_channel_configure(mr_dac_t dac, struct mr_dac_config
return -MR_ERR_IO;
}
static void _err_io_dac_write(mr_dac_t dac, mr_uint16_t channel, mr_uint32_t value)
static void _err_io_dac_write(mr_dac_t dac, mr_pos_t channel, mr_uint32_t value)
{
MR_ASSERT(0);
}
@@ -113,4 +113,4 @@ mr_err_t mr_dac_device_add(mr_dac_t dac, const char *name, void *data, struct mr
return mr_device_add(&dac->device, name, MR_OPEN_WRONLY);
}
#endif /* MR_CONF_DAC */
#endif /* MR_CONF_DAC */

13
device/dac/dac.h
View File

@@ -20,28 +20,29 @@
struct mr_dac_config
{
mr_uint16_t channel;
mr_uint8_t state;
mr_pos_t channel;
mr_state_t state;
};
typedef struct mr_dac *mr_dac_t;
struct mr_dac_ops
{
mr_err_t (*configure)(mr_dac_t dac, mr_uint8_t state);
mr_err_t (*configure)(mr_dac_t dac, mr_state_t state);
mr_err_t (*channel_configure)(mr_dac_t dac, struct mr_dac_config *config);
void (*write)(mr_dac_t dac, mr_uint16_t channel, mr_uint32_t value);
void (*write)(mr_dac_t dac, mr_pos_t channel, mr_uint32_t value);
};
struct mr_dac
{
struct mr_device device;
mr_size_t delay;
const struct mr_dac_ops *ops;
};
mr_err_t mr_dac_device_add(mr_dac_t dac, const char *name, void *data, struct mr_dac_ops *ops);
#endif /* MR_CONF_DAC */
#endif /* MR_CONF_DAC */
#endif /* _DAC_H_ */
#endif /* _DAC_H_ */

4
device/device_utils.h
View File

@@ -147,7 +147,7 @@ mr_inline mr_uint8_t mr_spi_read_reg(mr_device_t spi_device, mr_uint8_t reg)
#include <adc/adc.h>
mr_inline mr_err_t mr_adc_mode(mr_device_t adc, mr_uint16_t channel, mr_uint8_t state)
mr_inline mr_err_t mr_adc_mode(mr_device_t adc, mr_pos_t channel, mr_state_t state)
{
struct mr_adc_config config = {channel,
state};
@@ -169,7 +169,7 @@ mr_inline mr_uint16_t mr_adc_read(mr_device_t adc, mr_uint16_t channel)
#include <dac/dac.h>
mr_inline mr_err_t mr_dac_mode(mr_device_t dac, mr_uint16_t channel, mr_uint8_t state)
mr_inline mr_err_t mr_dac_mode(mr_device_t dac, mr_pos_t channel, mr_state_t state)
{
struct mr_dac_config config = {channel, state};

14
device/pin/pin.c
View File

@@ -38,7 +38,7 @@ static mr_err_t mr_pin_ioctl(mr_device_t device, int cmd, void *args)
}
}
static mr_ssize_t mr_pin_read(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size)
static mr_ssize_t mr_pin_read(mr_device_t device, mr_pos_t pos, void *buffer, mr_size_t size)
{
mr_pin_t pin = (mr_pin_t)device;
mr_uint8_t *recv_buffer = (mr_uint8_t *)buffer;
@@ -51,14 +51,14 @@ static mr_ssize_t mr_pin_read(mr_device_t device, mr_off_t pos, void *buffer, mr
for (recv_size = 0; recv_size < size; recv_size += sizeof(*recv_buffer))
{
*recv_buffer = pin->ops->read(pin, (mr_uint16_t)pos);
*recv_buffer = pin->ops->read(pin, pos);
recv_buffer++;
}
return (mr_ssize_t)recv_size;
}
static mr_ssize_t mr_pin_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size)
static mr_ssize_t mr_pin_write(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size)
{
mr_pin_t pin = (mr_pin_t)device;
mr_uint8_t *send_buffer = (mr_uint8_t *)buffer;
@@ -71,7 +71,7 @@ static mr_ssize_t mr_pin_write(mr_device_t device, mr_off_t pos, const void *buf
for (send_size = 0; send_size < size; send_size += sizeof(*send_buffer))
{
pin->ops->write(pin, (mr_uint16_t)pos, *send_buffer);
pin->ops->write(pin, pos, *send_buffer);
send_buffer++;
}
@@ -84,12 +84,12 @@ static mr_err_t _err_io_pin_configure(mr_pin_t pin, struct mr_pin_config *config
return -MR_ERR_IO;
}
static void _err_io_pin_write(mr_pin_t pin, mr_uint16_t number, mr_uint8_t value)
static void _err_io_pin_write(mr_pin_t pin, mr_pos_t number, mr_uint8_t value)
{
MR_ASSERT(0);
}
static mr_uint8_t _err_io_pin_read(mr_pin_t pin, mr_uint16_t number)
static mr_uint8_t _err_io_pin_read(mr_pin_t pin, mr_pos_t number)
{
MR_ASSERT(0);
return 0;
@@ -136,4 +136,4 @@ void mr_pin_device_isr(mr_pin_t pin, mr_uint32_t number)
}
}
#endif /* MR_CONF_PIN */
#endif /* MR_CONF_PIN */

20
device/pin/pin.h
View File

@@ -22,15 +22,15 @@
#define MR_PIN_MODE_INPUT_DOWN 4
#define MR_PIN_MODE_INPUT_UP 5
#define MR_PIN_MODE_RISING 6
#define MR_PIN_MODE_FALLING 7
#define MR_PIN_MODE_EDGE 8
#define MR_PIN_MODE_LOW 9
#define MR_PIN_MODE_HIGH 10
#define MR_PIN_MODE_IRQ_RISING 6
#define MR_PIN_MODE_IRQ_FALLING 7
#define MR_PIN_MODE_IRQ_EDGE 8
#define MR_PIN_MODE_IRQ_LOW 9
#define MR_PIN_MODE_IRQ_HIGH 10
struct mr_pin_config
{
mr_uint16_t number;
mr_pos_t number;
mr_uint8_t mode;
};
@@ -39,8 +39,8 @@ typedef struct mr_pin *mr_pin_t;
struct mr_pin_ops
{
mr_err_t (*configure)(mr_pin_t pin, struct mr_pin_config *config);
void (*write)(mr_pin_t pin, mr_uint16_t number, mr_uint8_t value);
mr_uint8_t (*read)(mr_pin_t pin, mr_uint16_t number);
void (*write)(mr_pin_t pin, mr_pos_t number, mr_uint8_t value);
mr_uint8_t (*read)(mr_pin_t pin, mr_pos_t number);
};
struct mr_pin
@@ -53,6 +53,6 @@ struct mr_pin
mr_err_t mr_pin_device_add(mr_pin_t pin, const char *name, void *data, struct mr_pin_ops *ops);
void mr_pin_device_isr(mr_pin_t pin, mr_uint32_t number);
#endif /* MR_CONF_PIN */
#endif /* MR_CONF_PIN */
#endif /* _PIN_H_ */
#endif /* _PIN_H_ */

14
device/pwm/pwm.c
View File

@@ -69,7 +69,7 @@ static mr_err_t mr_pwm_ioctl(mr_device_t device, int cmd, void *args)
}
}
static mr_err_t mr_pwm_read(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size)
static mr_err_t mr_pwm_read(mr_device_t device, mr_pos_t pos, void *buffer, mr_size_t size)
{
mr_pwm_t pwm = (mr_pwm_t)device;
mr_uint32_t *recv_buffer = (mr_uint32_t *)buffer;
@@ -82,14 +82,14 @@ static mr_err_t mr_pwm_read(mr_device_t device, mr_off_t pos, void *buffer, mr_s
for (recv_size = 0; recv_size < size; recv_size += sizeof(*recv_buffer))
{
*recv_buffer = pwm->ops->read(pwm, (mr_uint8_t)pos);
*recv_buffer = pwm->ops->read(pwm, pos);
recv_buffer++;
}
return (mr_ssize_t)recv_size;
}
static mr_err_t mr_pwm_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size)
static mr_err_t mr_pwm_write(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size)
{
mr_pwm_t pwm = (mr_pwm_t)device;
mr_uint32_t *send_buffer = (mr_uint32_t *)buffer;
@@ -102,7 +102,7 @@ static mr_err_t mr_pwm_write(mr_device_t device, mr_off_t pos, const void *buffe
for (send_size = 0; send_size < size; send_size += sizeof(*send_buffer))
{
pwm->ops->write(pwm, (mr_uint8_t)pos, *send_buffer);
pwm->ops->write(pwm, pos, *send_buffer);
send_buffer++;
}
@@ -115,13 +115,13 @@ static mr_err_t _err_io_pwm_configure(mr_pwm_t pwm, struct mr_pwm_config *config
return -MR_ERR_IO;
}
static mr_err_t _err_io_pwm_write(mr_pwm_t pwm, mr_uint8_t channel, mr_uint32_t duty)
static mr_err_t _err_io_pwm_write(mr_pwm_t pwm, mr_pos_t channel, mr_uint32_t duty)
{
MR_ASSERT(0);
return -MR_ERR_IO;
}
static mr_uint32_t _err_io_pwm_read(mr_pwm_t pwm, mr_uint8_t channel)
static mr_uint32_t _err_io_pwm_read(mr_pwm_t pwm, mr_pos_t channel)
{
MR_ASSERT(0);
return 0;
@@ -163,4 +163,4 @@ mr_err_t mr_pwm_device_add(mr_pwm_t pwm, const char *name, void *data, struct mr
return mr_device_add(&pwm->device, name, MR_OPEN_RDWR);
}
#endif /* MR_CONF_PWM */
#endif /* MR_CONF_PWM */

8
device/pwm/pwm.h
View File

@@ -37,8 +37,8 @@ typedef struct mr_pwm *mr_pwm_t;
struct mr_pwm_ops
{
mr_err_t (*configure)(mr_pwm_t pwm, struct mr_pwm_config *config);
mr_err_t (*write)(mr_pwm_t pwm, mr_uint8_t channel, mr_uint32_t duty);
mr_uint32_t (*read)(mr_pwm_t pwm, mr_uint8_t channel);
mr_err_t (*write)(mr_pwm_t pwm, mr_pos_t channel, mr_uint32_t duty);
mr_uint32_t (*read)(mr_pwm_t pwm, mr_pos_t channel);
};
struct mr_pwm
@@ -57,6 +57,6 @@ mr_err_t mr_pwm_device_add(mr_pwm_t pwm,
struct mr_pwm_ops *ops,
struct mr_pwm_info *info);
#endif /* MR_CONF_PWM */
#endif /* MR_CONF_PWM */
#endif /* _PWM_H_ */
#endif /* _PWM_H_ */

6
device/serial/serial.c
View File

@@ -172,7 +172,7 @@ static mr_err_t mr_serial_ioctl(mr_device_t device, int cmd, void *args)
}
}
static mr_ssize_t mr_serial_read(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size)
static mr_ssize_t mr_serial_read(mr_device_t device, mr_pos_t pos, void *buffer, mr_size_t size)
{
mr_serial_t serial = (mr_serial_t)device;
mr_uint8_t *recv_buffer = (mr_uint8_t *)buffer;
@@ -198,7 +198,7 @@ static mr_ssize_t mr_serial_read(mr_device_t device, mr_off_t pos, void *buffer,
return (mr_ssize_t)recv_size;
}
static mr_ssize_t mr_serial_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size)
static mr_ssize_t mr_serial_write(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size)
{
mr_serial_t serial = (mr_serial_t)device;
mr_uint8_t *send_buffer = (mr_uint8_t *)buffer;
@@ -406,4 +406,4 @@ void mr_serial_device_isr(mr_serial_t serial, mr_uint32_t event)
}
}
#endif /* MR_CONF_SERIAL */
#endif /* MR_CONF_SERIAL */

7
device/serial/serial.h
View File

@@ -38,9 +38,6 @@
#define MR_SERIAL_EVENT_TX_DMA 0x80000000
#define _MR_SERIAL_EVENT_MASK 0xf0000000
#define _MR_SERIAL_STATE_IDLE 0x00
#define _MR_SERIAL_STATE_RUNNING 0x10
/* Default config for mr_serial_config structure */
#define MR_SERIAL_CONFIG_DEFAULT \
{ \
@@ -101,6 +98,6 @@ struct mr_serial
mr_err_t mr_serial_device_add(mr_serial_t serial, const char *name, void *data, struct mr_serial_ops *ops);
void mr_serial_device_isr(mr_serial_t serial, mr_uint32_t event);
#endif /* MR_CONF_SERIAL */
#endif /* MR_CONF_SERIAL */
#endif /* _SERIAL_H_ */
#endif /* _SERIAL_H_ */

35
device/spi/spi.c
View File

@@ -12,7 +12,7 @@
#if (MR_CONF_PIN == MR_CONF_ENABLE)
#include "device/pin/pin.h"
#endif
#endif /* MR_CONF_PIN */
#if (MR_CONF_SPI == MR_CONF_ENABLE)
@@ -72,7 +72,7 @@ mr_inline mr_uint8_t mr_spi_bus_transfer(mr_spi_bus_t spi_bus, mr_uint8_t data)
return spi_bus->ops->read(spi_bus);
}
mr_inline mr_err_t mr_take_spi_bus(mr_spi_device_t spi_device)
mr_inline mr_err_t mr_spi_device_take_bus(mr_spi_device_t spi_device)
{
mr_err_t ret = MR_ERR_OK;
@@ -109,10 +109,11 @@ mr_inline mr_err_t mr_take_spi_bus(mr_spi_device_t spi_device)
spi_device->bus->config = spi_device->config;
spi_device->bus->owner = spi_device;
}
return MR_ERR_OK;
}
mr_inline mr_err_t mr_release_spi_bus(mr_spi_device_t spi_device)
mr_inline mr_err_t mr_spi_device_release_bus(mr_spi_device_t spi_device)
{
mr_err_t ret = MR_ERR_OK;
@@ -311,7 +312,7 @@ static mr_err_t mr_spi_device_ioctl(mr_device_t device, int cmd, void *args)
if (args)
{
/* Take spi-bus */
ret = mr_take_spi_bus(spi_device);
ret = mr_spi_device_take_bus(spi_device);
if (ret != MR_ERR_OK)
{
return ret;
@@ -333,7 +334,7 @@ static mr_err_t mr_spi_device_ioctl(mr_device_t device, int cmd, void *args)
} while (args != MR_NULL);
/* Release spi-bus */
mr_release_spi_bus(spi_device);
mr_spi_device_release_bus(spi_device);
return MR_ERR_OK;
}
return -MR_ERR_INVALID;
@@ -344,7 +345,7 @@ static mr_err_t mr_spi_device_ioctl(mr_device_t device, int cmd, void *args)
}
}
static mr_ssize_t mr_spi_device_read(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size)
static mr_ssize_t mr_spi_device_read(mr_device_t device, mr_pos_t pos, void *buffer, mr_size_t size)
{
mr_spi_device_t spi_device = (mr_spi_device_t)device;
mr_uint8_t *recv_buffer = (mr_uint8_t *)buffer;
@@ -353,7 +354,7 @@ static mr_ssize_t mr_spi_device_read(mr_device_t device, mr_off_t pos, void *buf
mr_err_t ret = MR_ERR_OK;
/* Take spi-bus */
ret = mr_take_spi_bus(spi_device);
ret = mr_spi_device_take_bus(spi_device);
if (ret != MR_ERR_OK)
{
return ret;
@@ -371,7 +372,7 @@ static mr_ssize_t mr_spi_device_read(mr_device_t device, mr_off_t pos, void *buf
mr_spi_bus_transfer(spi_bus, (mr_uint8_t)pos);
}
/* Host blocking read */
/* Blocking read */
for (recv_size = 0; recv_size < size; recv_size += sizeof(*recv_buffer))
{
*recv_buffer = mr_spi_bus_transfer(spi_bus, 0u);
@@ -401,12 +402,12 @@ static mr_ssize_t mr_spi_device_read(mr_device_t device, mr_off_t pos, void *buf
}
/* Release spi-bus */
mr_release_spi_bus(spi_device);
mr_spi_device_release_bus(spi_device);
return (mr_ssize_t)recv_size;
}
static mr_ssize_t mr_spi_device_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size)
static mr_ssize_t mr_spi_device_write(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size)
{
mr_spi_device_t spi_device = (mr_spi_device_t)device;
mr_uint8_t *send_buffer = (mr_uint8_t *)buffer;
@@ -417,7 +418,7 @@ static mr_ssize_t mr_spi_device_write(mr_device_t device, mr_off_t pos, const vo
mr_err_t ret = MR_ERR_OK;
/* Take spi-bus */
ret = mr_take_spi_bus(spi_device);
ret = mr_spi_device_take_bus(spi_device);
if (ret != MR_ERR_OK)
{
return ret;
@@ -506,7 +507,7 @@ static mr_ssize_t mr_spi_device_write(mr_device_t device, mr_off_t pos, const vo
}
/* Release spi-bus */
mr_release_spi_bus(spi_device);
mr_spi_device_release_bus(spi_device);
return (mr_ssize_t)send_size;
}
@@ -528,12 +529,12 @@ static mr_uint8_t _err_io_spi_read(mr_spi_bus_t spi_bus)
return 0;
}
static void _err_io_spi_cs_ctrl(mr_spi_bus_t spi_bus, mr_uint16_t cs_pin, mr_uint8_t state)
static void _err_io_spi_cs_ctrl(mr_spi_bus_t spi_bus, mr_pos_t cs_pin, mr_state_t state)
{
MR_ASSERT(0);
}
static mr_uint8_t _err_io_spi_cs_read(mr_spi_bus_t spi_bus, mr_uint16_t cs_pin)
static mr_uint8_t _err_io_spi_cs_read(mr_spi_bus_t spi_bus, mr_pos_t cs_pin)
{
MR_ASSERT(0);
return 0;
@@ -605,7 +606,7 @@ mr_err_t mr_spi_device_add(mr_spi_device_t spi_device, const char *name, mr_uint
#if (MR_CONF_PIN == MR_CONF_ENABLE)
struct mr_pin_config pin_config = {cs_pin, MR_PIN_MODE_OUTPUT};
mr_device_t pin = MR_NULL;
#endif /* MR_CONF_PIN */
#endif /* MR_CONF_PIN */
MR_ASSERT(spi_device != MR_NULL);
MR_ASSERT(name != MR_NULL);
@@ -630,7 +631,7 @@ mr_err_t mr_spi_device_add(mr_spi_device_t spi_device, const char *name, mr_uint
}
mr_device_open(pin, MR_OPEN_RDWR);
mr_device_ioctl(pin, MR_CTRL_CONFIG, &pin_config);
#endif /* MR_CONF_PIN */
#endif /* MR_CONF_PIN */
/* Add to the container */
return mr_device_add(&spi_device->device, name, MR_OPEN_RDWR | MR_OPEN_NONBLOCKING);
@@ -726,4 +727,4 @@ void mr_spi_bus_isr(mr_spi_bus_t spi_bus, mr_uint32_t event)
}
}
#endif /* MR_CONF_SPI */
#endif /* MR_CONF_SPI */

11
device/spi/spi.h
View File

@@ -36,9 +36,6 @@
#define MR_SPI_BUS_EVENT_TX_DMA 0x80000000
#define _MR_SPI_BUS_EVENT_MASK 0xf0000000
#define _MR_SPI_BUS_STATE_IDLE 0x00
#define _MR_SPI_BUS_STATE_RUNNING 0x10
/* Default config for mr_spi_config structure */
#define MR_SPI_CONFIG_DEFAULT \
{ \
@@ -84,9 +81,9 @@ struct mr_spi_bus_ops
mr_err_t (*configure)(mr_spi_bus_t spi_bus, struct mr_spi_config *config);
void (*write)(mr_spi_bus_t spi_bus, mr_uint8_t data);
mr_uint8_t (*read)(mr_spi_bus_t spi_bus);
void (*cs_ctrl)(mr_spi_bus_t spi_bus, mr_uint16_t cs_pin, mr_uint8_t state);
void (*cs_ctrl)(mr_spi_bus_t spi_bus, mr_pos_t cs_pin, mr_state_t state);
mr_uint8_t (*cs_read)(mr_spi_bus_t spi_bus, mr_uint16_t cs_pin);
mr_uint8_t (*cs_read)(mr_spi_bus_t spi_bus, mr_pos_t cs_pin);
void (*start_tx)(mr_spi_bus_t spi_bus);
void (*stop_tx)(mr_spi_bus_t spi_bus);
@@ -114,6 +111,6 @@ mr_err_t mr_spi_bus_add(mr_spi_bus_t spi_bus, const char *name, void *data, stru
mr_err_t mr_spi_device_add(mr_spi_device_t spi_device, const char *name, mr_uint16_t cs_pin);
void mr_spi_bus_isr(mr_spi_bus_t spi_bus, mr_uint32_t event);
#endif /* MR_CONF_SPI */
#endif /* MR_CONF_SPI */
#endif /* _SPI_H_ */
#endif /* _SPI_H_ */

14
device/timer/timer.c
View File

@@ -18,7 +18,7 @@ static mr_uint32_t mr_timer_timeout_calculate(mr_timer_t timer, mr_uint32_t time
mr_uint32_t i = 0, reload_min = 0, reload_max = 0, error = 0, error_min = 0, reload_best = 0;
/* Calculate the timer-period and timeout total count */
timer_period = 1000000 / timer->config.freq;
timer_period = 1000000u / timer->config.freq;
count = timeout / timer_period;
if (count == 0)
@@ -135,7 +135,7 @@ static mr_err_t mr_timer_ioctl(mr_device_t device, int cmd, void *args)
{
return -MR_ERR_INVALID;
}
timer->ops->start(timer, timer->timeout / (1000000 / timer->config.freq));
timer->ops->start(timer, timer->timeout / (1000000u / timer->config.freq));
return MR_ERR_OK;
}
@@ -144,7 +144,7 @@ static mr_err_t mr_timer_ioctl(mr_device_t device, int cmd, void *args)
}
}
static mr_ssize_t mr_timer_read(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size)
static mr_ssize_t mr_timer_read(mr_device_t device, mr_pos_t pos, void *buffer, mr_size_t size)
{
mr_timer_t timer = (mr_timer_t)device;
mr_uint32_t *recv_buffer = (mr_uint32_t *)buffer;
@@ -161,17 +161,17 @@ static mr_ssize_t mr_timer_read(mr_device_t device, mr_off_t pos, void *buffer,
cnt = timer->ops->get_count(timer);
if (timer->info.cnt_mode == _MR_TIMER_CNT_MODE_DOWN)
{
cnt = timer->timeout / (1000000 / timer->config.freq) - cnt;
cnt = timer->timeout / (1000000u / timer->config.freq) - cnt;
}
*recv_buffer = timer->overflow * timer->timeout + cnt * (1000000 / timer->config.freq);
*recv_buffer = timer->overflow * timer->timeout + cnt * (1000000u / timer->config.freq);
recv_buffer++;
}
return (mr_ssize_t)recv_size;
}
static mr_ssize_t mr_timer_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size)
static mr_ssize_t mr_timer_write(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size)
{
mr_timer_t timer = (mr_timer_t)device;
mr_uint32_t *send_buffer = (mr_uint32_t *)buffer;
@@ -308,4 +308,4 @@ void mr_timer_device_isr(mr_timer_t timer, mr_uint32_t event)
}
}
#endif /* MR_CONF_TIMER */
#endif /* MR_CONF_TIMER */

4
device/timer/timer.h
View File

@@ -76,6 +76,6 @@ mr_err_t mr_timer_device_add(mr_timer_t timer,
struct mr_timer_info *info);
void mr_timer_device_isr(mr_timer_t timer, mr_uint32_t event);
#endif /* MR_CONF_TIMER */
#endif /* MR_CONF_TIMER */
#endif /* _TIMER_H_ */
#endif /* _TIMER_H_ */

2
document/user/device/adc.md
View File

@@ -93,7 +93,7 @@ mr_device_ioctl(adc_device, MR_CTRL_CONFIG, &adc_config);
## 获取ADC通道值
```c
mr_ssize_t mr_device_read(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size);
mr_ssize_t mr_device_read(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size);
```
| 参数 | 描述 |

2
document/user/device/dac.md
View File

@@ -93,7 +93,7 @@ mr_device_ioctl(dac_device, MR_CTRL_CONFIG, &dac_config);
## 设置DAC通道值
```c
mr_ssize_t mr_device_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size);
mr_ssize_t mr_device_write(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size);
```
| 参数 | 描述 |

4
document/user/device/device.md
View File

@@ -67,8 +67,8 @@ 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_ssize_t (*sda_read)(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size);
mr_ssize_t (*write)(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size);
mr_ssize_t (*sda_read)(mr_device_t device, mr_pos_t pos, void *buffer, mr_size_t size);
mr_ssize_t (*write)(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size);
};
```

4
document/user/device/pin.md
View File

@@ -119,7 +119,7 @@ mr_device_ioctl(pin_device, MR_CTRL_CONFIG, &pin_config);
## 设置引脚电平
```c
mr_ssize_t mr_device_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size);
mr_ssize_t mr_device_write(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size);
```
| 参数 | 描述 |
@@ -144,7 +144,7 @@ mr_device_write(pin_device, 29, &pin_level, sizeof(pin_level));
## 获取引脚电平
```c
mr_ssize_t mr_device_read(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size);
mr_ssize_t mr_device_read(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size);
```
| 参数 | 描述 |

8
include/mrdef.h
View File

@@ -142,10 +142,10 @@ typedef unsigned int mr_ubase_t; /* Type for
typedef mr_ubase_t mr_size_t; /* Type for size number */
typedef mr_base_t mr_ssize_t; /* Type for signed size number */
typedef mr_base_t mr_err_t; /* Type for error number */
typedef mr_base_t mr_off_t; /* Type for offset */
typedef mr_base_t mr_pos_t; /* Type for position */
typedef mr_int8_t mr_bool_t; /* Type for boolean */
typedef mr_int8_t mr_level_t; /* Type for level */
typedef mr_int8_t mr_state_t; /* Type for state */
typedef mr_uint8_t mr_state_t; /* Type for state */
typedef mr_int8_t mr_lock_t; /* Type for lock */
/**
@@ -280,8 +280,8 @@ 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_ssize_t (*read)(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size);
mr_ssize_t (*write)(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size);
mr_ssize_t (*read)(mr_device_t device, mr_pos_t pos, void *buffer, mr_size_t size);
mr_ssize_t (*write)(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size);
};
struct mr_device

5
include/mrlib.h
View File

@@ -37,8 +37,8 @@ mr_err_t mr_device_add(mr_device_t device, const char *name, mr_uint16_t flags);
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_ssize_t mr_device_read(mr_device_t device, mr_off_t pos, void *buffer, mr_size_t size);
mr_ssize_t mr_device_write(mr_device_t device, mr_off_t pos, const void *buffer, mr_size_t size);
mr_ssize_t mr_device_read(mr_device_t device, mr_pos_t pos, void *buffer, mr_size_t size);
mr_ssize_t mr_device_write(mr_device_t device, mr_pos_t pos, const void *buffer, mr_size_t size);
#endif /* MR_CONF_DEVICE */
#if (MR_CONF_EVENT == MR_CONF_ENABLE)
@@ -113,6 +113,7 @@ void mr_log_output(mr_base_t level, const char *tag, const char *format, ...);
void mr_assert_handle(void);
void mr_interrupt_disable(void);
void mr_interrupt_enable(void);
void mr_delay_us(mr_uint32_t us);
void mr_delay_ms(mr_uint32_t ms);
/**

1
package/soft_i2c/soft_i2c.h
View File

@@ -17,6 +17,7 @@
#define I2C_DELAY 100
typedef struct i2c_bus *i2c_bus_t;
struct i2c_device
{
uint8_t addr;

4
src/kernel.c
View File

@@ -78,7 +78,7 @@ mr_object_t mr_object_find(const char *name, mr_uint8_t type)
mr_interrupt_disable();
/* Walk through the container looking for objects */
for (list = (container->list).next; list != &(container->list); list = list->next)
for (list = container->list.next; list != &container->list; list = list->next)
{
object = mr_container_of(list, struct mr_object, list);
if (mr_strncmp(object->name, name, MR_CONF_NAME_MAX) == 0)
@@ -133,7 +133,7 @@ mr_err_t mr_object_add(mr_object_t object, const char *name, mr_uint8_t type)
mr_interrupt_disable();
/* Insert the object into the container's list */
mr_list_insert_after(&(container->list), &(object->list));
mr_list_insert_before(&(container->list), &(object->list));
/* Enable interrupt */
mr_interrupt_enable();

15
src/kservice.c
View File

@@ -27,11 +27,11 @@ static int start(void)
}
AUTO_INIT_EXPORT(start, "0");
static int driver_state(void)
static int driver_start(void)
{
return 0;
}
AUTO_INIT_EXPORT(driver_state, "0.end");
AUTO_INIT_EXPORT(driver_start, "0.end");
static int driver_end(void)
{
@@ -133,16 +133,21 @@ mr_weak void mr_interrupt_enable(void)
}
mr_weak void mr_delay_ms(mr_uint32_t ms)
mr_weak void mr_delay_us(mr_size_t us)
{
volatile mr_size_t count = 0;
for (count = 0; count < ms * BSP_SYSCLK_FREQ / 1000;)
for (count = 0; count < us * (BSP_SYSCLK_FREQ / 1000000u); count++)
{
count++;
asm("nop");
}
}
mr_weak void mr_delay_ms(mr_size_t ms)
{
mr_delay_us(ms * 1000u);
}
/**
* @brief This function initialize the fifo.
*