Zephyr API Documentation  3.7.0-rc3
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
184struct i2c_msg {
187
190
193};
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
448
451
454
457};
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(struct i2c_msg *msg)
481{
482 return (msg->flags & I2C_MSG_READ) == I2C_MSG_READ;
483}
484
511void i2c_dump_msgs_rw(const struct device *dev, const struct i2c_msg *msgs, uint8_t num_msgs,
512 uint16_t addr, bool dump_read);
513
528static inline void i2c_dump_msgs(const struct device *dev, const struct i2c_msg *msgs,
529 uint8_t num_msgs, uint16_t addr)
530{
531 i2c_dump_msgs_rw(dev, msgs, num_msgs, addr, false);
532}
533
534#if defined(CONFIG_I2C_STATS) || defined(__DOXYGEN__)
535
536#include <zephyr/stats/stats.h>
537
541STATS_SECT_ENTRY32(bytes_read)
542STATS_SECT_ENTRY32(bytes_written)
543STATS_SECT_ENTRY32(message_count)
544STATS_SECT_ENTRY32(transfer_call_count)
546
548STATS_NAME(i2c, bytes_read)
549STATS_NAME(i2c, bytes_written)
550STATS_NAME(i2c, message_count)
551STATS_NAME(i2c, transfer_call_count)
552STATS_NAME_END(i2c);
553
562 struct stats_i2c stats;
563};
564
572static inline void i2c_xfer_stats(const struct device *dev, struct i2c_msg *msgs,
573 uint8_t num_msgs)
574{
575 struct i2c_device_state *state =
577 uint32_t bytes_read = 0U;
578 uint32_t bytes_written = 0U;
579
580 STATS_INC(state->stats, transfer_call_count);
581 STATS_INCN(state->stats, message_count, num_msgs);
582 for (uint8_t i = 0U; i < num_msgs; i++) {
583 if (msgs[i].flags & I2C_MSG_READ) {
584 bytes_read += msgs[i].len;
585 } else {
586 bytes_written += msgs[i].len;
587 }
588 }
589 STATS_INCN(state->stats, bytes_read, bytes_read);
590 STATS_INCN(state->stats, bytes_written, bytes_written);
591}
592
598#define Z_I2C_DEVICE_STATE_DEFINE(dev_id) \
599 static struct i2c_device_state Z_DEVICE_STATE_NAME(dev_id) \
600 __attribute__((__section__(".z_devstate")))
601
608#define Z_I2C_INIT_FN(dev_id, init_fn) \
609 static inline int UTIL_CAT(dev_id, _init)(const struct device *dev) \
610 { \
611 struct i2c_device_state *state = \
612 CONTAINER_OF(dev->state, struct i2c_device_state, devstate); \
613 stats_init(&state->stats.s_hdr, STATS_SIZE_32, 4, \
614 STATS_NAME_INIT_PARMS(i2c)); \
615 stats_register(dev->name, &(state->stats.s_hdr)); \
616 if (!is_null_no_warn(init_fn)) { \
617 return init_fn(dev); \
618 } \
619 \
620 return 0; \
621 }
622
652#define I2C_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
653 prio, api, ...) \
654 Z_I2C_DEVICE_STATE_DEFINE(Z_DEVICE_DT_DEV_ID(node_id)); \
655 Z_I2C_INIT_FN(Z_DEVICE_DT_DEV_ID(node_id), init_fn) \
656 Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
657 DEVICE_DT_NAME(node_id), \
658 &UTIL_CAT(Z_DEVICE_DT_DEV_ID(node_id), _init), \
659 pm, data, config, level, prio, api, \
660 &(Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_ID(node_id)).devstate), \
661 __VA_ARGS__)
662
663#else /* CONFIG_I2C_STATS */
664
665static inline void i2c_xfer_stats(const struct device *dev, struct i2c_msg *msgs,
666 uint8_t num_msgs)
667{
668 ARG_UNUSED(dev);
669 ARG_UNUSED(msgs);
670 ARG_UNUSED(num_msgs);
671}
672
673#define I2C_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
674 prio, api, ...) \
675 DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
676 prio, api, __VA_ARGS__)
677
678#endif /* CONFIG_I2C_STATS */
679
688#define I2C_DEVICE_DT_INST_DEFINE(inst, ...) \
689 I2C_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
690
691
702__syscall int i2c_configure(const struct device *dev, uint32_t dev_config);
703
704static inline int z_impl_i2c_configure(const struct device *dev,
705 uint32_t dev_config)
706{
707 const struct i2c_driver_api *api =
708 (const struct i2c_driver_api *)dev->api;
709
710 return api->configure(dev, dev_config);
711}
712
733__syscall int i2c_get_config(const struct device *dev, uint32_t *dev_config);
734
735static inline int z_impl_i2c_get_config(const struct device *dev, uint32_t *dev_config)
736{
737 const struct i2c_driver_api *api = (const struct i2c_driver_api *)dev->api;
738
739 if (api->get_config == NULL) {
740 return -ENOSYS;
741 }
742
743 return api->get_config(dev, dev_config);
744}
745
777__syscall int i2c_transfer(const struct device *dev,
778 struct i2c_msg *msgs, uint8_t num_msgs,
779 uint16_t addr);
780
781static inline int z_impl_i2c_transfer(const struct device *dev,
782 struct i2c_msg *msgs, uint8_t num_msgs,
783 uint16_t addr)
784{
785 const struct i2c_driver_api *api =
786 (const struct i2c_driver_api *)dev->api;
787
788 int res = api->transfer(dev, msgs, num_msgs, addr);
789
790 i2c_xfer_stats(dev, msgs, num_msgs);
791
792 if (IS_ENABLED(CONFIG_I2C_DUMP_MESSAGES)) {
793 i2c_dump_msgs_rw(dev, msgs, num_msgs, addr, true);
794 }
795
796 return res;
797}
798
799#if defined(CONFIG_I2C_CALLBACK) || defined(__DOXYGEN__)
800
823static inline int i2c_transfer_cb(const struct device *dev,
824 struct i2c_msg *msgs,
825 uint8_t num_msgs,
826 uint16_t addr,
828 void *userdata)
829{
830 const struct i2c_driver_api *api = (const struct i2c_driver_api *)dev->api;
831
832 if (api->transfer_cb == NULL) {
833 return -ENOSYS;
834 }
835
836 return api->transfer_cb(dev, msgs, num_msgs, addr, cb, userdata);
837}
838
854static inline int i2c_transfer_cb_dt(const struct i2c_dt_spec *spec,
855 struct i2c_msg *msgs,
856 uint8_t num_msgs,
858 void *userdata)
859{
860 return i2c_transfer_cb(spec->bus, msgs, num_msgs, spec->addr, cb, userdata);
861}
862
886static inline int i2c_write_read_cb(const struct device *dev, struct i2c_msg *msgs,
887 uint8_t num_msgs, uint16_t addr, const void *write_buf,
888 size_t num_write, void *read_buf, size_t num_read,
889 i2c_callback_t cb, void *userdata)
890{
891 if ((msgs == NULL) || (num_msgs != 2)) {
892 return -EINVAL;
893 }
894
895 msgs[0].buf = (uint8_t *)write_buf;
896 msgs[0].len = num_write;
897 msgs[0].flags = I2C_MSG_WRITE;
898
899 msgs[1].buf = (uint8_t *)read_buf;
900 msgs[1].len = num_read;
902
903 return i2c_transfer_cb(dev, msgs, num_msgs, addr, cb, userdata);
904}
905
927static inline int i2c_write_read_cb_dt(const struct i2c_dt_spec *spec, struct i2c_msg *msgs,
928 uint8_t num_msgs, const void *write_buf, size_t num_write,
929 void *read_buf, size_t num_read, i2c_callback_t cb,
930 void *userdata)
931{
932 return i2c_write_read_cb(spec->bus, msgs, num_msgs, spec->addr, write_buf, num_write,
933 read_buf, num_read, cb, userdata);
934}
935
936#if defined(CONFIG_POLL) || defined(__DOXYGEN__)
937
939void z_i2c_transfer_signal_cb(const struct device *dev, int result, void *userdata);
963static inline int i2c_transfer_signal(const struct device *dev,
964 struct i2c_msg *msgs,
965 uint8_t num_msgs,
966 uint16_t addr,
967 struct k_poll_signal *sig)
968{
969 const struct i2c_driver_api *api = (const struct i2c_driver_api *)dev->api;
970
971 if (api->transfer_cb == NULL) {
972 return -ENOSYS;
973 }
974
975 return api->transfer_cb(dev, msgs, num_msgs, addr, z_i2c_transfer_signal_cb, sig);
976}
977
978#endif /* CONFIG_POLL */
979
980#endif /* CONFIG_I2C_CALLBACK */
981
982
983#if defined(CONFIG_I2C_RTIO) || defined(__DOXYGEN__)
984
991static inline void i2c_iodev_submit(struct rtio_iodev_sqe *iodev_sqe)
992{
993 const struct i2c_dt_spec *dt_spec = (const struct i2c_dt_spec *)iodev_sqe->sqe.iodev->data;
994 const struct device *dev = dt_spec->bus;
995 const struct i2c_driver_api *api = (const struct i2c_driver_api *)dev->api;
996
997 api->iodev_submit(dt_spec->bus, iodev_sqe);
998}
999
1000extern const struct rtio_iodev_api i2c_iodev_api;
1001
1011#define I2C_DT_IODEV_DEFINE(name, node_id) \
1012 const struct i2c_dt_spec _i2c_dt_spec_##name = \
1013 I2C_DT_SPEC_GET(node_id); \
1014 RTIO_IODEV_DEFINE(name, &i2c_iodev_api, (void *)&_i2c_dt_spec_##name)
1015
1026#define I2C_IODEV_DEFINE(name, _bus, _addr) \
1027 const struct i2c_dt_spec _i2c_dt_spec_##name = { \
1028 .bus = DEVICE_DT_GET(_bus), \
1029 .addr = _addr, \
1030 }; \
1031 RTIO_IODEV_DEFINE(name, &i2c_iodev_api, (void *)&_i2c_dt_spec_##name)
1032
1045 struct rtio_iodev *iodev,
1046 const struct i2c_msg *msgs,
1047 uint8_t num_msgs);
1048
1049#endif /* CONFIG_I2C_RTIO */
1050
1064static inline int i2c_transfer_dt(const struct i2c_dt_spec *spec,
1065 struct i2c_msg *msgs, uint8_t num_msgs)
1066{
1067 return i2c_transfer(spec->bus, msgs, num_msgs, spec->addr);
1068}
1069
1082__syscall int i2c_recover_bus(const struct device *dev);
1083
1084static inline int z_impl_i2c_recover_bus(const struct device *dev)
1085{
1086 const struct i2c_driver_api *api =
1087 (const struct i2c_driver_api *)dev->api;
1088
1089 if (api->recover_bus == NULL) {
1090 return -ENOSYS;
1091 }
1092
1093 return api->recover_bus(dev);
1094}
1095
1120static inline int i2c_target_register(const struct device *dev,
1121 struct i2c_target_config *cfg)
1122{
1123 const struct i2c_driver_api *api =
1124 (const struct i2c_driver_api *)dev->api;
1125
1126 if (api->target_register == NULL) {
1127 return -ENOSYS;
1128 }
1129
1130 return api->target_register(dev, cfg);
1131}
1132
1149static inline int i2c_target_unregister(const struct device *dev,
1150 struct i2c_target_config *cfg)
1151{
1152 const struct i2c_driver_api *api =
1153 (const struct i2c_driver_api *)dev->api;
1154
1155 if (api->target_unregister == NULL) {
1156 return -ENOSYS;
1157 }
1158
1159 return api->target_unregister(dev, cfg);
1160}
1161
1175__syscall int i2c_target_driver_register(const struct device *dev);
1176
1177static inline int z_impl_i2c_target_driver_register(const struct device *dev)
1178{
1179 const struct i2c_target_driver_api *api =
1180 (const struct i2c_target_driver_api *)dev->api;
1181
1182 return api->driver_register(dev);
1183}
1184
1198__syscall int i2c_target_driver_unregister(const struct device *dev);
1199
1200static inline int z_impl_i2c_target_driver_unregister(const struct device *dev)
1201{
1202 const struct i2c_target_driver_api *api =
1203 (const struct i2c_target_driver_api *)dev->api;
1204
1205 return api->driver_unregister(dev);
1206}
1207
1208/*
1209 * Derived i2c APIs -- all implemented in terms of i2c_transfer()
1210 */
1211
1226static inline int i2c_write(const struct device *dev, const uint8_t *buf,
1227 uint32_t num_bytes, uint16_t addr)
1228{
1229 struct i2c_msg msg;
1230
1231 msg.buf = (uint8_t *)buf;
1232 msg.len = num_bytes;
1234
1235 return i2c_transfer(dev, &msg, 1, addr);
1236}
1237
1251static inline int i2c_write_dt(const struct i2c_dt_spec *spec,
1252 const uint8_t *buf, uint32_t num_bytes)
1253{
1254 return i2c_write(spec->bus, buf, num_bytes, spec->addr);
1255}
1256
1271static inline int i2c_read(const struct device *dev, uint8_t *buf,
1272 uint32_t num_bytes, uint16_t addr)
1273{
1274 struct i2c_msg msg;
1275
1276 msg.buf = buf;
1277 msg.len = num_bytes;
1279
1280 return i2c_transfer(dev, &msg, 1, addr);
1281}
1282
1296static inline int i2c_read_dt(const struct i2c_dt_spec *spec,
1297 uint8_t *buf, uint32_t num_bytes)
1298{
1299 return i2c_read(spec->bus, buf, num_bytes, spec->addr);
1300}
1301
1320static inline int i2c_write_read(const struct device *dev, uint16_t addr,
1321 const void *write_buf, size_t num_write,
1322 void *read_buf, size_t num_read)
1323{
1324 struct i2c_msg msg[2];
1325
1326 msg[0].buf = (uint8_t *)write_buf;
1327 msg[0].len = num_write;
1328 msg[0].flags = I2C_MSG_WRITE;
1329
1330 msg[1].buf = (uint8_t *)read_buf;
1331 msg[1].len = num_read;
1333
1334 return i2c_transfer(dev, msg, 2, addr);
1335}
1336
1354static inline int i2c_write_read_dt(const struct i2c_dt_spec *spec,
1355 const void *write_buf, size_t num_write,
1356 void *read_buf, size_t num_read)
1357{
1358 return i2c_write_read(spec->bus, spec->addr,
1359 write_buf, num_write,
1360 read_buf, num_read);
1361}
1362
1381static inline int i2c_burst_read(const struct device *dev,
1382 uint16_t dev_addr,
1383 uint8_t start_addr,
1384 uint8_t *buf,
1385 uint32_t num_bytes)
1386{
1387 return i2c_write_read(dev, dev_addr,
1388 &start_addr, sizeof(start_addr),
1389 buf, num_bytes);
1390}
1391
1406static inline int i2c_burst_read_dt(const struct i2c_dt_spec *spec,
1407 uint8_t start_addr,
1408 uint8_t *buf,
1409 uint32_t num_bytes)
1410{
1411 return i2c_burst_read(spec->bus, spec->addr,
1412 start_addr, buf, num_bytes);
1413}
1414
1436static inline int i2c_burst_write(const struct device *dev,
1437 uint16_t dev_addr,
1438 uint8_t start_addr,
1439 const uint8_t *buf,
1440 uint32_t num_bytes)
1441{
1442 struct i2c_msg msg[2];
1443
1444 msg[0].buf = &start_addr;
1445 msg[0].len = 1U;
1446 msg[0].flags = I2C_MSG_WRITE;
1447
1448 msg[1].buf = (uint8_t *)buf;
1449 msg[1].len = num_bytes;
1450 msg[1].flags = I2C_MSG_WRITE | I2C_MSG_STOP;
1451
1452 return i2c_transfer(dev, msg, 2, dev_addr);
1453}
1454
1469static inline int i2c_burst_write_dt(const struct i2c_dt_spec *spec,
1470 uint8_t start_addr,
1471 const uint8_t *buf,
1472 uint32_t num_bytes)
1473{
1474 return i2c_burst_write(spec->bus, spec->addr,
1475 start_addr, buf, num_bytes);
1476}
1477
1493static inline int i2c_reg_read_byte(const struct device *dev,
1494 uint16_t dev_addr,
1495 uint8_t reg_addr, uint8_t *value)
1496{
1497 return i2c_write_read(dev, dev_addr,
1498 &reg_addr, sizeof(reg_addr),
1499 value, sizeof(*value));
1500}
1501
1515static inline int i2c_reg_read_byte_dt(const struct i2c_dt_spec *spec,
1516 uint8_t reg_addr, uint8_t *value)
1517{
1518 return i2c_reg_read_byte(spec->bus, spec->addr, reg_addr, value);
1519}
1520
1539static inline int i2c_reg_write_byte(const struct device *dev,
1540 uint16_t dev_addr,
1541 uint8_t reg_addr, uint8_t value)
1542{
1543 uint8_t tx_buf[2] = {reg_addr, value};
1544
1545 return i2c_write(dev, tx_buf, 2, dev_addr);
1546}
1547
1561static inline int i2c_reg_write_byte_dt(const struct i2c_dt_spec *spec,
1562 uint8_t reg_addr, uint8_t value)
1563{
1564 return i2c_reg_write_byte(spec->bus, spec->addr, reg_addr, value);
1565}
1566
1586static inline int i2c_reg_update_byte(const struct device *dev,
1587 uint8_t dev_addr,
1588 uint8_t reg_addr, uint8_t mask,
1589 uint8_t value)
1590{
1591 uint8_t old_value, new_value;
1592 int rc;
1593
1594 rc = i2c_reg_read_byte(dev, dev_addr, reg_addr, &old_value);
1595 if (rc != 0) {
1596 return rc;
1597 }
1598
1599 new_value = (old_value & ~mask) | (value & mask);
1600 if (new_value == old_value) {
1601 return 0;
1602 }
1603
1604 return i2c_reg_write_byte(dev, dev_addr, reg_addr, new_value);
1605}
1606
1621static inline int i2c_reg_update_byte_dt(const struct i2c_dt_spec *spec,
1622 uint8_t reg_addr, uint8_t mask,
1623 uint8_t value)
1624{
1625 return i2c_reg_update_byte(spec->bus, spec->addr,
1626 reg_addr, mask, value);
1627}
1628
1629#ifdef __cplusplus
1630}
1631#endif
1632
1637#include <zephyr/syscalls/i2c.h>
1638
1639#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:854
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:1469
static int i2c_target_unregister(const struct device *dev, struct i2c_target_config *cfg)
Unregisters the provided config as Target device.
Definition: i2c.h:1149
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:1320
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:991
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:1226
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:1251
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:1354
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:886
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 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:1381
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
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:1621
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:1296
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:1561
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:1539
#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:1515
int i2c_configure(const struct device *dev, uint32_t dev_config)
Configure operation of a host controller.
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:927
#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:1064
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:1271
static bool i2c_is_read_op(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:1406
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:1120
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:823
#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:572
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:528
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:963
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:1586
const struct rtio_iodev_api i2c_iodev_api
#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:1493
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:1436
static bool i2c_is_ready_dt(const struct i2c_dt_spec *spec)
Validate that I2C bus is ready.
Definition: i2c.h:467
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:124
#define CONTAINER_OF(ptr, type, field)
Get a pointer to a structure containing the element.
Definition: util.h:268
#define EINVAL
Invalid argument.
Definition: errno.h:60
#define ENOSYS
Function not implemented.
Definition: errno.h:82
Public kernel APIs.
flags
Definition: parser.h:96
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:371
Runtime device structure (in ROM) per driver instance.
Definition: device.h:403
void * data
Address of the device instance private data.
Definition: device.h:413
const void * api
Address of the API structure exposed by the device instance.
Definition: device.h:409
struct device_state * state
Address of the common device state.
Definition: device.h:411
I2C specific device state which allows for i2c device class specific additions.
Definition: i2c.h:560
struct stats_i2c stats
Definition: i2c.h:562
struct device_state devstate
Definition: i2c.h:561
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:5691
API that an RTIO IO device should implement.
Definition: rtio.h:433
Compute the mempool block index for a given pointer.
Definition: rtio.h:423
struct rtio_sqe sqe
Definition: rtio.h:424
An IO device with a function table for submitting requests.
Definition: rtio.h:448
void * data
Definition: rtio.h:453
A submission queue event.
Definition: rtio.h:232
const struct rtio_iodev * iodev
Device to operation on.
Definition: rtio.h:243
An RTIO context containing what can be viewed as a pair of queues.
Definition: rtio.h:327