Zephyr API Documentation 4.2.0-rc1
A Scalable Open Source RTOS
 4.2.0-rc1
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
666#define I2C_DEVICE_DT_DEINIT_DEFINE(node_id, init_fn, deinit_fn, pm, \
667 data, config, level, prio, api, ...)\
668 Z_I2C_DEVICE_STATE_DEFINE(Z_DEVICE_DT_DEV_ID(node_id)); \
669 Z_I2C_INIT_FN(Z_DEVICE_DT_DEV_ID(node_id), init_fn) \
670 Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
671 DEVICE_DT_NAME(node_id), \
672 &UTIL_CAT(Z_DEVICE_DT_DEV_ID(node_id), _init), \
673 deinit_fn, Z_DEVICE_DT_FLAGS(node_id), pm, data,\
674 config, level, prio, api, \
675 &(Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_ID(node_id)).devstate), \
676 __VA_ARGS__)
677
678#else /* CONFIG_I2C_STATS */
679
680static inline void i2c_xfer_stats(const struct device *dev, struct i2c_msg *msgs,
681 uint8_t num_msgs)
682{
683 ARG_UNUSED(dev);
684 ARG_UNUSED(msgs);
685 ARG_UNUSED(num_msgs);
686}
687
688#define I2C_DEVICE_DT_DEINIT_DEFINE(node_id, init_fn, deinit_fn, pm, \
689 data, config, level, prio, api, ...)\
690 DEVICE_DT_DEINIT_DEFINE(node_id, init_fn, deinit_fn, pm, data, \
691 config, level, prio, api, __VA_ARGS__)
692
693#endif /* CONFIG_I2C_STATS */
694
698#define I2C_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
699 prio, api, ...) \
700 I2C_DEVICE_DT_DEINIT_DEFINE(node_id, init_fn, NULL, pm, data, \
701 config, level, prio, api, \
702 __VA_ARGS__)
703
712#define I2C_DEVICE_DT_INST_DEINIT_DEFINE(inst, ...) \
713 I2C_DEVICE_DT_DEINIT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
714
723#define I2C_DEVICE_DT_INST_DEFINE(inst, ...) \
724 I2C_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
725
736__syscall int i2c_configure(const struct device *dev, uint32_t dev_config);
737
738static inline int z_impl_i2c_configure(const struct device *dev,
739 uint32_t dev_config)
740{
741 const struct i2c_driver_api *api =
742 (const struct i2c_driver_api *)dev->api;
743
744 return api->configure(dev, dev_config);
745}
746
760static inline int i2c_configure_dt(const struct i2c_dt_spec *spec,
761 uint32_t dev_config)
762{
763 return i2c_configure(spec->bus, dev_config);
764}
765
786__syscall int i2c_get_config(const struct device *dev, uint32_t *dev_config);
787
788static inline int z_impl_i2c_get_config(const struct device *dev, uint32_t *dev_config)
789{
790 const struct i2c_driver_api *api = (const struct i2c_driver_api *)dev->api;
791
792 if (api->get_config == NULL) {
793 return -ENOSYS;
794 }
795
796 return api->get_config(dev, dev_config);
797}
798
830__syscall int i2c_transfer(const struct device *dev,
831 struct i2c_msg *msgs, uint8_t num_msgs,
832 uint16_t addr);
833
834static inline int z_impl_i2c_transfer(const struct device *dev,
835 struct i2c_msg *msgs, uint8_t num_msgs,
836 uint16_t addr)
837{
838 const struct i2c_driver_api *api =
839 (const struct i2c_driver_api *)dev->api;
840
841 if (!num_msgs) {
842 return 0;
843 }
844
845 if (!IS_ENABLED(CONFIG_I2C_ALLOW_NO_STOP_TRANSACTIONS)) {
846 msgs[num_msgs - 1].flags |= I2C_MSG_STOP;
847 }
848
849 int res = api->transfer(dev, msgs, num_msgs, addr);
850
851 i2c_xfer_stats(dev, msgs, num_msgs);
852
853 if (IS_ENABLED(CONFIG_I2C_DUMP_MESSAGES)) {
854 i2c_dump_msgs_rw(dev, msgs, num_msgs, addr, true);
855 }
856
857 return res;
858}
859
860#if defined(CONFIG_I2C_CALLBACK) || defined(__DOXYGEN__)
861
884static inline int i2c_transfer_cb(const struct device *dev,
885 struct i2c_msg *msgs,
886 uint8_t num_msgs,
887 uint16_t addr,
889 void *userdata)
890{
891 const struct i2c_driver_api *api =
892 (const struct i2c_driver_api *)dev->api;
893
894 if (api->transfer_cb == NULL) {
895 return -ENOSYS;
896 }
897
898 if (!num_msgs) {
899 cb(dev, 0, userdata);
900 return 0;
901 }
902
903 if (!IS_ENABLED(CONFIG_I2C_ALLOW_NO_STOP_TRANSACTIONS)) {
904 msgs[num_msgs - 1].flags |= I2C_MSG_STOP;
905 }
906
907 return api->transfer_cb(dev, msgs, num_msgs, addr, cb, userdata);
908}
909
925static inline int i2c_transfer_cb_dt(const struct i2c_dt_spec *spec,
926 struct i2c_msg *msgs,
927 uint8_t num_msgs,
929 void *userdata)
930{
931 return i2c_transfer_cb(spec->bus, msgs, num_msgs, spec->addr, cb, userdata);
932}
933
957static inline int i2c_write_read_cb(const struct device *dev, struct i2c_msg *msgs,
958 uint8_t num_msgs, uint16_t addr, const void *write_buf,
959 size_t num_write, void *read_buf, size_t num_read,
960 i2c_callback_t cb, void *userdata)
961{
962 if ((msgs == NULL) || (num_msgs != 2)) {
963 return -EINVAL;
964 }
965
966 msgs[0].buf = (uint8_t *)write_buf;
967 msgs[0].len = num_write;
968 msgs[0].flags = I2C_MSG_WRITE;
969
970 msgs[1].buf = (uint8_t *)read_buf;
971 msgs[1].len = num_read;
973
974 return i2c_transfer_cb(dev, msgs, num_msgs, addr, cb, userdata);
975}
976
998static inline int i2c_write_read_cb_dt(const struct i2c_dt_spec *spec, struct i2c_msg *msgs,
999 uint8_t num_msgs, const void *write_buf, size_t num_write,
1000 void *read_buf, size_t num_read, i2c_callback_t cb,
1001 void *userdata)
1002{
1003 return i2c_write_read_cb(spec->bus, msgs, num_msgs, spec->addr, write_buf, num_write,
1004 read_buf, num_read, cb, userdata);
1005}
1006
1007#if defined(CONFIG_POLL) || defined(__DOXYGEN__)
1008
1010void z_i2c_transfer_signal_cb(const struct device *dev, int result, void *userdata);
1034static inline int i2c_transfer_signal(const struct device *dev,
1035 struct i2c_msg *msgs,
1036 uint8_t num_msgs,
1037 uint16_t addr,
1038 struct k_poll_signal *sig)
1039{
1040 const struct i2c_driver_api *api = (const struct i2c_driver_api *)dev->api;
1041
1042 if (api->transfer_cb == NULL) {
1043 return -ENOSYS;
1044 }
1045
1046 return api->transfer_cb(dev, msgs, num_msgs, addr, z_i2c_transfer_signal_cb, sig);
1047}
1048
1049#endif /* CONFIG_POLL */
1050
1051#endif /* CONFIG_I2C_CALLBACK */
1052
1053
1054#if defined(CONFIG_I2C_RTIO) || defined(__DOXYGEN__)
1055
1066void i2c_iodev_submit_fallback(const struct device *dev, struct rtio_iodev_sqe *iodev_sqe);
1067
1074static inline void i2c_iodev_submit(struct rtio_iodev_sqe *iodev_sqe)
1075{
1076 const struct i2c_dt_spec *dt_spec = (const struct i2c_dt_spec *)iodev_sqe->sqe.iodev->data;
1077 const struct device *dev = dt_spec->bus;
1078 const struct i2c_driver_api *api = (const struct i2c_driver_api *)dev->api;
1079
1080 if (api->iodev_submit == NULL) {
1081 rtio_iodev_sqe_err(iodev_sqe, -ENOSYS);
1082 return;
1083 }
1084 api->iodev_submit(dt_spec->bus, iodev_sqe);
1085}
1086
1087extern const struct rtio_iodev_api i2c_iodev_api;
1088
1098#define I2C_DT_IODEV_DEFINE(name, node_id) \
1099 const struct i2c_dt_spec _i2c_dt_spec_##name = \
1100 I2C_DT_SPEC_GET(node_id); \
1101 RTIO_IODEV_DEFINE(name, &i2c_iodev_api, (void *)&_i2c_dt_spec_##name)
1102
1113#define I2C_IODEV_DEFINE(name, _bus, _addr) \
1114 const struct i2c_dt_spec _i2c_dt_spec_##name = { \
1115 .bus = DEVICE_DT_GET(_bus), \
1116 .addr = _addr, \
1117 }; \
1118 RTIO_IODEV_DEFINE(name, &i2c_iodev_api, (void *)&_i2c_dt_spec_##name)
1119
1128static inline bool i2c_is_ready_iodev(const struct rtio_iodev *i2c_iodev)
1129{
1130 struct i2c_dt_spec *spec = (struct i2c_dt_spec *)i2c_iodev->data;
1131
1132 return i2c_is_ready_dt(spec);
1133}
1134
1147 struct rtio_iodev *iodev,
1148 const struct i2c_msg *msgs,
1149 uint8_t num_msgs);
1150
1163 uint8_t reg_addr, uint8_t data);
1164
1178 uint8_t start_addr, void *buf, size_t num_bytes);
1179
1180#endif /* CONFIG_I2C_RTIO */
1181
1195static inline int i2c_transfer_dt(const struct i2c_dt_spec *spec,
1196 struct i2c_msg *msgs, uint8_t num_msgs)
1197{
1198 return i2c_transfer(spec->bus, msgs, num_msgs, spec->addr);
1199}
1200
1213__syscall int i2c_recover_bus(const struct device *dev);
1214
1215static inline int z_impl_i2c_recover_bus(const struct device *dev)
1216{
1217 const struct i2c_driver_api *api =
1218 (const struct i2c_driver_api *)dev->api;
1219
1220 if (api->recover_bus == NULL) {
1221 return -ENOSYS;
1222 }
1223
1224 return api->recover_bus(dev);
1225}
1226
1251static inline int i2c_target_register(const struct device *dev,
1252 struct i2c_target_config *cfg)
1253{
1254 const struct i2c_driver_api *api =
1255 (const struct i2c_driver_api *)dev->api;
1256
1257 if (api->target_register == NULL) {
1258 return -ENOSYS;
1259 }
1260
1261 return api->target_register(dev, cfg);
1262}
1263
1280static inline int i2c_target_unregister(const struct device *dev,
1281 struct i2c_target_config *cfg)
1282{
1283 const struct i2c_driver_api *api =
1284 (const struct i2c_driver_api *)dev->api;
1285
1286 if (api->target_unregister == NULL) {
1287 return -ENOSYS;
1288 }
1289
1290 return api->target_unregister(dev, cfg);
1291}
1292
1306__syscall int i2c_target_driver_register(const struct device *dev);
1307
1308static inline int z_impl_i2c_target_driver_register(const struct device *dev)
1309{
1310 const struct i2c_target_driver_api *api =
1311 (const struct i2c_target_driver_api *)dev->api;
1312
1313 return api->driver_register(dev);
1314}
1315
1329__syscall int i2c_target_driver_unregister(const struct device *dev);
1330
1331static inline int z_impl_i2c_target_driver_unregister(const struct device *dev)
1332{
1333 const struct i2c_target_driver_api *api =
1334 (const struct i2c_target_driver_api *)dev->api;
1335
1336 return api->driver_unregister(dev);
1337}
1338
1339/*
1340 * Derived i2c APIs -- all implemented in terms of i2c_transfer()
1341 */
1342
1357static inline int i2c_write(const struct device *dev, const uint8_t *buf,
1358 uint32_t num_bytes, uint16_t addr)
1359{
1360 struct i2c_msg msg;
1361
1362 msg.buf = (uint8_t *)buf;
1363 msg.len = num_bytes;
1365
1366 return i2c_transfer(dev, &msg, 1, addr);
1367}
1368
1382static inline int i2c_write_dt(const struct i2c_dt_spec *spec,
1383 const uint8_t *buf, uint32_t num_bytes)
1384{
1385 return i2c_write(spec->bus, buf, num_bytes, spec->addr);
1386}
1387
1402static inline int i2c_read(const struct device *dev, uint8_t *buf,
1403 uint32_t num_bytes, uint16_t addr)
1404{
1405 struct i2c_msg msg;
1406
1407 msg.buf = buf;
1408 msg.len = num_bytes;
1410
1411 return i2c_transfer(dev, &msg, 1, addr);
1412}
1413
1427static inline int i2c_read_dt(const struct i2c_dt_spec *spec,
1428 uint8_t *buf, uint32_t num_bytes)
1429{
1430 return i2c_read(spec->bus, buf, num_bytes, spec->addr);
1431}
1432
1451static inline int i2c_write_read(const struct device *dev, uint16_t addr,
1452 const void *write_buf, size_t num_write,
1453 void *read_buf, size_t num_read)
1454{
1455 struct i2c_msg msg[2];
1456
1457 msg[0].buf = (uint8_t *)write_buf;
1458 msg[0].len = num_write;
1459 msg[0].flags = I2C_MSG_WRITE;
1460
1461 msg[1].buf = (uint8_t *)read_buf;
1462 msg[1].len = num_read;
1464
1465 return i2c_transfer(dev, msg, 2, addr);
1466}
1467
1485static inline int i2c_write_read_dt(const struct i2c_dt_spec *spec,
1486 const void *write_buf, size_t num_write,
1487 void *read_buf, size_t num_read)
1488{
1489 return i2c_write_read(spec->bus, spec->addr,
1490 write_buf, num_write,
1491 read_buf, num_read);
1492}
1493
1512static inline int i2c_burst_read(const struct device *dev,
1513 uint16_t dev_addr,
1514 uint8_t start_addr,
1515 uint8_t *buf,
1516 uint32_t num_bytes)
1517{
1518 return i2c_write_read(dev, dev_addr,
1519 &start_addr, sizeof(start_addr),
1520 buf, num_bytes);
1521}
1522
1537static inline int i2c_burst_read_dt(const struct i2c_dt_spec *spec,
1538 uint8_t start_addr,
1539 uint8_t *buf,
1540 uint32_t num_bytes)
1541{
1542 return i2c_burst_read(spec->bus, spec->addr,
1543 start_addr, buf, num_bytes);
1544}
1545
1567static inline int i2c_burst_write(const struct device *dev,
1568 uint16_t dev_addr,
1569 uint8_t start_addr,
1570 const uint8_t *buf,
1571 uint32_t num_bytes)
1572{
1573 struct i2c_msg msg[2];
1574
1575 msg[0].buf = &start_addr;
1576 msg[0].len = 1U;
1577 msg[0].flags = I2C_MSG_WRITE;
1578
1579 msg[1].buf = (uint8_t *)buf;
1580 msg[1].len = num_bytes;
1581 msg[1].flags = I2C_MSG_WRITE | I2C_MSG_STOP;
1582
1583 return i2c_transfer(dev, msg, 2, dev_addr);
1584}
1585
1600static inline int i2c_burst_write_dt(const struct i2c_dt_spec *spec,
1601 uint8_t start_addr,
1602 const uint8_t *buf,
1603 uint32_t num_bytes)
1604{
1605 return i2c_burst_write(spec->bus, spec->addr,
1606 start_addr, buf, num_bytes);
1607}
1608
1624static inline int i2c_reg_read_byte(const struct device *dev,
1625 uint16_t dev_addr,
1626 uint8_t reg_addr, uint8_t *value)
1627{
1628 return i2c_write_read(dev, dev_addr,
1629 &reg_addr, sizeof(reg_addr),
1630 value, sizeof(*value));
1631}
1632
1646static inline int i2c_reg_read_byte_dt(const struct i2c_dt_spec *spec,
1647 uint8_t reg_addr, uint8_t *value)
1648{
1649 return i2c_reg_read_byte(spec->bus, spec->addr, reg_addr, value);
1650}
1651
1670static inline int i2c_reg_write_byte(const struct device *dev,
1671 uint16_t dev_addr,
1672 uint8_t reg_addr, uint8_t value)
1673{
1674 uint8_t tx_buf[2] = {reg_addr, value};
1675
1676 return i2c_write(dev, tx_buf, 2, dev_addr);
1677}
1678
1692static inline int i2c_reg_write_byte_dt(const struct i2c_dt_spec *spec,
1693 uint8_t reg_addr, uint8_t value)
1694{
1695 return i2c_reg_write_byte(spec->bus, spec->addr, reg_addr, value);
1696}
1697
1717static inline int i2c_reg_update_byte(const struct device *dev,
1718 uint8_t dev_addr,
1719 uint8_t reg_addr, uint8_t mask,
1720 uint8_t value)
1721{
1722 uint8_t old_value, new_value;
1723 int rc;
1724
1725 rc = i2c_reg_read_byte(dev, dev_addr, reg_addr, &old_value);
1726 if (rc != 0) {
1727 return rc;
1728 }
1729
1730 new_value = (old_value & ~mask) | (value & mask);
1731 if (new_value == old_value) {
1732 return 0;
1733 }
1734
1735 return i2c_reg_write_byte(dev, dev_addr, reg_addr, new_value);
1736}
1737
1752static inline int i2c_reg_update_byte_dt(const struct i2c_dt_spec *spec,
1753 uint8_t reg_addr, uint8_t mask,
1754 uint8_t value)
1755{
1756 return i2c_reg_update_byte(spec->bus, spec->addr,
1757 reg_addr, mask, value);
1758}
1759
1760#ifdef __cplusplus
1761}
1762#endif
1763
1768#include <zephyr/syscalls/i2c.h>
1769
1770#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:925
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:1600
static int i2c_target_unregister(const struct device *dev, struct i2c_target_config *cfg)
Unregisters the provided config as Target device.
Definition i2c.h:1280
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:1451
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:1074
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:1357
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:1382
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:1485
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:957
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:1128
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:1512
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:1752
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:1427
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:1692
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:1670
#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:1646
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:760
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:998
#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:1195
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:1402
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:1537
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:1251
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:884
#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:1034
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:1717
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:1624
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:1567
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:1285
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:455
Runtime device structure (in ROM) per driver instance.
Definition device.h:510
void * data
Address of the device instance private data.
Definition device.h:520
const void * api
Address of the API structure exposed by the device instance.
Definition device.h:516
struct device_state * state
Address of the common device state.
Definition device.h:518
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:6122
API that an RTIO IO device should implement.
Definition rtio.h:524
Compute the mempool block index for a given pointer.
Definition rtio.h:514
struct rtio_sqe sqe
Definition rtio.h:515
An IO device with a function table for submitting requests.
Definition rtio.h:539
void * data
Definition rtio.h:544
A submission queue event.
Definition rtio.h:295
const struct rtio_iodev * iodev
Device to operation on.
Definition rtio.h:304
const uint8_t * buf
Buffer to write from.
Definition rtio.h:320
An RTIO context containing what can be viewed as a pair of queues.
Definition rtio.h:418