Zephyr Project API 4.2.99
A Scalable Open Source RTOS
Loading...
Searching...
No Matches
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
1089#define I2C_CAT2(x, y) x ## y
1090
1100#define I2C_DT_IODEV_DEFINE(name, node_id) \
1101 const struct i2c_dt_spec _i2c_dt_spec_##name = \
1102 I2C_DT_SPEC_GET(node_id); \
1103 RTIO_IODEV_DEFINE(name, &i2c_iodev_api, (void *)&_i2c_dt_spec_##name)
1104
1115#define I2C_IODEV_DEFINE(name, _bus, _addr) \
1116 const struct i2c_dt_spec I2C_CAT2(_i2c_dt_spec_, name) = { \
1117 .bus = DEVICE_DT_GET(_bus), \
1118 .addr = _addr, \
1119 }; \
1120 RTIO_IODEV_DEFINE(name, &i2c_iodev_api, (void *)&I2C_CAT2(_i2c_dt_spec_, name))
1121
1130static inline bool i2c_is_ready_iodev(const struct rtio_iodev *i2c_iodev)
1131{
1132 struct i2c_dt_spec *spec = (struct i2c_dt_spec *)i2c_iodev->data;
1133
1134 return i2c_is_ready_dt(spec);
1135}
1136
1149 struct rtio_iodev *iodev,
1150 const struct i2c_msg *msgs,
1151 uint8_t num_msgs);
1152
1165 uint8_t reg_addr, uint8_t data);
1166
1180 uint8_t start_addr, void *buf, size_t num_bytes);
1181
1182#endif /* CONFIG_I2C_RTIO */
1183
1197static inline int i2c_transfer_dt(const struct i2c_dt_spec *spec,
1198 struct i2c_msg *msgs, uint8_t num_msgs)
1199{
1200 return i2c_transfer(spec->bus, msgs, num_msgs, spec->addr);
1201}
1202
1215__syscall int i2c_recover_bus(const struct device *dev);
1216
1217static inline int z_impl_i2c_recover_bus(const struct device *dev)
1218{
1219 const struct i2c_driver_api *api =
1220 (const struct i2c_driver_api *)dev->api;
1221
1222 if (api->recover_bus == NULL) {
1223 return -ENOSYS;
1224 }
1225
1226 return api->recover_bus(dev);
1227}
1228
1253static inline int i2c_target_register(const struct device *dev,
1254 struct i2c_target_config *cfg)
1255{
1256 const struct i2c_driver_api *api =
1257 (const struct i2c_driver_api *)dev->api;
1258
1259 if (api->target_register == NULL) {
1260 return -ENOSYS;
1261 }
1262
1263 return api->target_register(dev, cfg);
1264}
1265
1282static inline int i2c_target_unregister(const struct device *dev,
1283 struct i2c_target_config *cfg)
1284{
1285 const struct i2c_driver_api *api =
1286 (const struct i2c_driver_api *)dev->api;
1287
1288 if (api->target_unregister == NULL) {
1289 return -ENOSYS;
1290 }
1291
1292 return api->target_unregister(dev, cfg);
1293}
1294
1308__syscall int i2c_target_driver_register(const struct device *dev);
1309
1310static inline int z_impl_i2c_target_driver_register(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_register(dev);
1316}
1317
1331__syscall int i2c_target_driver_unregister(const struct device *dev);
1332
1333static inline int z_impl_i2c_target_driver_unregister(const struct device *dev)
1334{
1335 const struct i2c_target_driver_api *api =
1336 (const struct i2c_target_driver_api *)dev->api;
1337
1338 return api->driver_unregister(dev);
1339}
1340
1341/*
1342 * Derived i2c APIs -- all implemented in terms of i2c_transfer()
1343 */
1344
1359static inline int i2c_write(const struct device *dev, const uint8_t *buf,
1360 uint32_t num_bytes, uint16_t addr)
1361{
1362 struct i2c_msg msg;
1363
1364 msg.buf = (uint8_t *)buf;
1365 msg.len = num_bytes;
1367
1368 return i2c_transfer(dev, &msg, 1, addr);
1369}
1370
1384static inline int i2c_write_dt(const struct i2c_dt_spec *spec,
1385 const uint8_t *buf, uint32_t num_bytes)
1386{
1387 return i2c_write(spec->bus, buf, num_bytes, spec->addr);
1388}
1389
1404static inline int i2c_read(const struct device *dev, uint8_t *buf,
1405 uint32_t num_bytes, uint16_t addr)
1406{
1407 struct i2c_msg msg;
1408
1409 msg.buf = buf;
1410 msg.len = num_bytes;
1412
1413 return i2c_transfer(dev, &msg, 1, addr);
1414}
1415
1429static inline int i2c_read_dt(const struct i2c_dt_spec *spec,
1430 uint8_t *buf, uint32_t num_bytes)
1431{
1432 return i2c_read(spec->bus, buf, num_bytes, spec->addr);
1433}
1434
1453static inline int i2c_write_read(const struct device *dev, uint16_t addr,
1454 const void *write_buf, size_t num_write,
1455 void *read_buf, size_t num_read)
1456{
1457 struct i2c_msg msg[2];
1458
1459 msg[0].buf = (uint8_t *)write_buf;
1460 msg[0].len = num_write;
1461 msg[0].flags = I2C_MSG_WRITE;
1462
1463 msg[1].buf = (uint8_t *)read_buf;
1464 msg[1].len = num_read;
1466
1467 return i2c_transfer(dev, msg, 2, addr);
1468}
1469
1487static inline int i2c_write_read_dt(const struct i2c_dt_spec *spec,
1488 const void *write_buf, size_t num_write,
1489 void *read_buf, size_t num_read)
1490{
1491 return i2c_write_read(spec->bus, spec->addr,
1492 write_buf, num_write,
1493 read_buf, num_read);
1494}
1495
1514static inline int i2c_burst_read(const struct device *dev,
1515 uint16_t dev_addr,
1516 uint8_t start_addr,
1517 uint8_t *buf,
1518 uint32_t num_bytes)
1519{
1520 return i2c_write_read(dev, dev_addr,
1521 &start_addr, sizeof(start_addr),
1522 buf, num_bytes);
1523}
1524
1539static inline int i2c_burst_read_dt(const struct i2c_dt_spec *spec,
1540 uint8_t start_addr,
1541 uint8_t *buf,
1542 uint32_t num_bytes)
1543{
1544 return i2c_burst_read(spec->bus, spec->addr,
1545 start_addr, buf, num_bytes);
1546}
1547
1569static inline int i2c_burst_write(const struct device *dev,
1570 uint16_t dev_addr,
1571 uint8_t start_addr,
1572 const uint8_t *buf,
1573 uint32_t num_bytes)
1574{
1575 struct i2c_msg msg[2];
1576
1577 msg[0].buf = &start_addr;
1578 msg[0].len = 1U;
1579 msg[0].flags = I2C_MSG_WRITE;
1580
1581 msg[1].buf = (uint8_t *)buf;
1582 msg[1].len = num_bytes;
1583 msg[1].flags = I2C_MSG_WRITE | I2C_MSG_STOP;
1584
1585 return i2c_transfer(dev, msg, 2, dev_addr);
1586}
1587
1602static inline int i2c_burst_write_dt(const struct i2c_dt_spec *spec,
1603 uint8_t start_addr,
1604 const uint8_t *buf,
1605 uint32_t num_bytes)
1606{
1607 return i2c_burst_write(spec->bus, spec->addr,
1608 start_addr, buf, num_bytes);
1609}
1610
1626static inline int i2c_reg_read_byte(const struct device *dev,
1627 uint16_t dev_addr,
1628 uint8_t reg_addr, uint8_t *value)
1629{
1630 return i2c_write_read(dev, dev_addr,
1631 &reg_addr, sizeof(reg_addr),
1632 value, sizeof(*value));
1633}
1634
1648static inline int i2c_reg_read_byte_dt(const struct i2c_dt_spec *spec,
1649 uint8_t reg_addr, uint8_t *value)
1650{
1651 return i2c_reg_read_byte(spec->bus, spec->addr, reg_addr, value);
1652}
1653
1672static inline int i2c_reg_write_byte(const struct device *dev,
1673 uint16_t dev_addr,
1674 uint8_t reg_addr, uint8_t value)
1675{
1676 uint8_t tx_buf[2] = {reg_addr, value};
1677
1678 return i2c_write(dev, tx_buf, 2, dev_addr);
1679}
1680
1694static inline int i2c_reg_write_byte_dt(const struct i2c_dt_spec *spec,
1695 uint8_t reg_addr, uint8_t value)
1696{
1697 return i2c_reg_write_byte(spec->bus, spec->addr, reg_addr, value);
1698}
1699
1719static inline int i2c_reg_update_byte(const struct device *dev,
1720 uint8_t dev_addr,
1721 uint8_t reg_addr, uint8_t mask,
1722 uint8_t value)
1723{
1724 uint8_t old_value, new_value;
1725 int rc;
1726
1727 rc = i2c_reg_read_byte(dev, dev_addr, reg_addr, &old_value);
1728 if (rc != 0) {
1729 return rc;
1730 }
1731
1732 new_value = (old_value & ~mask) | (value & mask);
1733 if (new_value == old_value) {
1734 return 0;
1735 }
1736
1737 return i2c_reg_write_byte(dev, dev_addr, reg_addr, new_value);
1738}
1739
1754static inline int i2c_reg_update_byte_dt(const struct i2c_dt_spec *spec,
1755 uint8_t reg_addr, uint8_t mask,
1756 uint8_t value)
1757{
1758 return i2c_reg_update_byte(spec->bus, spec->addr,
1759 reg_addr, mask, value);
1760}
1761
1762#ifdef __cplusplus
1763}
1764#endif
1765
1770#include <zephyr/syscalls/i2c.h>
1771
1772#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:1602
static int i2c_target_unregister(const struct device *dev, struct i2c_target_config *cfg)
Unregisters the provided config as Target device.
Definition i2c.h:1282
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:1453
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:1359
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:1384
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:1487
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:1130
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:1514
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:1754
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:1429
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:1694
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:1672
#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:1648
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:1197
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:1404
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:1539
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:1253
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:1719
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:1626
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:1569
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:6149
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