Lerking/micropython
1
0
Fork 0
mirror of https://github.com/micropython/micropython.git synced 2025-12-16 01:40:14 +01:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

alif/machine_i2c: Add machine.I2C peripheral support.

Browse Source 
Signed-off-by: iabdalkader <i.abdalkader@gmail.com>
This commit is contained in:
iabdalkader
2025-01-02 06:29:05 +01:00
committed by Damien George
parent 82bae652eb
commit 9073270c2e
3 changed files with 305 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ports/alif/alif.mk
View File

@@ -117,6 +117,7 @@ SRC_C = \
alif_flash.c \
fatfs_port.c \
machine_pin.c \
machine_i2c.c \
main.c \
modalif.c \
mphalport.c \
@@ -186,6 +187,7 @@ ALIF_SRC_C += $(addprefix $(ALIF_DFP_REL_TOP)/,\
Device/common/source/pm.c \
Device/core/$(MCU_CORE)/source/startup_$(MCU_CORE).c \
drivers/source/adc.c \
drivers/source/i2c.c \
drivers/source/mhu_driver.c \
drivers/source/mhu_receiver.c \
drivers/source/mhu_sender.c \

301
ports/alif/machine_i2c.c Normal file
View File

@@ -0,0 +1,301 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2024-2025 OpenMV LLC.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "py/runtime.h"
#include "py/mphal.h"
#include "py/mperrno.h"
#include "extmod/modmachine.h"
#if MICROPY_HW_ENABLE_HW_I2C
#include "i2c.h"
#define I2C_DEFAULT_FREQ (400000)
#define I2C_DEFAULT_TIMEOUT (50000)
#define I2C_DAT_INDEX (0)
#define I2C_TX_FIFO_LEN (I2C_FIFO_DEPTH / 2)
#define I2C_RX_FIFO_LEN (I2C_FIFO_DEPTH / 2)
#define I2C_SPEED(freq) \
((freq) <= 100000 ? I2C_SPEED_STANDARD : \
((freq) <= 400000 ? I2C_SPEED_FAST : \
I2C_SPEED_FASTPLUS))
#define I2C_IC_CON_SPEED(freq) \
((freq) <= 100000 ? I2C_IC_CON_SPEED_STANDARD : \
((freq) <= 400000 ? I2C_IC_CON_SPEED_FAST : \
I2C_IC_CON_SPEED_HIGH))
#define I2C_IC_CON_MASTER_TX_EMPTY_CTRL (1 << 8)
#define I2C_IC_STATUS_RFNE I2C_IC_STATUS_RECEIVE_FIFO_NOT_EMPTY
#define I2C_IC_STATUS_TFNF I2C_IC_STATUS_TRANSMIT_FIFO_NOT_FULL
#define I2C_STAT_ERRORS (I2C_IC_INTR_STAT_TX_ABRT | I2C_IC_INTR_STAT_TX_OVER | \
I2C_IC_INTR_STAT_RX_OVER | I2C_IC_INTR_STAT_RX_UNDER)
#define debug_printf(...) // mp_printf(&mp_plat_print, "i2c.c: " __VA_ARGS__)
#define I2C_CHECK_ERRORS(base) \
if (base->I2C_RAW_INTR_STAT & I2C_STAT_ERRORS) { \
uint32_t status = base->I2C_RAW_INTR_STAT; \
debug_printf("status: 0x%lx raw_int: 0x%lx abort: 0x%lx line: %d\n", \
base->I2C_STATUS, status, base->I2C_TX_ABRT_SOURCE, __LINE__); \
(void)status; \
(void)base->I2C_CLR_TX_ABRT; \
(void)base->I2C_CLR_ACTIVITY; \
return -MP_EIO; \
}
typedef struct _machine_i2c_obj_t {
mp_obj_base_t base;
uint32_t i2c_id;
I2C_Type *i2c;
mp_hal_pin_obj_t scl;
mp_hal_pin_obj_t sda;
uint32_t freq;
uint32_t timeout;
} machine_i2c_obj_t;
static machine_i2c_obj_t machine_i2c_obj[] = {
#if defined(MICROPY_HW_I2C0_SCL)
[0] = {{&machine_i2c_type}, 0, (I2C_Type *)I2C0_BASE, MICROPY_HW_I2C0_SCL, MICROPY_HW_I2C0_SDA},
#endif
#if defined(MICROPY_HW_I2C1_SCL)
[1] = {{&machine_i2c_type}, 1, (I2C_Type *)I2C1_BASE, MICROPY_HW_I2C1_SCL, MICROPY_HW_I2C1_SDA},
#endif
#if defined(MICROPY_HW_I2C2_SCL)
[2] = {{&machine_i2c_type}, 2, (I2C_Type *)I2C2_BASE, MICROPY_HW_I2C2_SCL, MICROPY_HW_I2C2_SDA},
#endif
#if defined(MICROPY_HW_I2C3_SCL)
[3] = {{&machine_i2c_type}, 3, (I2C_Type *)I2C3_BASE, MICROPY_HW_I2C3_SCL, MICROPY_HW_I2C3_SDA},
#endif
};
static void machine_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
machine_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "I2C(%u, freq=%u, scl=%q, sda=%q, timeout=%u)",
self->i2c_id, self->freq, self->scl->name, self->sda->name, self->timeout);
}
mp_obj_t machine_i2c_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
enum { ARG_id, ARG_freq, ARG_scl, ARG_sda, ARG_timeout };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_id, MP_ARG_REQUIRED | MP_ARG_OBJ },
{ MP_QSTR_freq, MP_ARG_INT, {.u_int = I2C_DEFAULT_FREQ} },
{ MP_QSTR_scl, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
{ MP_QSTR_sda, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_NONE} },
{ MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = I2C_DEFAULT_TIMEOUT} },
};
// Parse args.
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
// Get I2C bus.
int i2c_id = mp_obj_get_int(args[ARG_id].u_obj);
if (i2c_id < 0 || i2c_id >= MP_ARRAY_SIZE(machine_i2c_obj) || !machine_i2c_obj[i2c_id].i2c) {
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("I2C(%d) doesn't exist"), i2c_id);
}
// Get static peripheral object.
machine_i2c_obj_t *self = &machine_i2c_obj[i2c_id];
// Set args
self->freq = args[ARG_freq].u_int;
self->timeout = args[ARG_timeout].u_int;
// here we would check the scl/sda pins and configure them, but it's not implemented
if (args[ARG_scl].u_obj != mp_const_none || args[ARG_sda].u_obj != mp_const_none) {
mp_raise_ValueError(MP_ERROR_TEXT("explicit choice of scl/sda is not implemented"));
}
// Disable I2C controller.
i2c_disable(self->i2c);
// Configure I2C pins.
mp_hal_pin_config(self->scl, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP,
MP_HAL_PIN_SPEED_LOW, MP_HAL_PIN_DRIVE_8MA, MP_HAL_PIN_ALT_I2C, true);
mp_hal_pin_config(self->sda, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP,
MP_HAL_PIN_SPEED_LOW, MP_HAL_PIN_DRIVE_8MA, MP_HAL_PIN_ALT_I2C, true);
// Initialize I2C controller.
self->i2c->I2C_CON = I2C_IC_CON_ENABLE_MASTER_MODE |
I2C_IC_CON_MASTER_RESTART_EN |
I2C_IC_CON_MASTER_TX_EMPTY_CTRL |
I2C_IC_CON_SPEED(self->freq);
// Configure FIFO threshold.
self->i2c->I2C_TX_TL = I2C_TX_FIFO_LEN;
self->i2c->I2C_RX_TL = I2C_RX_FIFO_LEN;
// Configure clock.
i2c_master_set_clock(self->i2c, GetSystemAPBClock() / 1000, I2C_SPEED(self->freq));
// Enable I2C controller.
i2c_clear_all_interrupt(self->i2c);
i2c_enable(self->i2c);
return MP_OBJ_FROM_PTR(self);
}
static int machine_i2c_poll_flags(I2C_Type *base, uint32_t flags, uint32_t timeout_us) {
mp_uint_t tick_start = mp_hal_ticks_us();
while (!(base->I2C_STATUS & flags)) {
I2C_CHECK_ERRORS(base);
if ((mp_hal_ticks_us() - tick_start) >= timeout_us) {
return -MP_ETIMEDOUT;
}
// Can't delay or handle pending events here otherwise we risk
// the FIFO getting empty, which will generate a STOP condition.
}
return 0;
}
static int machine_i2c_write(machine_i2c_obj_t *self, uint8_t *buf, size_t tx_size) {
mp_uint_t tick_start = mp_hal_ticks_us();
for (size_t tx_idx = 0; tx_idx < tx_size;) {
// Write data to FIFO
if (self->i2c->I2C_STATUS & I2C_IC_STATUS_TFNF) {
self->i2c->I2C_DATA_CMD = (uint16_t)buf[tx_idx++];
I2C_CHECK_ERRORS(self->i2c);
tick_start = mp_hal_ticks_us();
}
// Check for timeout
if ((mp_hal_ticks_us() - tick_start) >= self->timeout) {
return -MP_ETIMEDOUT;
}
}
return 0;
}
static int machine_i2c_read(machine_i2c_obj_t *self, uint8_t *buf, size_t rx_size) {
mp_uint_t tick_start = mp_hal_ticks_us();
for (size_t tx_idx = 0, rx_idx = 0; rx_idx < rx_size;) {
// Write command to FIFO
if (tx_idx < rx_size && (self->i2c->I2C_STATUS & I2C_IC_STATUS_TFNF)) {
self->i2c->I2C_DATA_CMD = I2C_IC_DATA_CMD_READ_REQ;
I2C_CHECK_ERRORS(self->i2c);
++tx_idx;
}
// Read data from FIFO
while (rx_idx < rx_size && (self->i2c->I2C_STATUS & I2C_IC_STATUS_RFNE)) {
buf[rx_idx++] = self->i2c->I2C_DATA_CMD & 0xFF;
tick_start = mp_hal_ticks_us();
}
// Check for timeout
if ((mp_hal_ticks_us() - tick_start) >= self->timeout) {
return -MP_ETIMEDOUT;
}
}
return 0;
}
int machine_i2c_transfer(mp_obj_base_t *self_in, uint16_t addr, size_t n, mp_machine_i2c_buf_t *bufs, unsigned int flags) {
int ret = 0;
uint32_t bytes = 0;
machine_i2c_obj_t *self = (machine_i2c_obj_t *)self_in;
// The DesignWare I2C IP on AE3 is configured such that it auto-generates a STOP
// condition when the TX FIFO gets empty. In other words, the code can't have any
// control over STOP condition generation. The only fix for this would be to buffer
// complete read/write sequences and send them out when the STOP flag is set.
if (!(flags & MP_MACHINE_I2C_FLAG_STOP)) {
mp_raise_ValueError(MP_ERROR_TEXT("nostop flag is not supported"));
}
i2c_clear_all_interrupt(self->i2c);
i2c_set_target_addr(self->i2c, addr, I2C_7BIT_ADDRESS, 0);
// Workaround issue with hardware I2C not accepting zero-length writes.
if (!bufs->len) {
mp_machine_i2c_buf_t bufs = { 0 };
mp_machine_soft_i2c_obj_t soft_i2c = {
.base = { &mp_machine_soft_i2c_type },
.scl = self->scl,
.sda = self->sda,
.us_timeout = self->timeout,
.us_delay = 500000 / self->freq + 1,
};
// Switch pins to GPIO/OD.
mp_hal_pin_config(self->scl, MP_HAL_PIN_MODE_OPEN_DRAIN, MP_HAL_PIN_PULL_UP,
MP_HAL_PIN_SPEED_LOW, MP_HAL_PIN_DRIVE_8MA, MP_HAL_PIN_ALT_NONE, true);
mp_hal_pin_config(self->sda, MP_HAL_PIN_MODE_OPEN_DRAIN, MP_HAL_PIN_PULL_UP,
MP_HAL_PIN_SPEED_LOW, MP_HAL_PIN_DRIVE_8MA, MP_HAL_PIN_ALT_NONE, true);
// Perform the transfer.
ret = mp_machine_soft_i2c_transfer(&soft_i2c.base, addr, 1, &bufs, flags);
// Re-configure I2C pins.
mp_hal_pin_config(self->scl, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP,
MP_HAL_PIN_SPEED_LOW, MP_HAL_PIN_DRIVE_8MA, MP_HAL_PIN_ALT_I2C, true);
mp_hal_pin_config(self->sda, MP_HAL_PIN_MODE_ALT, MP_HAL_PIN_PULL_UP,
MP_HAL_PIN_SPEED_LOW, MP_HAL_PIN_DRIVE_8MA, MP_HAL_PIN_ALT_I2C, true);
return ret;
}
for (size_t i = 0; i < n; i++) {
mp_machine_i2c_buf_t *buf = &bufs[i];
if (i == 0 && (flags & MP_MACHINE_I2C_FLAG_WRITE1)) {
ret = machine_i2c_write(self, buf->buf, buf->len);
} else if (flags & MP_MACHINE_I2C_FLAG_READ) {
ret = machine_i2c_read(self, buf->buf, buf->len);
} else if (bufs->len != 0) {
ret = machine_i2c_write(self, buf->buf, buf->len);
}
if (ret < 0) {
return ret;
}
bytes += bufs->len;
}
// Wait for TX FIFO empty
ret = machine_i2c_poll_flags(self->i2c, I2C_IC_STATUS_TFE, self->timeout);
if (ret < 0) {
return ret;
}
return bytes;
}
static const mp_machine_i2c_p_t machine_i2c_p = {
.transfer_supports_write1 = true,
.transfer = machine_i2c_transfer,
};
MP_DEFINE_CONST_OBJ_TYPE(
machine_i2c_type,
MP_QSTR_I2C,
MP_TYPE_FLAG_NONE,
make_new, machine_i2c_make_new,
print, machine_i2c_print,
protocol, &machine_i2c_p,
locals_dict, &mp_machine_i2c_locals_dict
);
#endif // MICROPY_HW_ENABLE_HW_I2C

2
ports/alif/mpconfigport.h
View File

@@ -130,6 +130,8 @@
#define MICROPY_PY_MACHINE_ADC_INCLUDEFILE "ports/alif/machine_adc.c"
#define MICROPY_PY_MACHINE_DHT_READINTO (1)
#define MICROPY_PY_MACHINE_PULSE (1)
#define MICROPY_PY_MACHINE_I2C (MICROPY_HW_ENABLE_HW_I2C)
#define MICROPY_PY_MACHINE_I2C_TRANSFER_WRITE1 (1)
#define MICROPY_PY_MACHINE_SOFTI2C (1)
#define MICROPY_PY_MACHINE_SOFTSPI (1)
#define MICROPY_PY_MACHINE_TIMER (1)