1 // Copyright 2023 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14 #include "pw_i2c/i2c_service.h"
15
16 #include <algorithm>
17 #include <chrono>
18
19 #include "pw_chrono/system_clock.h"
20 #include "pw_i2c/address.h"
21 #include "pw_i2c/initiator.h"
22 #include "pw_i2c/initiator_mock.h"
23 #include "pw_rpc/pwpb/test_method_context.h"
24 #include "pw_status/status.h"
25 #include "pw_unit_test/framework.h"
26
27 namespace pw::i2c {
28 namespace {
29
MakeSingletonSelector(Initiator * initiator)30 auto MakeSingletonSelector(Initiator* initiator) {
31 return [initiator](size_t pos) { return pos == 0 ? initiator : nullptr; };
32 }
33
34 constexpr auto kI2cTransactionTimeout =
35 chrono::SystemClock::for_at_least(std::chrono::milliseconds(100));
36
TEST(I2cServiceTest,I2cWriteSingleByteOk)37 TEST(I2cServiceTest, I2cWriteSingleByteOk) {
38 Vector<std::byte, 4> register_addr{};
39 Vector<std::byte, 4> register_value{};
40 constexpr auto kExpectWrite = bytes::Array<0x02, 0x03>();
41 register_addr.push_back(kExpectWrite[0]);
42 register_value.push_back(kExpectWrite[1]);
43 auto transactions = MakeExpectedTransactionArray({Transaction(
44 OkStatus(), Address{0x01}, kExpectWrite, {}, kI2cTransactionTimeout)});
45 MockInitiator i2c_initiator(transactions);
46
47 PW_PWPB_TEST_METHOD_CONTEXT(I2cService, I2cWrite)
48 context{MakeSingletonSelector(&i2c_initiator)};
49
50 context.call({.bus_index = 0,
51 .target_address = 0x01,
52 .register_address = register_addr,
53 .value = register_value});
54 EXPECT_TRUE(context.done());
55 EXPECT_EQ(context.status(), OkStatus());
56 EXPECT_EQ(i2c_initiator.Finalize(), OkStatus());
57 }
58
TEST(I2cServiceTest,I2cWriteMultiByteOk)59 TEST(I2cServiceTest, I2cWriteMultiByteOk) {
60 constexpr int kWriteSize = 4;
61 Vector<std::byte, kWriteSize> register_addr{};
62 Vector<std::byte, kWriteSize> register_value{};
63 constexpr auto kExpectWrite =
64 bytes::Array<0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09>();
65 std::copy(kExpectWrite.begin(),
66 kExpectWrite.begin() + kWriteSize,
67 std::back_inserter(register_addr));
68 std::copy(kExpectWrite.begin() + kWriteSize,
69 kExpectWrite.end(),
70 std::back_inserter(register_value));
71 auto transactions = MakeExpectedTransactionArray({Transaction(
72 OkStatus(), Address{0x01}, kExpectWrite, {}, kI2cTransactionTimeout)});
73 MockInitiator i2c_initiator(transactions);
74
75 PW_PWPB_TEST_METHOD_CONTEXT(I2cService, I2cWrite)
76 context{MakeSingletonSelector(&i2c_initiator)};
77
78 context.call({.bus_index = 0,
79 .target_address = 0x01,
80 .register_address = register_addr,
81 .value = register_value});
82 EXPECT_TRUE(context.done());
83 EXPECT_EQ(context.status(), OkStatus());
84 EXPECT_EQ(i2c_initiator.Finalize(), OkStatus());
85 }
86
TEST(I2cServiceTest,I2cWriteInvalidBusIndex)87 TEST(I2cServiceTest, I2cWriteInvalidBusIndex) {
88 Vector<std::byte, 4> register_addr{};
89 Vector<std::byte, 4> register_value{};
90
91 MockInitiator i2c_initiator({});
92
93 PW_PWPB_TEST_METHOD_CONTEXT(I2cService, I2cWrite)
94 context{MakeSingletonSelector(&i2c_initiator)};
95
96 context.call({.bus_index = 1,
97 .target_address = 0x01,
98 .register_address = register_addr,
99 .value = register_value});
100 EXPECT_TRUE(context.done());
101 EXPECT_EQ(context.status(), Status::InvalidArgument());
102 EXPECT_EQ(i2c_initiator.Finalize(), OkStatus());
103 }
104
TEST(I2cServiceTest,I2cReadSingleByteOk)105 TEST(I2cServiceTest, I2cReadSingleByteOk) {
106 constexpr auto kExpectWrite = bytes::Array<0x02>();
107 constexpr auto kExpectRead = bytes::Array<0x03>();
108 Vector<std::byte, 4> register_addr{};
109 register_addr.push_back(kExpectWrite[0]);
110
111 auto transactions =
112 MakeExpectedTransactionArray({Transaction(OkStatus(),
113 Address{0x01},
114 kExpectWrite,
115 kExpectRead,
116 kI2cTransactionTimeout)});
117 MockInitiator i2c_initiator(transactions);
118
119 PW_PWPB_TEST_METHOD_CONTEXT(I2cService, I2cRead)
120 context{MakeSingletonSelector(&i2c_initiator)};
121
122 context.call({.bus_index = 0,
123 .target_address = 0x01,
124 .register_address = register_addr,
125 .read_size = static_cast<uint32_t>(kExpectRead.size())});
126
127 EXPECT_TRUE(context.done());
128 EXPECT_EQ(context.status(), OkStatus());
129 for (size_t i = 0; i < kExpectRead.size(); ++i) {
130 EXPECT_EQ(kExpectRead[i], context.response().value[i]);
131 }
132 EXPECT_EQ(i2c_initiator.Finalize(), OkStatus());
133 }
134
TEST(I2cServiceTest,I2cReadMultiByteOk)135 TEST(I2cServiceTest, I2cReadMultiByteOk) {
136 constexpr auto kExpectWrite = bytes::Array<0x02, 0x04, 0x06, 0x08>();
137 constexpr auto kExpectRead = bytes::Array<0x03, 0x05, 0x07, 0x09>();
138 Vector<std::byte, 4> register_addr{};
139 std::copy(kExpectWrite.begin(),
140 kExpectWrite.end(),
141 std::back_inserter(register_addr));
142 auto transactions =
143 MakeExpectedTransactionArray({Transaction(OkStatus(),
144 Address{0x01},
145 kExpectWrite,
146 kExpectRead,
147 kI2cTransactionTimeout)});
148 MockInitiator i2c_initiator(transactions);
149
150 PW_PWPB_TEST_METHOD_CONTEXT(I2cService, I2cRead)
151 context{MakeSingletonSelector(&i2c_initiator)};
152
153 context.call({.bus_index = 0,
154 .target_address = 0x01,
155 .register_address = register_addr,
156 .read_size = static_cast<uint32_t>(kExpectRead.size())});
157
158 EXPECT_TRUE(context.done());
159 EXPECT_EQ(context.status(), OkStatus());
160 for (size_t i = 0; i < kExpectRead.size(); ++i) {
161 EXPECT_EQ(kExpectRead[i], context.response().value[i]);
162 }
163 EXPECT_EQ(i2c_initiator.Finalize(), OkStatus());
164 }
165
TEST(I2cServiceTest,I2cReadMaxByteOk)166 TEST(I2cServiceTest, I2cReadMaxByteOk) {
167 constexpr auto kExpectWrite = bytes::Array<0x02, 0x04, 0x06, 0x08>();
168 constexpr auto kExpectRead = bytes::Array<0x03, 0x05, 0x07, 0x09>();
169 static_assert(sizeof(kExpectRead) <= pwpb::I2cReadResponse::kValueMaxSize);
170
171 Vector<std::byte, 4> register_addr{};
172 std::copy(kExpectWrite.begin(),
173 kExpectWrite.end(),
174 std::back_inserter(register_addr));
175 auto transactions =
176 MakeExpectedTransactionArray({Transaction(OkStatus(),
177 Address{0x01},
178 kExpectWrite,
179 kExpectRead,
180 kI2cTransactionTimeout)});
181 MockInitiator i2c_initiator(transactions);
182
183 PW_PWPB_TEST_METHOD_CONTEXT(I2cService, I2cRead)
184 context{MakeSingletonSelector(&i2c_initiator)};
185
186 context.call({
187 .bus_index = 0,
188 .target_address = 0x01,
189 .register_address = register_addr,
190 .read_size = sizeof(kExpectRead),
191 });
192
193 EXPECT_TRUE(context.done());
194 EXPECT_EQ(context.status(), OkStatus());
195 // EXPECT_EQ(kExpectRead, context.response().value);
196 EXPECT_EQ(i2c_initiator.Finalize(), OkStatus());
197 }
198
TEST(I2cServiceTest,I2cReadMultiByteOutOfBounds)199 TEST(I2cServiceTest, I2cReadMultiByteOutOfBounds) {
200 pwpb::I2cReadResponse::Message response_message;
201 constexpr auto kMaxReadSize = response_message.value.max_size();
202 constexpr auto kRegisterAddr = bytes::Array<0x02, 0x04, 0x06, 0x08>();
203 Vector<std::byte, 4> register_addr{};
204 std::copy(kRegisterAddr.begin(),
205 kRegisterAddr.end(),
206 std::back_inserter(register_addr));
207 MockInitiator i2c_initiator({});
208
209 PW_PWPB_TEST_METHOD_CONTEXT(I2cService, I2cRead)
210 context{MakeSingletonSelector(&i2c_initiator)};
211
212 context.call({.bus_index = 0,
213 .target_address = 0x01,
214 .register_address = register_addr,
215 .read_size = kMaxReadSize + 1});
216
217 EXPECT_TRUE(context.done());
218 EXPECT_EQ(context.status(), Status::InvalidArgument());
219 EXPECT_EQ(i2c_initiator.Finalize(), OkStatus());
220 }
221
TEST(I2cServiceTest,I2cReadInvalidBusIndex)222 TEST(I2cServiceTest, I2cReadInvalidBusIndex) {
223 Vector<std::byte, 4> register_addr{};
224 MockInitiator i2c_initiator({});
225
226 PW_PWPB_TEST_METHOD_CONTEXT(I2cService, I2cRead)
227 context{MakeSingletonSelector(&i2c_initiator)};
228
229 context.call({.bus_index = 1,
230 .target_address = 0x01,
231 .register_address = register_addr,
232 .read_size = 1});
233
234 EXPECT_TRUE(context.done());
235 EXPECT_EQ(context.status(), Status::InvalidArgument());
236 EXPECT_EQ(i2c_initiator.Finalize(), OkStatus());
237 }
238
239 } // namespace
240 } // namespace pw::i2c
241