Zephyr API Documentation 4.1.99
A Scalable Open Source RTOS
 4.1.99
All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
i2c.h
Go to the documentation of this file.
1
7/*
8 * Copyright (c) 2015 Intel Corporation
9 *
10 * SPDX-License-Identifier: Apache-2.0
11 */
12#ifndef ZEPHYR_INCLUDE_DRIVERS_I2C_H_
13#define ZEPHYR_INCLUDE_DRIVERS_I2C_H_
14
24#include <errno.h>
25
26#include <zephyr/types.h>
27#include <zephyr/device.h>
28#include <zephyr/kernel.h>
29#include <zephyr/sys/slist.h>
30#include <zephyr/rtio/rtio.h>
31
32#ifdef __cplusplus
33extern "C" {
34#endif
35
36/*
37 * The following #defines are used to configure the I2C controller.
38 */
39
41#define I2C_SPEED_STANDARD (0x1U)
42
44#define I2C_SPEED_FAST (0x2U)
45
47#define I2C_SPEED_FAST_PLUS (0x3U)
48
50#define I2C_SPEED_HIGH (0x4U)
51
53#define I2C_SPEED_ULTRA (0x5U)
54
56#define I2C_SPEED_DT (0x7U)
57
58#define I2C_SPEED_SHIFT (1U)
59#define I2C_SPEED_SET(speed) (((speed) << I2C_SPEED_SHIFT) \
60 & I2C_SPEED_MASK)
61#define I2C_SPEED_MASK (0x7U << I2C_SPEED_SHIFT) /* 3 bits */
62#define I2C_SPEED_GET(cfg) (((cfg) & I2C_SPEED_MASK) \
63 >> I2C_SPEED_SHIFT)
64
66#define I2C_ADDR_10_BITS BIT(0)
67
69#define I2C_MODE_CONTROLLER BIT(4)
70
78 const struct device *bus;
80};
81
92#define I2C_DT_SPEC_GET_ON_I3C(node_id) \
93 .bus = DEVICE_DT_GET(DT_BUS(node_id)), \
94 .addr = DT_PROP_BY_IDX(node_id, reg, 0)
95
106#define I2C_DT_SPEC_GET_ON_I2C(node_id) \
107 .bus = DEVICE_DT_GET(DT_BUS(node_id)), \
108 .addr = DT_REG_ADDR(node_id)
109
120#define I2C_DT_SPEC_GET(node_id) \
121 { \
122 COND_CODE_1(DT_ON_BUS(node_id, i3c), \
123 (I2C_DT_SPEC_GET_ON_I3C(node_id)), \
124 (I2C_DT_SPEC_GET_ON_I2C(node_id))) \
125 }
126
135#define I2C_DT_SPEC_INST_GET(inst) \
136 I2C_DT_SPEC_GET(DT_DRV_INST(inst))
137
138
139/*
140 * I2C_MSG_* are I2C Message flags.
141 */
142
144#define I2C_MSG_WRITE (0U << 0U)
145
147#define I2C_MSG_READ BIT(0)
148
150#define I2C_MSG_RW_MASK BIT(0)
154#define I2C_MSG_STOP BIT(1)
155
163#define I2C_MSG_RESTART BIT(2)
164
168#define I2C_MSG_ADDR_10_BITS BIT(3)
169
194
202typedef void (*i2c_callback_t)(const struct device *dev, int result, void *data);
203
210struct i2c_target_config;
211
212typedef int (*i2c_api_configure_t)(const struct device *dev,
213 uint32_t dev_config);
214typedef int (*i2c_api_get_config_t)(const struct device *dev,
215 uint32_t *dev_config);
216typedef int (*i2c_api_full_io_t)(const struct device *dev,
217 struct i2c_msg *msgs,
218 uint8_t num_msgs,
219 uint16_t addr);
220typedef int (*i2c_api_target_register_t)(const struct device *dev,
221 struct i2c_target_config *cfg);
222typedef int (*i2c_api_target_unregister_t)(const struct device *dev,
223 struct i2c_target_config *cfg);
224#ifdef CONFIG_I2C_CALLBACK
225typedef int (*i2c_api_transfer_cb_t)(const struct device *dev,
226 struct i2c_msg *msgs,
227 uint8_t num_msgs,
228 uint16_t addr,
230 void *userdata);
231#endif /* CONFIG_I2C_CALLBACK */
232#if defined(CONFIG_I2C_RTIO) || defined(__DOXYGEN__)
233
238typedef void (*i2c_api_iodev_submit)(const struct device *dev,
239 struct rtio_iodev_sqe *iodev_sqe);
240#endif /* CONFIG_I2C_RTIO */
241
242typedef int (*i2c_api_recover_bus_t)(const struct device *dev);
243
244__subsystem struct i2c_driver_api {
245 i2c_api_configure_t configure;
246 i2c_api_get_config_t get_config;
247 i2c_api_full_io_t transfer;
248 i2c_api_target_register_t target_register;
249 i2c_api_target_unregister_t target_unregister;
250#ifdef CONFIG_I2C_CALLBACK
251 i2c_api_transfer_cb_t transfer_cb;
252#endif
253#ifdef CONFIG_I2C_RTIO
254 i2c_api_iodev_submit iodev_submit;
255#endif
256 i2c_api_recover_bus_t recover_bus;
257};
258
259typedef int (*i2c_target_api_register_t)(const struct device *dev);
260typedef int (*i2c_target_api_unregister_t)(const struct device *dev);
261
262__subsystem struct i2c_target_driver_api {
263 i2c_target_api_register_t driver_register;
264 i2c_target_api_unregister_t driver_unregister;
265};
266
272#define I2C_TARGET_FLAGS_ADDR_10_BITS BIT(0)
273
290 struct i2c_target_config *config);
291
311 struct i2c_target_config *config, uint8_t val);
312
333 struct i2c_target_config *config, uint8_t *val);
334
355 struct i2c_target_config *config, uint8_t *val);
356
357#ifdef CONFIG_I2C_TARGET_BUFFER_MODE
371typedef void (*i2c_target_buf_write_received_cb_t)(
372 struct i2c_target_config *config, uint8_t *ptr, uint32_t len);
373
396typedef int (*i2c_target_buf_read_requested_cb_t)(
397 struct i2c_target_config *config, uint8_t **ptr, uint32_t *len);
398#endif
399
414typedef int (*i2c_target_stop_cb_t)(struct i2c_target_config *config);
415
427#ifdef CONFIG_I2C_TARGET_BUFFER_MODE
428 i2c_target_buf_write_received_cb_t buf_write_received;
429 i2c_target_buf_read_requested_cb_t buf_read_requested;
430#endif
432};
433
458
467static inline bool i2c_is_ready_dt(const struct i2c_dt_spec *spec)
468{
469 /* Validate bus is ready */
470 return device_is_ready(spec->bus);
471}
472
480static inline bool i2c_is_read_op(const struct i2c_msg *msg)
481{
482 return (msg->flags & I2C_MSG_READ) == I2C_MSG_READ;
483}
484
492static inline bool i2c_is_stop_op(const struct i2c_msg *msg)
493{
494 return (msg->flags & I2C_MSG_STOP) == I2C_MSG_STOP;
495}
496
523void i2c_dump_msgs_rw(const struct device *dev, const struct i2c_msg *msgs, uint8_t num_msgs,
524 uint16_t addr, bool dump_read);
525
540static inline void i2c_dump_msgs(const struct device *dev, const struct i2c_msg *msgs,
541 uint8_t num_msgs, uint16_t addr)
542{
543 i2c_dump_msgs_rw(dev, msgs, num_msgs, addr, false);
544}
545
546#if defined(CONFIG_I2C_STATS) || defined(__DOXYGEN__)
547
548#include <zephyr/stats/stats.h>
549
553STATS_SECT_ENTRY32(bytes_read)
554STATS_SECT_ENTRY32(bytes_written)
555STATS_SECT_ENTRY32(message_count)
556STATS_SECT_ENTRY32(transfer_call_count)
558
560STATS_NAME(i2c, bytes_read)
561STATS_NAME(i2c, bytes_written)
562STATS_NAME(i2c, message_count)
563STATS_NAME(i2c, transfer_call_count)
564STATS_NAME_END(i2c);
565
574 struct stats_i2c stats;
575};
576
584static inline void i2c_xfer_stats(const struct device *dev, struct i2c_msg *msgs,
585 uint8_t num_msgs)
586{
587 struct i2c_device_state *state =
589 uint32_t bytes_read = 0U;
590 uint32_t bytes_written = 0U;
591
592 STATS_INC(state->stats, transfer_call_count);
593 STATS_INCN(state->stats, message_count, num_msgs);
594 for (uint8_t i = 0U; i < num_msgs; i++) {
595 if (msgs[i].flags & I2C_MSG_READ) {
596 bytes_read += msgs[i].len;
597 } else {
598 bytes_written += msgs[i].len;
599 }
600 }
601 STATS_INCN(state->stats, bytes_read, bytes_read);
602 STATS_INCN(state->stats, bytes_written, bytes_written);
603}
604
610#define Z_I2C_DEVICE_STATE_DEFINE(dev_id) \
611 static struct i2c_device_state Z_DEVICE_STATE_NAME(dev_id) \
612 __attribute__((__section__(".z_devstate")))
613
620#define Z_I2C_INIT_FN(dev_id, init_fn) \
621 static inline int UTIL_CAT(dev_id, _init)(const struct device *dev) \
622 { \
623 struct i2c_device_state *state = \
624 CONTAINER_OF(dev->state, struct i2c_device_state, devstate); \
625 stats_init(&state->stats.s_hdr, STATS_SIZE_32, 4, \
626 STATS_NAME_INIT_PARMS(i2c)); \
627 stats_register(dev->name, &(state->stats.s_hdr)); \
628 if (!is_null_no_warn(init_fn)) { \
629 return init_fn(dev); \
630 } \
631 \
632 return 0; \
633 }
634
664#define I2C_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
665 prio, api, ...) \
666 Z_I2C_DEVICE_STATE_DEFINE(Z_DEVICE_DT_DEV_ID(node_id)); \
667 Z_I2C_INIT_FN(Z_DEVICE_DT_DEV_ID(node_id), init_fn) \
668 Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
669 DEVICE_DT_NAME(node_id), \
670 &UTIL_CAT(Z_DEVICE_DT_DEV_ID(node_id), _init), \
671 NULL, Z_DEVICE_DT_FLAGS(node_id), pm, data, \
672 config, level, prio, api, \
673 &(Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_ID(node_id)).devstate), \
674 __VA_ARGS__)
675
676#else /* CONFIG_I2C_STATS */
677
678static inline void i2c_xfer_stats(const struct device *dev, struct i2c_msg *msgs,
679 uint8_t num_msgs)
680{
681 ARG_UNUSED(dev);
682 ARG_UNUSED(msgs);
683 ARG_UNUSED(num_msgs);
684}
685
686#define I2C_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
687 prio, api, ...) \
688 DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
689 prio, api, __VA_ARGS__)
690
691#endif /* CONFIG_I2C_STATS */
692
701#define I2C_DEVICE_DT_INST_DEFINE(inst, ...) \
702 I2C_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
703
704
715__syscall int i2c_configure(const struct device *dev, uint32_t dev_config);
716
717static inline int z_impl_i2c_configure(const struct device *dev,
718 uint32_t dev_config)
719{
720 const struct i2c_driver_api *api =
721 (const struct i2c_driver_api *)dev->api;
722
723 return api->configure(dev, dev_config);
724}
725
739static inline int i2c_configure_dt(const struct i2c_dt_spec *spec,
740 uint32_t dev_config)
741{
742 return i2c_configure(spec->bus, dev_config);
743}
744
765__syscall int i2c_get_config(const struct device *dev, uint32_t *dev_config);
766
767static inline int z_impl_i2c_get_config(const struct device *dev, uint32_t *dev_config)
768{
769 const struct i2c_driver_api *api = (const struct i2c_driver_api *)dev->api;
770
771 if (api->get_config == NULL) {
772 return -ENOSYS;
773 }
774
775 return api->get_config(dev, dev_config);
776}
777
809__syscall int i2c_transfer(const struct device *dev,
810 struct i2c_msg *msgs, uint8_t num_msgs,
811 uint16_t addr);
812
813static inline int z_impl_i2c_transfer(const struct device *dev,
814 struct i2c_msg *msgs, uint8_t num_msgs,
815 uint16_t addr)
816{
817 const struct i2c_driver_api *api =
818 (const struct i2c_driver_api *)dev->api;
819
820 if (!num_msgs) {
821 return 0;
822 }
823
824 if (!IS_ENABLED(CONFIG_I2C_ALLOW_NO_STOP_TRANSACTIONS)) {
825 msgs[num_msgs - 1].flags |= I2C_MSG_STOP;
826 }
827
828 int res = api->transfer(dev, msgs, num_msgs, addr);
829
830 i2c_xfer_stats(dev, msgs, num_msgs);
831
832 if (IS_ENABLED(CONFIG_I2C_DUMP_MESSAGES)) {
833 i2c_dump_msgs_rw(dev, msgs, num_msgs, addr, true);
834 }
835
836 return res;
837}
838
839#if defined(CONFIG_I2C_CALLBACK) || defined(__DOXYGEN__)
840
863static inline int i2c_transfer_cb(const struct device *dev,
864 struct i2c_msg *msgs,
865 uint8_t num_msgs,
866 uint16_t addr,
868 void *userdata)
869{
870 const struct i2c_driver_api *api =
871 (const struct i2c_driver_api *)dev->api;
872
873 if (api->transfer_cb == NULL) {
874 return -ENOSYS;
875 }
876
877 if (!num_msgs) {
878 cb(dev, 0, userdata);
879 return 0;
880 }
881
882 if (!IS_ENABLED(CONFIG_I2C_ALLOW_NO_STOP_TRANSACTIONS)) {
883 msgs[num_msgs - 1].flags |= I2C_MSG_STOP;
884 }
885
886 return api->transfer_cb(dev, msgs, num_msgs, addr, cb, userdata);
887}
888
904static inline int i2c_transfer_cb_dt(const struct i2c_dt_spec *spec,
905 struct i2c_msg *msgs,
906 uint8_t num_msgs,
908 void *userdata)
909{
910 return i2c_transfer_cb(spec->bus, msgs, num_msgs, spec->addr, cb, userdata);
911}
912
936static inline int i2c_write_read_cb(const struct device *dev, struct i2c_msg *msgs,
937 uint8_t num_msgs, uint16_t addr, const void *write_buf,
938 size_t num_write, void *read_buf, size_t num_read,
939 i2c_callback_t cb, void *userdata)
940{
941 if ((msgs == NULL) || (num_msgs != 2)) {
942 return -EINVAL;
943 }
944
945 msgs[0].buf = (uint8_t *)write_buf;
946 msgs[0].len = num_write;
947 msgs[0].flags = I2C_MSG_WRITE;
948
949 msgs[1].buf = (uint8_t *)read_buf;
950 msgs[1].len = num_read;
952
953 return i2c_transfer_cb(dev, msgs, num_msgs, addr, cb, userdata);
954}
955
977static inline int i2c_write_read_cb_dt(const struct i2c_dt_spec *spec, struct i2c_msg *msgs,
978 uint8_t num_msgs, const void *write_buf, size_t num_write,
979 void *read_buf, size_t num_read, i2c_callback_t cb,
980 void *userdata)
981{
982 return i2c_write_read_cb(spec->bus, msgs, num_msgs, spec->addr, write_buf, num_write,
983 read_buf, num_read, cb, userdata);
984}
985
986#if defined(CONFIG_POLL) || defined(__DOXYGEN__)
987
989void z_i2c_transfer_signal_cb(const struct device *dev, int result, void *userdata);
1013static inline int i2c_transfer_signal(const struct device *dev,
1014 struct i2c_msg *msgs,
1015 uint8_t num_msgs,
1016 uint16_t addr,
1017 struct k_poll_signal *sig)
1018{
1019 const struct i2c_driver_api *api = (const struct i2c_driver_api *)dev->api;
1020
1021 if (api->transfer_cb == NULL) {
1022 return -ENOSYS;
1023 }
1024
1025 return api->transfer_cb(dev, msgs, num_msgs, addr, z_i2c_transfer_signal_cb, sig);
1026}
1027
1028#endif /* CONFIG_POLL */
1029
1030#endif /* CONFIG_I2C_CALLBACK */
1031
1032
1033#if defined(CONFIG_I2C_RTIO) || defined(__DOXYGEN__)
1034
1045void i2c_iodev_submit_fallback(const struct device *dev, struct rtio_iodev_sqe *iodev_sqe);
1046
1053static inline void i2c_iodev_submit(struct rtio_iodev_sqe *iodev_sqe)
1054{
1055 const struct i2c_dt_spec *dt_spec = (const struct i2c_dt_spec *)iodev_sqe->sqe.iodev->data;
1056 const struct device *dev = dt_spec->bus;
1057 const struct i2c_driver_api *api = (const struct i2c_driver_api *)dev->api;
1058
1059 if (api->iodev_submit == NULL) {
1060 rtio_iodev_sqe_err(iodev_sqe, -ENOSYS);
1061 return;
1062 }
1063 api->iodev_submit(dt_spec->bus, iodev_sqe);
1064}
1065
1066extern const struct rtio_iodev_api i2c_iodev_api;
1067
1077#define I2C_DT_IODEV_DEFINE(name, node_id) \
1078 const struct i2c_dt_spec _i2c_dt_spec_##name = \
1079 I2C_DT_SPEC_GET(node_id); \
1080 RTIO_IODEV_DEFINE(name, &i2c_iodev_api, (void *)&_i2c_dt_spec_##name)
1081
1092#define I2C_IODEV_DEFINE(name, _bus, _addr) \
1093 const struct i2c_dt_spec _i2c_dt_spec_##name = { \
1094 .bus = DEVICE_DT_GET(_bus), \
1095 .addr = _addr, \
1096 }; \
1097 RTIO_IODEV_DEFINE(name, &i2c_iodev_api, (void *)&_i2c_dt_spec_##name)
1098
1107static inline bool i2c_is_ready_iodev(const struct rtio_iodev *i2c_iodev)
1108{
1109 struct i2c_dt_spec *spec = (struct i2c_dt_spec *)i2c_iodev->data;
1110
1111 return i2c_is_ready_dt(spec);
1112}
1113
1126 struct rtio_iodev *iodev,
1127 const struct i2c_msg *msgs,
1128 uint8_t num_msgs);
1129
1142 uint8_t reg_addr, uint8_t data);
1143
1157 uint8_t start_addr, void *buf, size_t num_bytes);
1158
1159#endif /* CONFIG_I2C_RTIO */
1160
1174static inline int i2c_transfer_dt(const struct i2c_dt_spec *spec,
1175 struct i2c_msg *msgs, uint8_t num_msgs)
1176{
1177 return i2c_transfer(spec->bus, msgs, num_msgs, spec->addr);
1178}
1179
1192__syscall int i2c_recover_bus(const struct device *dev);
1193
1194static inline int z_impl_i2c_recover_bus(const struct device *dev)
1195{
1196 const struct i2c_driver_api *api =
1197 (const struct i2c_driver_api *)dev->api;
1198
1199 if (api->recover_bus == NULL) {
1200 return -ENOSYS;
1201 }
1202
1203 return api->recover_bus(dev);
1204}
1205
1230static inline int i2c_target_register(const struct device *dev,
1231 struct i2c_target_config *cfg)
1232{
1233 const struct i2c_driver_api *api =
1234 (const struct i2c_driver_api *)dev->api;
1235
1236 if (api->target_register == NULL) {
1237 return -ENOSYS;
1238 }
1239
1240 return api->target_register(dev, cfg);
1241}
1242
1259static inline int i2c_target_unregister(const struct device *dev,
1260 struct i2c_target_config *cfg)
1261{
1262 const struct i2c_driver_api *api =
1263 (const struct i2c_driver_api *)dev->api;
1264
1265 if (api->target_unregister == NULL) {
1266 return -ENOSYS;
1267 }
1268
1269 return api->target_unregister(dev, cfg);
1270}
1271
1285__syscall int i2c_target_driver_register(const struct device *dev);
1286
1287static inline int z_impl_i2c_target_driver_register(const struct device *dev)
1288{
1289 const struct i2c_target_driver_api *api =
1290 (const struct i2c_target_driver_api *)dev->api;
1291
1292 return api->driver_register(dev);
1293}
1294
1308__syscall int i2c_target_driver_unregister(const struct device *dev);
1309
1310static inline int z_impl_i2c_target_driver_unregister(const struct device *dev)
1311{
1312 const struct i2c_target_driver_api *api =
1313 (const struct i2c_target_driver_api *)dev->api;
1314
1315 return api->driver_unregister(dev);
1316}
1317
1318/*
1319 * Derived i2c APIs -- all implemented in terms of i2c_transfer()
1320 */
1321
1336static inline int i2c_write(const struct device *dev, const uint8_t *buf,
1337 uint32_t num_bytes, uint16_t addr)
1338{
1339 struct i2c_msg msg;
1340
1341 msg.buf = (uint8_t *)buf;
1342 msg.len = num_bytes;
1344
1345 return i2c_transfer(dev, &msg, 1, addr);
1346}
1347
1361static inline int i2c_write_dt(const struct i2c_dt_spec *spec,
1362 const uint8_t *buf, uint32_t num_bytes)
1363{
1364 return i2c_write(spec->bus, buf, num_bytes, spec->addr);
1365}
1366
1381static inline int i2c_read(const struct device *dev, uint8_t *buf,
1382 uint32_t num_bytes, uint16_t addr)
1383{
1384 struct i2c_msg msg;
1385
1386 msg.buf = buf;
1387 msg.len = num_bytes;
1389
1390 return i2c_transfer(dev, &msg, 1, addr);
1391}
1392
1406static inline int i2c_read_dt(const struct i2c_dt_spec *spec,
1407 uint8_t *buf, uint32_t num_bytes)
1408{
1409 return i2c_read(spec->bus, buf, num_bytes, spec->addr);
1410}
1411
1430static inline int i2c_write_read(const struct device *dev, uint16_t addr,
1431 const void *write_buf, size_t num_write,
1432 void *read_buf, size_t num_read)
1433{
1434 struct i2c_msg msg[2];
1435
1436 msg[0].buf = (uint8_t *)write_buf;
1437 msg[0].len = num_write;
1438 msg[0].flags = I2C_MSG_WRITE;
1439
1440 msg[1].buf = (uint8_t *)read_buf;
1441 msg[1].len = num_read;
1443
1444 return i2c_transfer(dev, msg, 2, addr);
1445}
1446
1464static inline int i2c_write_read_dt(const struct i2c_dt_spec *spec,
1465 const void *write_buf, size_t num_write,
1466 void *read_buf, size_t num_read)
1467{
1468 return i2c_write_read(spec->bus, spec->addr,
1469 write_buf, num_write,
1470 read_buf, num_read);
1471}
1472
1491static inline int i2c_burst_read(const struct device *dev,
1492 uint16_t dev_addr,
1493 uint8_t start_addr,
1494 uint8_t *buf,
1495 uint32_t num_bytes)
1496{
1497 return i2c_write_read(dev, dev_addr,
1498 &start_addr, sizeof(start_addr),
1499 buf, num_bytes);
1500}
1501
1516static inline int i2c_burst_read_dt(const struct i2c_dt_spec *spec,
1517 uint8_t start_addr,
1518 uint8_t *buf,
1519 uint32_t num_bytes)
1520{
1521 return i2c_burst_read(spec->bus, spec->addr,
1522 start_addr, buf, num_bytes);
1523}
1524
1546static inline int i2c_burst_write(const struct device *dev,
1547 uint16_t dev_addr,
1548 uint8_t start_addr,
1549 const uint8_t *buf,
1550 uint32_t num_bytes)
1551{
1552 struct i2c_msg msg[2];
1553
1554 msg[0].buf = &start_addr;
1555 msg[0].len = 1U;
1556 msg[0].flags = I2C_MSG_WRITE;
1557
1558 msg[1].buf = (uint8_t *)buf;
1559 msg[1].len = num_bytes;
1560 msg[1].flags = I2C_MSG_WRITE | I2C_MSG_STOP;
1561
1562 return i2c_transfer(dev, msg, 2, dev_addr);
1563}
1564
1579static inline int i2c_burst_write_dt(const struct i2c_dt_spec *spec,
1580 uint8_t start_addr,
1581 const uint8_t *buf,
1582 uint32_t num_bytes)
1583{
1584 return i2c_burst_write(spec->bus, spec->addr,
1585 start_addr, buf, num_bytes);
1586}
1587
1603static inline int i2c_reg_read_byte(const struct device *dev,
1604 uint16_t dev_addr,
1605 uint8_t reg_addr, uint8_t *value)
1606{
1607 return i2c_write_read(dev, dev_addr,
1608 &reg_addr, sizeof(reg_addr),
1609 value, sizeof(*value));
1610}
1611
1625static inline int i2c_reg_read_byte_dt(const struct i2c_dt_spec *spec,
1626 uint8_t reg_addr, uint8_t *value)
1627{
1628 return i2c_reg_read_byte(spec->bus, spec->addr, reg_addr, value);
1629}
1630
1649static inline int i2c_reg_write_byte(const struct device *dev,
1650 uint16_t dev_addr,
1651 uint8_t reg_addr, uint8_t value)
1652{
1653 uint8_t tx_buf[2] = {reg_addr, value};
1654
1655 return i2c_write(dev, tx_buf, 2, dev_addr);
1656}
1657
1671static inline int i2c_reg_write_byte_dt(const struct i2c_dt_spec *spec,
1672 uint8_t reg_addr, uint8_t value)
1673{
1674 return i2c_reg_write_byte(spec->bus, spec->addr, reg_addr, value);
1675}
1676
1696static inline int i2c_reg_update_byte(const struct device *dev,
1697 uint8_t dev_addr,
1698 uint8_t reg_addr, uint8_t mask,
1699 uint8_t value)
1700{
1701 uint8_t old_value, new_value;
1702 int rc;
1703
1704 rc = i2c_reg_read_byte(dev, dev_addr, reg_addr, &old_value);
1705 if (rc != 0) {
1706 return rc;
1707 }
1708
1709 new_value = (old_value & ~mask) | (value & mask);
1710 if (new_value == old_value) {
1711 return 0;
1712 }
1713
1714 return i2c_reg_write_byte(dev, dev_addr, reg_addr, new_value);
1715}
1716
1731static inline int i2c_reg_update_byte_dt(const struct i2c_dt_spec *spec,
1732 uint8_t reg_addr, uint8_t mask,
1733 uint8_t value)
1734{
1735 return i2c_reg_update_byte(spec->bus, spec->addr,
1736 reg_addr, mask, value);
1737}
1738
1739#ifdef __cplusplus
1740}
1741#endif
1742
1747#include <zephyr/syscalls/i2c.h>
1748
1749#endif /* ZEPHYR_INCLUDE_DRIVERS_I2C_H_ */
workaround assembler barfing for ST r
Definition asm-macro-32-bit-gnu.h:24
System error numbers.
bool device_is_ready(const struct device *dev)
Verify that a device is ready for use.
static int i2c_transfer_cb_dt(const struct i2c_dt_spec *spec, struct i2c_msg *msgs, uint8_t num_msgs, i2c_callback_t cb, void *userdata)
Perform data transfer to another I2C device in master mode asynchronously.
Definition i2c.h:904
int i2c_target_driver_unregister(const struct device *dev)
Instructs the I2C Target device to unregister itself from the I2C Controller.
static int i2c_burst_write_dt(const struct i2c_dt_spec *spec, uint8_t start_addr, const uint8_t *buf, uint32_t num_bytes)
Write multiple bytes to an internal address of an I2C device.
Definition i2c.h:1579
static int i2c_target_unregister(const struct device *dev, struct i2c_target_config *cfg)
Unregisters the provided config as Target device.
Definition i2c.h:1259
static int i2c_write_read(const struct device *dev, uint16_t addr, const void *write_buf, size_t num_write, void *read_buf, size_t num_read)
Write then read data from an I2C device.
Definition i2c.h:1430
int i2c_target_driver_register(const struct device *dev)
Instructs the I2C Target device to register itself to the I2C Controller.
static void i2c_iodev_submit(struct rtio_iodev_sqe *iodev_sqe)
Submit request(s) to an I2C device with RTIO.
Definition i2c.h:1053
struct rtio_sqe * i2c_rtio_copy(struct rtio *r, struct rtio_iodev *iodev, const struct i2c_msg *msgs, uint8_t num_msgs)
Copy the i2c_msgs into a set of RTIO requests.
void i2c_dump_msgs_rw(const struct device *dev, const struct i2c_msg *msgs, uint8_t num_msgs, uint16_t addr, bool dump_read)
Dump out an I2C message.
int(* i2c_target_read_requested_cb_t)(struct i2c_target_config *config, uint8_t *val)
Function called when a read from the device is initiated.
Definition i2c.h:332
int i2c_transfer(const struct device *dev, struct i2c_msg *msgs, uint8_t num_msgs, uint16_t addr)
Perform data transfer to another I2C device in controller mode.
static int i2c_write(const struct device *dev, const uint8_t *buf, uint32_t num_bytes, uint16_t addr)
Write a set amount of data to an I2C device.
Definition i2c.h:1336
static int i2c_write_dt(const struct i2c_dt_spec *spec, const uint8_t *buf, uint32_t num_bytes)
Write a set amount of data to an I2C device.
Definition i2c.h:1361
static int i2c_write_read_dt(const struct i2c_dt_spec *spec, const void *write_buf, size_t num_write, void *read_buf, size_t num_read)
Write then read data from an I2C device.
Definition i2c.h:1464
static int i2c_write_read_cb(const struct device *dev, struct i2c_msg *msgs, uint8_t num_msgs, uint16_t addr, const void *write_buf, size_t num_write, void *read_buf, size_t num_read, i2c_callback_t cb, void *userdata)
Write then read data from an I2C device asynchronously.
Definition i2c.h:936
static bool i2c_is_stop_op(const struct i2c_msg *msg)
Check if the current message includes a stop.
Definition i2c.h:492
int(* i2c_target_stop_cb_t)(struct i2c_target_config *config)
Function called when a stop condition is observed after a start condition addressed to a particular d...
Definition i2c.h:414
static bool i2c_is_ready_iodev(const struct rtio_iodev *i2c_iodev)
Validate that I2C bus is ready.
Definition i2c.h:1107
static int i2c_burst_read(const struct device *dev, uint16_t dev_addr, uint8_t start_addr, uint8_t *buf, uint32_t num_bytes)
Read multiple bytes from an internal address of an I2C device.
Definition i2c.h:1491
int(* i2c_target_read_processed_cb_t)(struct i2c_target_config *config, uint8_t *val)
Function called when a read from the device is continued.
Definition i2c.h:354
int(* i2c_target_write_requested_cb_t)(struct i2c_target_config *config)
Function called when a write to the device is initiated.
Definition i2c.h:289
void i2c_iodev_submit_fallback(const struct device *dev, struct rtio_iodev_sqe *iodev_sqe)
Fallback submit implementation.
static int i2c_reg_update_byte_dt(const struct i2c_dt_spec *spec, uint8_t reg_addr, uint8_t mask, uint8_t value)
Update internal register of an I2C device.
Definition i2c.h:1731
void(* i2c_callback_t)(const struct device *dev, int result, void *data)
I2C callback for asynchronous transfer requests.
Definition i2c.h:202
static int i2c_read_dt(const struct i2c_dt_spec *spec, uint8_t *buf, uint32_t num_bytes)
Read a set amount of data from an I2C device.
Definition i2c.h:1406
int(* i2c_target_write_received_cb_t)(struct i2c_target_config *config, uint8_t val)
Function called when a write to the device is continued.
Definition i2c.h:310
static int i2c_reg_write_byte_dt(const struct i2c_dt_spec *spec, uint8_t reg_addr, uint8_t value)
Write internal register of an I2C device.
Definition i2c.h:1671
int i2c_get_config(const struct device *dev, uint32_t *dev_config)
Get configuration of a host controller.
static int i2c_reg_write_byte(const struct device *dev, uint16_t dev_addr, uint8_t reg_addr, uint8_t value)
Write internal register of an I2C device.
Definition i2c.h:1649
#define I2C_MSG_READ
Read message from I2C bus.
Definition i2c.h:147
static int i2c_reg_read_byte_dt(const struct i2c_dt_spec *spec, uint8_t reg_addr, uint8_t *value)
Read internal register of an I2C device.
Definition i2c.h:1625
int i2c_configure(const struct device *dev, uint32_t dev_config)
Configure operation of a host controller.
static int i2c_configure_dt(const struct i2c_dt_spec *spec, uint32_t dev_config)
Configure operation of a host controller.
Definition i2c.h:739
static int i2c_write_read_cb_dt(const struct i2c_dt_spec *spec, struct i2c_msg *msgs, uint8_t num_msgs, const void *write_buf, size_t num_write, void *read_buf, size_t num_read, i2c_callback_t cb, void *userdata)
Write then read data from an I2C device asynchronously.
Definition i2c.h:977
#define I2C_MSG_RESTART
RESTART I2C transaction for this message.
Definition i2c.h:163
static int i2c_transfer_dt(const struct i2c_dt_spec *spec, struct i2c_msg *msgs, uint8_t num_msgs)
Perform data transfer to another I2C device in controller mode.
Definition i2c.h:1174
int i2c_recover_bus(const struct device *dev)
Recover the I2C bus.
static int i2c_read(const struct device *dev, uint8_t *buf, uint32_t num_bytes, uint16_t addr)
Read a set amount of data from an I2C device.
Definition i2c.h:1381
static bool i2c_is_read_op(const struct i2c_msg *msg)
Check if the current message is a read operation.
Definition i2c.h:480
static int i2c_burst_read_dt(const struct i2c_dt_spec *spec, uint8_t start_addr, uint8_t *buf, uint32_t num_bytes)
Read multiple bytes from an internal address of an I2C device.
Definition i2c.h:1516
static int i2c_target_register(const struct device *dev, struct i2c_target_config *cfg)
Registers the provided config as Target device of a controller.
Definition i2c.h:1230
static int i2c_transfer_cb(const struct device *dev, struct i2c_msg *msgs, uint8_t num_msgs, uint16_t addr, i2c_callback_t cb, void *userdata)
Perform data transfer to another I2C device in controller mode.
Definition i2c.h:863
#define I2C_MSG_STOP
Send STOP after this message.
Definition i2c.h:154
static void i2c_xfer_stats(const struct device *dev, struct i2c_msg *msgs, uint8_t num_msgs)
Updates the i2c stats for i2c transfers.
Definition i2c.h:584
static void i2c_dump_msgs(const struct device *dev, const struct i2c_msg *msgs, uint8_t num_msgs, uint16_t addr)
Dump out an I2C message, before it is executed.
Definition i2c.h:540
static int i2c_transfer_signal(const struct device *dev, struct i2c_msg *msgs, uint8_t num_msgs, uint16_t addr, struct k_poll_signal *sig)
Perform data transfer to another I2C device in controller mode.
Definition i2c.h:1013
static int i2c_reg_update_byte(const struct device *dev, uint8_t dev_addr, uint8_t reg_addr, uint8_t mask, uint8_t value)
Update internal register of an I2C device.
Definition i2c.h:1696
const struct rtio_iodev_api i2c_iodev_api
struct rtio_sqe * i2c_rtio_copy_reg_write_byte(struct rtio *r, struct rtio_iodev *iodev, uint8_t reg_addr, uint8_t data)
Copy the register address and data to a SQE.
#define I2C_MSG_WRITE
Write message to I2C bus.
Definition i2c.h:144
static int i2c_reg_read_byte(const struct device *dev, uint16_t dev_addr, uint8_t reg_addr, uint8_t *value)
Read internal register of an I2C device.
Definition i2c.h:1603
static int i2c_burst_write(const struct device *dev, uint16_t dev_addr, uint8_t start_addr, const uint8_t *buf, uint32_t num_bytes)
Write multiple bytes to an internal address of an I2C device.
Definition i2c.h:1546
struct rtio_sqe * i2c_rtio_copy_reg_burst_read(struct rtio *r, struct rtio_iodev *iodev, uint8_t start_addr, void *buf, size_t num_bytes)
acquire and configure a i2c burst read transmission
static bool i2c_is_ready_dt(const struct i2c_dt_spec *spec)
Validate that I2C bus is ready.
Definition i2c.h:467
static void rtio_iodev_sqe_err(struct rtio_iodev_sqe *iodev_sqe, int result)
Inform the executor of a submissions completion with error.
Definition rtio.h:1233
struct _snode sys_snode_t
Single-linked list node structure.
Definition slist.h:39
#define IS_ENABLED(config_macro)
Check for macro definition in compiler-visible expressions.
Definition util_macro.h:148
#define CONTAINER_OF(ptr, type, field)
Get a pointer to a structure containing the element.
Definition util.h:285
#define EINVAL
Invalid argument.
Definition errno.h:60
#define ENOSYS
Function not implemented.
Definition errno.h:82
#define NULL
Definition iar_missing_defs.h:20
Public kernel APIs.
flags
Definition parser.h:97
state
Definition parser_state.h:29
Real-Time IO device API for moving bytes with low effort.
Statistics.
#define STATS_NAME_END(name__)
Definition stats.h:391
#define STATS_NAME(name__, entry__)
Definition stats.h:390
#define STATS_SECT_END
Ends a stats group struct definition.
Definition stats.h:89
#define STATS_SECT_ENTRY32(var__)
Definition stats.h:359
#define STATS_INC(group__, var__)
Definition stats.h:364
#define STATS_NAME_START(name__)
Definition stats.h:389
#define STATS_INCN(group__, var__, n__)
Definition stats.h:363
#define STATS_SECT_START(group__)
Definition stats.h:354
__UINT32_TYPE__ uint32_t
Definition stdint.h:90
__UINT8_TYPE__ uint8_t
Definition stdint.h:88
__UINT16_TYPE__ uint16_t
Definition stdint.h:89
Runtime device dynamic structure (in RAM) per driver instance.
Definition device.h:451
Runtime device structure (in ROM) per driver instance.
Definition device.h:504
void * data
Address of the device instance private data.
Definition device.h:514
const void * api
Address of the API structure exposed by the device instance.
Definition device.h:510
struct device_state * state
Address of the common device state.
Definition device.h:512
I2C specific device state which allows for i2c device class specific additions.
Definition i2c.h:572
struct stats_i2c stats
Definition i2c.h:574
struct device_state devstate
Definition i2c.h:573
Complete I2C DT information.
Definition i2c.h:77
const struct device * bus
Definition i2c.h:78
uint16_t addr
Definition i2c.h:79
One I2C Message.
Definition i2c.h:184
uint8_t * buf
Data buffer in bytes.
Definition i2c.h:186
uint32_t len
Length of buffer in bytes.
Definition i2c.h:189
uint8_t flags
Flags for this message.
Definition i2c.h:192
Structure providing callbacks to be implemented for devices that supports the I2C target API.
Definition i2c.h:422
i2c_target_read_requested_cb_t read_requested
Definition i2c.h:424
i2c_target_write_received_cb_t write_received
Definition i2c.h:425
i2c_target_read_processed_cb_t read_processed
Definition i2c.h:426
i2c_target_write_requested_cb_t write_requested
Definition i2c.h:423
i2c_target_stop_cb_t stop
Definition i2c.h:431
Structure describing a device that supports the I2C target API.
Definition i2c.h:445
uint8_t flags
Flags for the target device defined by I2C_TARGET_FLAGS_* constants.
Definition i2c.h:450
uint16_t address
Address for this target device.
Definition i2c.h:453
sys_snode_t node
Private, do not modify.
Definition i2c.h:447
const struct i2c_target_callbacks * callbacks
Callback functions.
Definition i2c.h:456
Definition kernel.h:5998
API that an RTIO IO device should implement.
Definition rtio.h:502
Compute the mempool block index for a given pointer.
Definition rtio.h:492
struct rtio_sqe sqe
Definition rtio.h:493
An IO device with a function table for submitting requests.
Definition rtio.h:517
void * data
Definition rtio.h:522
A submission queue event.
Definition rtio.h:286
const struct rtio_iodev * iodev
Device to operation on.
Definition rtio.h:295
const uint8_t * buf
Buffer to write from.
Definition rtio.h:311
An RTIO context containing what can be viewed as a pair of queues.
Definition rtio.h:396