1 /*
2 * This file is part of the MicroPython project, http://micropython.org/
3 *
4 * The MIT License (MIT)
5 *
6 * Copyright (c) 2019 Damien P. George
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 * THE SOFTWARE.
25 */
26
27 #include "py/runtime.h"
28 #include "py/mphal.h"
29 #include "py/mperrno.h"
30 #include "extmod/machine_i2c.h"
31 #include "modmachine.h"
32
33 #include "aos_hal_i2c.h"
34 #include "ulog/ulog.h"
35
36 #if MICROPY_PY_MACHINE
37
38 #define LOG_TAG "machine_hw_i2c"
39
40 typedef enum{
41 I2C_NUM_0 = 0, /*!< I2C port 0 */
42 I2C_NUM_1 , /*!< I2C port 1 */
43 I2C_NUM_MAX
44 } i2c_port_t;
45
46 #define I2C_0_DEFAULT_SCL (18)
47 #define I2C_0_DEFAULT_SDA (19)
48
49 #define I2C_1_DEFAULT_SCL (20)
50 #define I2C_1_DEFAULT_SDA (21)
51
52 #define I2C_DEFAULT_TIMEOUT_US (1000 * 10) // 10ms
53
54 typedef struct _machine_hw_i2c_obj_t {
55 mp_obj_base_t base;
56 uint16_t port : 8;
57 uint16_t scl : 8;
58 uint16_t sda : 8;
59 i2c_dev_t dev;
60 uint32_t timeout;
61 } machine_hw_i2c_obj_t;
62
63 STATIC machine_hw_i2c_obj_t machine_hw_i2c_obj[I2C_NUM_MAX];
64
machine_hw_i2c_transfer(mp_obj_base_t * self_in,uint16_t addr,size_t n,mp_machine_i2c_buf_t * bufs,unsigned int flags)65 int machine_hw_i2c_transfer(mp_obj_base_t *self_in, uint16_t addr, size_t n, mp_machine_i2c_buf_t *bufs, unsigned int flags) {
66 machine_hw_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
67 i2c_dev_t *dev = &self->dev;
68 int32_t ret = -1;
69 uint32_t timeout = self->timeout;
70 uint8_t mode = dev->config.mode;
71
72 int data_len = 0;
73 for (; n--; ++bufs) {
74 if (flags & MP_MACHINE_I2C_FLAG_READ) {
75 if(mode == I2C_MODE_MASTER) {
76 ret = aos_hal_i2c_master_recv(dev, addr, bufs->buf, bufs->len, timeout);
77 for(int k=0; k<bufs->len; k++) {
78 LOGD(LOG_TAG, "data = 0x%2x\n", bufs->buf[k]);
79 }
80 } else {
81 ret = aos_hal_i2c_slave_recv(dev, bufs->buf, bufs->len, timeout);
82 }
83 } else {
84 if (bufs->len != 0) {
85 for(int k=0; k<bufs->len; k++) {
86 LOGD(LOG_TAG, "data = 0x%2x\n", bufs->buf[k]);
87 }
88 if(mode == I2C_MODE_MASTER) {
89 ret = aos_hal_i2c_master_send(dev, addr, bufs->buf, bufs->len, timeout);
90 } else {
91 ret = aos_hal_i2c_slave_send(dev, bufs->buf, bufs->len, timeout);
92 }
93 }
94 }
95
96 if (ret != 0) {
97 LOGE(LOG_TAG, "machine_hw_i2c_transfer fail, ret = %d\n", ret);
98 goto fail;
99 }
100
101 data_len += bufs->len;
102 }
103 return data_len;
104
105 fail:
106 return ret;
107 }
108
109 /******************************************************************************/
110 // MicroPython bindings for machine API
111
machine_hw_i2c_print(const mp_print_t * print,mp_obj_t self_in,mp_print_kind_t kind)112 STATIC void machine_hw_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
113 machine_hw_i2c_obj_t *self = MP_OBJ_TO_PTR(self_in);
114 i2c_dev_t *dev = &self->dev;
115
116 mp_printf(print, "I2C(port=%u, scl=%u, sda=%u, freq=%u, addr_width=%u, dev_addr=%u, mode=%u)",
117 self->port, self->scl, self->sda, dev->config.freq, dev->config.address_width,
118 dev->config.dev_addr, dev->config.mode);
119 }
120
machine_hw_i2c_init(machine_hw_i2c_obj_t * self,bool first_init)121 STATIC int32_t machine_hw_i2c_init(machine_hw_i2c_obj_t *self, bool first_init) {
122 i2c_dev_t *dev = &self->dev;
123 int32_t ret = -1;
124 if (!first_init) {
125 ret = aos_hal_i2c_finalize(self->port);
126 if(ret != 0) {
127 LOGE(LOG_TAG, "aos_hal_i2c_finalize fail, ret = %d\n", ret);
128 return ret;
129 }
130 }
131
132 ret = aos_hal_i2c_init(dev);
133 if(ret != 0) {
134 LOGE(LOG_TAG, "aos_hal_i2c_finalize fail, ret = %d\n", ret);
135 }
136 return ret;
137 }
138
machine_hw_i2c_make_new(const mp_obj_type_t * type,size_t n_args,size_t n_kw,const mp_obj_t * all_args)139 mp_obj_t machine_hw_i2c_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
140 // MP_MACHINE_I2C_CHECK_FOR_LEGACY_SOFTI2C_CONSTRUCTION(n_args, n_kw, all_args);
141
142 // Parse args
143 enum { ARG_id, ARG_scl, ARG_sda, ARG_freq, ARG_timeout, ARG_mode, ARG_addr, ARG_addrsize};
144 static const mp_arg_t allowed_args[] = {
145 { MP_QSTR_id, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
146 { MP_QSTR_scl, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
147 { MP_QSTR_sda, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
148 { MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = I2C_BUS_BIT_RATES_400K} },
149 { MP_QSTR_timeout, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = I2C_DEFAULT_TIMEOUT_US} },
150 { MP_QSTR_mode, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = I2C_MODE_MASTER} },
151 { MP_QSTR_addr, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = I2C_NUM_0} },
152 { MP_QSTR_addrsize, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = I2C_HAL_ADDRESS_WIDTH_7BIT} },
153
154 };
155 mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
156 mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
157
158 // Get I2C bus
159 mp_int_t port = mp_obj_get_int(args[ARG_id].u_obj);
160 if (!(I2C_NUM_0 <= port && port < I2C_NUM_MAX)) {
161 mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("I2C(%d) doesn't exist"), port);
162 }
163
164 // Get static peripheral object
165 machine_hw_i2c_obj_t *self = (machine_hw_i2c_obj_t *)&machine_hw_i2c_obj[port];
166
167 bool first_init = false;
168 if (self->base.type == NULL) {
169 // Created for the first time, set default pins
170 self->base.type = &machine_hw_i2c_type;
171 self->port = port;
172 if (self->port == I2C_NUM_0) {
173 self->scl = I2C_0_DEFAULT_SCL;
174 self->sda = I2C_0_DEFAULT_SDA;
175 } else {
176 self->scl = I2C_1_DEFAULT_SCL;
177 self->sda = I2C_1_DEFAULT_SDA;
178 }
179 first_init = true;
180 }
181
182 // Set SCL/SDA pins if given
183 if (args[ARG_scl].u_obj != MP_OBJ_NULL) {
184 self->scl = mp_hal_get_pin_obj(args[ARG_scl].u_obj);
185 }
186 if (args[ARG_sda].u_obj != MP_OBJ_NULL) {
187 self->sda = mp_hal_get_pin_obj(args[ARG_sda].u_obj);
188 }
189
190 // Set Address width if given
191 mp_int_t addr_width = args[ARG_addrsize].u_int;
192
193 // Set freq if given
194 mp_int_t freq = addr_width = args[ARG_freq].u_int;
195
196 // Set timeout if given
197 mp_int_t timeout = args[ARG_timeout].u_int;
198
199 // Set mode if given
200 mp_int_t mode = args[ARG_mode].u_int;
201
202 // Set addr if given
203 mp_int_t addr = args[ARG_addr].u_int;
204
205 i2c_dev_t *dev = &self->dev;
206 dev->port = port;
207 dev->config.address_width = addr_width;
208 dev->config.freq = freq;
209 dev->config.mode = mode;
210 dev->config.dev_addr = addr;
211 dev->priv = NULL;
212
213 self->timeout = timeout;
214
215 // Initialise the I2C peripheral
216 machine_hw_i2c_init(self, first_init);
217
218 return MP_OBJ_FROM_PTR(self);
219 }
220
221 STATIC const mp_machine_i2c_p_t machine_hw_i2c_p = {
222 .transfer = machine_hw_i2c_transfer,
223 };
224
225 const mp_obj_type_t machine_hw_i2c_type = {
226 { &mp_type_type },
227 .name = MP_QSTR_I2C,
228 .print = machine_hw_i2c_print,
229 .make_new = machine_hw_i2c_make_new,
230 .protocol = &machine_hw_i2c_p,
231 .locals_dict = (mp_obj_dict_t *)&mp_machine_i2c_locals_dict,
232 };
233
234 #endif