1 /*
2 * Copyright (c) 2022 Vestas Wind Systems A/S
3 * Copyright (c) 2019 Alexander Wachter
4 *
5 * SPDX-License-Identifier: Apache-2.0
6 */
7
8 #include <zephyr/drivers/can.h>
9 #include <zephyr/ztest.h>
10
11 #include "common.h"
12
13 /**
14 * @addtogroup t_can_driver
15 * @{
16 * @defgroup t_can_classic test_can_classic
17 * @}
18 */
19
20 /**
21 * @brief Standard (11-bit) CAN ID transmit callback 1.
22 *
23 * See @a can_tx_callback_t() for argument description.
24 */
tx_std_callback_1(const struct device * dev,int error,void * user_data)25 static void tx_std_callback_1(const struct device *dev, int error, void *user_data)
26 {
27 const struct can_frame *frame = user_data;
28
29 k_sem_give(&tx_callback_sem);
30
31 zassert_equal(dev, can_dev, "CAN device does not match");
32 zassert_equal(frame->id, TEST_CAN_STD_ID_1, "ID does not match");
33 }
34
35 /**
36 * @brief Standard (11-bit) CAN ID transmit callback 2.
37 *
38 * See @a can_tx_callback_t() for argument description.
39 */
tx_std_callback_2(const struct device * dev,int error,void * user_data)40 static void tx_std_callback_2(const struct device *dev, int error, void *user_data)
41 {
42 const struct can_frame *frame = user_data;
43
44 k_sem_give(&tx_callback_sem);
45
46 zassert_equal(dev, can_dev, "CAN device does not match");
47 zassert_equal(frame->id, TEST_CAN_STD_ID_2, "ID does not match");
48 }
49
50 /**
51 * @brief Extended (29-bit) CAN ID transmit callback 1.
52 *
53 * See @a can_tx_callback_t() for argument description.
54 */
tx_ext_callback_1(const struct device * dev,int error,void * user_data)55 static void tx_ext_callback_1(const struct device *dev, int error, void *user_data)
56 {
57 const struct can_frame *frame = user_data;
58
59 k_sem_give(&tx_callback_sem);
60
61 zassert_equal(dev, can_dev, "CAN device does not match");
62 zassert_equal(frame->id, TEST_CAN_EXT_ID_1, "ID does not match");
63 }
64
65 /**
66 * @brief Extended (29-bit) CAN ID transmit callback 2.
67 *
68 * See @a can_tx_callback_t() for argument description.
69 */
tx_ext_callback_2(const struct device * dev,int error,void * user_data)70 static void tx_ext_callback_2(const struct device *dev, int error, void *user_data)
71 {
72 const struct can_frame *frame = user_data;
73
74 k_sem_give(&tx_callback_sem);
75
76 zassert_equal(dev, can_dev, "CAN device does not match");
77 zassert_equal(frame->id, TEST_CAN_EXT_ID_2, "ID does not match");
78 }
79
80 /**
81 * @brief Standard (11-bit) CAN ID receive callback 1.
82 *
83 * See @a can_rx_callback_t() for argument description.
84 */
rx_std_callback_1(const struct device * dev,struct can_frame * frame,void * user_data)85 static void rx_std_callback_1(const struct device *dev, struct can_frame *frame,
86 void *user_data)
87 {
88 struct can_filter *filter = user_data;
89
90 assert_frame_equal(frame, &test_std_frame_1, 0);
91 zassert_equal(dev, can_dev, "CAN device does not match");
92 zassert_equal_ptr(filter, &test_std_filter_1, "filter does not match");
93
94 k_sem_give(&rx_callback_sem);
95 }
96
97 /**
98 * @brief Standard (11-bit) CAN ID receive callback 2.
99 *
100 * See @a can_rx_callback_t() for argument description.
101 */
rx_std_callback_2(const struct device * dev,struct can_frame * frame,void * user_data)102 static void rx_std_callback_2(const struct device *dev, struct can_frame *frame,
103 void *user_data)
104 {
105 struct can_filter *filter = user_data;
106
107 assert_frame_equal(frame, &test_std_frame_2, 0);
108 zassert_equal(dev, can_dev, "CAN device does not match");
109 zassert_equal_ptr(filter, &test_std_filter_2, "filter does not match");
110
111 k_sem_give(&rx_callback_sem);
112 }
113
114 /**
115 * @brief Standard (11-bit) masked CAN ID receive callback 1.
116 *
117 * See @a can_rx_callback_t() for argument description.
118 */
rx_std_mask_callback_1(const struct device * dev,struct can_frame * frame,void * user_data)119 static void rx_std_mask_callback_1(const struct device *dev, struct can_frame *frame,
120 void *user_data)
121 {
122 struct can_filter *filter = user_data;
123
124 assert_frame_equal(frame, &test_std_frame_1, 0x0F);
125 zassert_equal(dev, can_dev, "CAN device does not match");
126 zassert_equal_ptr(filter, &test_std_masked_filter_1, "filter does not match");
127
128 k_sem_give(&rx_callback_sem);
129 }
130
131 /**
132 * @brief Standard (11-bit) masked CAN ID receive callback 2.
133 *
134 * See @a can_rx_callback_t() for argument description.
135 */
rx_std_mask_callback_2(const struct device * dev,struct can_frame * frame,void * user_data)136 static void rx_std_mask_callback_2(const struct device *dev, struct can_frame *frame,
137 void *user_data)
138 {
139 struct can_filter *filter = user_data;
140
141 assert_frame_equal(frame, &test_std_frame_2, 0x0F);
142 zassert_equal(dev, can_dev, "CAN device does not match");
143 zassert_equal_ptr(filter, &test_std_masked_filter_2, "filter does not match");
144
145 k_sem_give(&rx_callback_sem);
146 }
147
148 /**
149 * @brief Extended (29-bit) CAN ID receive callback 1.
150 *
151 * See @a can_rx_callback_t() for argument description.
152 */
rx_ext_callback_1(const struct device * dev,struct can_frame * frame,void * user_data)153 static void rx_ext_callback_1(const struct device *dev, struct can_frame *frame,
154 void *user_data)
155 {
156 struct can_filter *filter = user_data;
157
158 assert_frame_equal(frame, &test_ext_frame_1, 0);
159 zassert_equal(dev, can_dev, "CAN device does not match");
160 zassert_equal_ptr(filter, &test_ext_filter_1, "filter does not match");
161
162 k_sem_give(&rx_callback_sem);
163 }
164
165 /**
166 * @brief Extended (29-bit) CAN ID receive callback 2.
167 *
168 * See @a can_rx_callback_t() for argument description.
169 */
rx_ext_callback_2(const struct device * dev,struct can_frame * frame,void * user_data)170 static void rx_ext_callback_2(const struct device *dev, struct can_frame *frame,
171 void *user_data)
172 {
173 struct can_filter *filter = user_data;
174
175 assert_frame_equal(frame, &test_ext_frame_2, 0);
176 zassert_equal(dev, can_dev, "CAN device does not match");
177 zassert_equal_ptr(filter, &test_ext_filter_2, "filter does not match");
178
179 k_sem_give(&rx_callback_sem);
180 }
181
182 /**
183 * @brief Extended (29-bit) masked CAN ID receive callback 1.
184 *
185 * See @a can_rx_callback_t() for argument description.
186 */
rx_ext_mask_callback_1(const struct device * dev,struct can_frame * frame,void * user_data)187 static void rx_ext_mask_callback_1(const struct device *dev, struct can_frame *frame,
188 void *user_data)
189 {
190 struct can_filter *filter = user_data;
191
192 assert_frame_equal(frame, &test_ext_frame_1, 0x0F);
193 zassert_equal(dev, can_dev, "CAN device does not match");
194 zassert_equal_ptr(filter, &test_ext_masked_filter_1, "filter does not match");
195
196 k_sem_give(&rx_callback_sem);
197 }
198
199 /**
200 * @brief Extended (29-bit) masked CAN ID receive callback 2.
201 *
202 * See @a can_rx_callback_t() for argument description.
203 */
rx_ext_mask_callback_2(const struct device * dev,struct can_frame * frame,void * user_data)204 static void rx_ext_mask_callback_2(const struct device *dev, struct can_frame *frame,
205 void *user_data)
206 {
207 struct can_filter *filter = user_data;
208
209 assert_frame_equal(frame, &test_ext_frame_2, 0x0F);
210 zassert_equal(dev, can_dev, "CAN device does not match");
211 zassert_equal_ptr(filter, &test_ext_masked_filter_2, "filter does not match");
212
213 k_sem_give(&rx_callback_sem);
214 }
215
216 /**
217 * @brief Send a CAN test frame with asserts.
218 *
219 * This function will block until the frame is transmitted or a test timeout
220 * occurs.
221 *
222 * @param dev Pointer to the device structure for the driver instance.
223 * @param frame Pointer to the CAN frame to send.
224 */
send_test_frame(const struct device * dev,const struct can_frame * frame)225 static void send_test_frame(const struct device *dev, const struct can_frame *frame)
226 {
227 int err;
228
229 err = can_send(dev, frame, TEST_SEND_TIMEOUT, NULL, NULL);
230 zassert_not_equal(err, -EBUSY, "arbitration lost in loopback mode");
231 zassert_equal(err, 0, "failed to send frame (err %d)", err);
232 }
233
234 /**
235 * @brief Send a CAN test frame with asserts.
236 *
237 * This function will block until the frame is queued or a test timeout
238 * occurs.
239 *
240 * @param dev Pointer to the device structure for the driver instance.
241 * @param frame Pointer to the CAN frame to send.
242 * @param callback Transmit callback function.
243 */
send_test_frame_nowait(const struct device * dev,const struct can_frame * frame,can_tx_callback_t callback)244 static void send_test_frame_nowait(const struct device *dev, const struct can_frame *frame,
245 can_tx_callback_t callback)
246 {
247 int err;
248
249 err = can_send(dev, frame, TEST_SEND_TIMEOUT, callback, (void *)frame);
250 zassert_not_equal(err, -EBUSY, "arbitration lost in loopback mode");
251 zassert_equal(err, 0, "failed to send frame (err %d)", err);
252 }
253
254 /**
255 * @brief Add a CAN message queue with asserts.
256 *
257 * @param dev Pointer to the device structure for the driver instance.
258 * @param filter CAN filter for the CAN message queue.
259 *
260 * @return CAN filter ID.
261 */
add_rx_msgq(const struct device * dev,const struct can_filter * filter)262 static inline int add_rx_msgq(const struct device *dev, const struct can_filter *filter)
263 {
264 int filter_id;
265
266 filter_id = can_add_rx_filter_msgq(dev, &can_msgq, filter);
267 zassert_not_equal(filter_id, -ENOSPC, "no filters available");
268 zassert_true(filter_id >= 0, "negative filter number");
269
270 return filter_id;
271 }
272
273 /**
274 * @brief Add a CAN filter with asserts.
275 *
276 * @param dev Pointer to the device structure for the driver instance.
277 * @param filter CAN filter.
278 * @param callback Receive callback function.
279 *
280 * @return CAN filter ID.
281 */
add_rx_filter(const struct device * dev,const struct can_filter * filter,can_rx_callback_t callback)282 static inline int add_rx_filter(const struct device *dev,
283 const struct can_filter *filter,
284 can_rx_callback_t callback)
285 {
286 int filter_id;
287
288 k_sem_reset(&rx_callback_sem);
289
290 filter_id = can_add_rx_filter(dev, callback, (void *)filter, filter);
291 zassert_not_equal(filter_id, -ENOSPC, "no filters available");
292 zassert_true(filter_id >= 0, "negative filter number");
293
294 return filter_id;
295 }
296
297 /**
298 * @brief Perform a send/receive test with a set of CAN ID filters and CAN frames.
299 *
300 * @param filter1 CAN filter 1
301 * @param filter2 CAN filter 2
302 * @param frame1 CAN frame 1
303 * @param frame2 CAN frame 2
304 */
send_receive(const struct can_filter * filter1,const struct can_filter * filter2,const struct can_frame * frame1,const struct can_frame * frame2)305 static void send_receive(const struct can_filter *filter1,
306 const struct can_filter *filter2,
307 const struct can_frame *frame1,
308 const struct can_frame *frame2)
309 {
310 struct can_frame frame_buffer;
311 uint32_t mask = 0U;
312 int filter_id_1;
313 int filter_id_2;
314 int err;
315
316 filter_id_1 = add_rx_msgq(can_dev, filter1);
317 zassert_not_equal(filter_id_1, -ENOSPC, "no filters available");
318 zassert_true(filter_id_1 >= 0, "negative filter number");
319 send_test_frame(can_dev, frame1);
320
321 err = k_msgq_get(&can_msgq, &frame_buffer, TEST_RECEIVE_TIMEOUT);
322 zassert_equal(err, 0, "receive timeout");
323
324 if ((filter1->flags & CAN_FILTER_IDE) != 0) {
325 if (filter1->mask != CAN_EXT_ID_MASK) {
326 mask = 0x0F;
327 }
328 } else {
329 if (filter1->mask != CAN_STD_ID_MASK) {
330 mask = 0x0F;
331 }
332 }
333
334 assert_frame_equal(&frame_buffer, frame1, mask);
335 can_remove_rx_filter(can_dev, filter_id_1);
336
337 k_sem_reset(&tx_callback_sem);
338
339 if ((frame1->flags & CAN_FRAME_IDE) != 0) {
340 if (filter1->mask == CAN_EXT_ID_MASK) {
341 filter_id_1 = add_rx_filter(can_dev, filter1, rx_ext_callback_1);
342 filter_id_2 = add_rx_filter(can_dev, filter2, rx_ext_callback_2);
343 send_test_frame_nowait(can_dev, frame1, tx_ext_callback_1);
344 send_test_frame_nowait(can_dev, frame2, tx_ext_callback_2);
345 } else {
346 filter_id_1 = add_rx_filter(can_dev, filter1, rx_ext_mask_callback_1);
347 filter_id_2 = add_rx_filter(can_dev, filter2, rx_ext_mask_callback_2);
348 send_test_frame_nowait(can_dev, frame1, tx_ext_callback_1);
349 send_test_frame_nowait(can_dev, frame2, tx_ext_callback_2);
350 }
351 } else {
352 if (filter1->mask == CAN_STD_ID_MASK) {
353 filter_id_1 = add_rx_filter(can_dev, filter1, rx_std_callback_1);
354 filter_id_2 = add_rx_filter(can_dev, filter2, rx_std_callback_2);
355 send_test_frame_nowait(can_dev, frame1, tx_std_callback_1);
356 send_test_frame_nowait(can_dev, frame2, tx_std_callback_2);
357 } else {
358 filter_id_1 = add_rx_filter(can_dev, filter1, rx_std_mask_callback_1);
359 filter_id_2 = add_rx_filter(can_dev, filter2, rx_std_mask_callback_2);
360 send_test_frame_nowait(can_dev, frame1, tx_std_callback_1);
361 send_test_frame_nowait(can_dev, frame2, tx_std_callback_2);
362 }
363 }
364
365 zassert_not_equal(filter_id_1, -ENOSPC, "no filters available");
366 zassert_true(filter_id_1 >= 0, "negative filter number");
367
368 zassert_not_equal(filter_id_2, -ENOSPC, "no filters available");
369 zassert_true(filter_id_2 >= 0, "negative filter number");
370
371 err = k_sem_take(&rx_callback_sem, TEST_RECEIVE_TIMEOUT);
372 zassert_equal(err, 0, "receive timeout");
373
374 err = k_sem_take(&rx_callback_sem, TEST_RECEIVE_TIMEOUT);
375 zassert_equal(err, 0, "receive timeout");
376
377 err = k_sem_take(&tx_callback_sem, TEST_SEND_TIMEOUT);
378 zassert_equal(err, 0, "missing TX callback");
379
380 err = k_sem_take(&tx_callback_sem, TEST_SEND_TIMEOUT);
381 zassert_equal(err, 0, "missing TX callback");
382
383 can_remove_rx_filter(can_dev, filter_id_1);
384 can_remove_rx_filter(can_dev, filter_id_2);
385 }
386
387 /**
388 * @brief Perform a send/receive test with a set of CAN ID filters and CAN frames, RTR and data
389 * frames.
390 *
391 * @param data_filter CAN data filter
392 * @param rtr_filter CAN RTR filter
393 * @param data_frame CAN data frame
394 * @param rtr_frame CAN RTR frame
395 */
send_receive_rtr(const struct can_filter * filter,const struct can_frame * data_frame,const struct can_frame * rtr_frame)396 void send_receive_rtr(const struct can_filter *filter,
397 const struct can_frame *data_frame,
398 const struct can_frame *rtr_frame)
399 {
400 struct can_frame frame;
401 int filter_id;
402 int err;
403
404 filter_id = can_add_rx_filter_msgq(can_dev, &can_msgq, filter);
405 zassert_not_equal(filter_id, -ENOSPC, "no filters available");
406 zassert_true(filter_id >= 0, "negative filter number");
407
408 /* Verify that filter matches RTR frame */
409 err = can_send(can_dev, rtr_frame, TEST_SEND_TIMEOUT, NULL, NULL);
410 if (err == -ENOTSUP) {
411 /* Not all drivers support transmission of RTR frames */
412 can_remove_rx_filter(can_dev, filter_id);
413 ztest_test_skip();
414 }
415 zassert_equal(err, 0, "failed to send RTR frame (err %d)", err);
416
417 err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
418 zassert_equal(err, 0, "receive timeout");
419 assert_frame_equal(&frame, rtr_frame, 0);
420
421 /* Verify that filter matches data frame */
422 send_test_frame(can_dev, data_frame);
423 err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
424 zassert_equal(err, 0, "receive timeout");
425 assert_frame_equal(&frame, data_frame, 0);
426
427 can_remove_rx_filter(can_dev, filter_id);
428 }
429
430 /**
431 * @brief Test getting the CAN core clock rate.
432 */
ZTEST_USER(can_classic,test_get_core_clock)433 ZTEST_USER(can_classic, test_get_core_clock)
434 {
435 uint32_t rate;
436 int err;
437
438 err = can_get_core_clock(can_dev, &rate);
439 zassert_equal(err, 0, "failed to get CAN core clock rate (err %d)", err);
440 zassert_not_equal(rate, 0, "CAN core clock rate is 0");
441 }
442
443 /**
444 * @brief Test getting the CAN controller capabilities.
445 */
ZTEST_USER(can_classic,test_classic_get_capabilities)446 ZTEST_USER(can_classic, test_classic_get_capabilities)
447 {
448 can_mode_t cap;
449 int err;
450
451 err = can_get_capabilities(can_dev, &cap);
452 zassert_equal(err, 0, "failed to get CAN capabilities (err %d)", err);
453 zassert_not_equal(cap & CAN_MODE_LOOPBACK, 0, "CAN loopback mode not supported");
454 }
455
456 /**
457 * @brief CAN state change callback.
458 */
state_change_callback(const struct device * dev,enum can_state state,struct can_bus_err_cnt err_cnt,void * user_data)459 static void state_change_callback(const struct device *dev, enum can_state state,
460 struct can_bus_err_cnt err_cnt, void *user_data)
461 {
462 ARG_UNUSED(dev);
463 ARG_UNUSED(state);
464 ARG_UNUSED(err_cnt);
465 ARG_UNUSED(user_data);
466 }
467
468 /**
469 * @brief Test setting the CAN state change callback.
470 */
ZTEST(can_classic,test_set_state_change_callback)471 ZTEST(can_classic, test_set_state_change_callback)
472 {
473 /* It is not possible to provoke a change of state, but test the API call */
474 can_set_state_change_callback(can_dev, state_change_callback, NULL);
475 can_set_state_change_callback(can_dev, NULL, NULL);
476 }
477
478 /**
479 * @brief Test setting a too high bitrate.
480 */
ZTEST_USER(can_classic,test_set_bitrate_too_high)481 ZTEST_USER(can_classic, test_set_bitrate_too_high)
482 {
483 uint32_t max = 0U;
484 int err;
485
486 err = can_get_max_bitrate(can_dev, &max);
487 if (err == -ENOSYS) {
488 ztest_test_skip();
489 }
490
491 zassert_equal(err, 0, "failed to get max bitrate (err %d)", err);
492 zassert_not_equal(max, 0, "max bitrate is 0");
493
494 err = can_stop(can_dev);
495 zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
496
497 err = can_set_bitrate(can_dev, max + 1);
498 zassert_equal(err, -ENOTSUP, "too high bitrate accepted");
499
500 err = can_start(can_dev);
501 zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
502 }
503
504 /**
505 * @brief Test setting bitrate.
506 */
ZTEST_USER(can_classic,test_set_bitrate)507 ZTEST_USER(can_classic, test_set_bitrate)
508 {
509 int err;
510
511 err = can_stop(can_dev);
512 zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
513
514 err = can_set_bitrate(can_dev, TEST_BITRATE_1);
515 zassert_equal(err, 0, "failed to set bitrate");
516
517 err = can_start(can_dev);
518 zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
519 }
520
521 /**
522 * @brief Test sending a message with no filters installed.
523 *
524 * This basic test work since the CAN controller is in loopback mode and
525 * therefore ACKs its own frame.
526 */
ZTEST_USER(can_classic,test_send_and_forget)527 ZTEST_USER(can_classic, test_send_and_forget)
528 {
529 send_test_frame(can_dev, &test_std_frame_1);
530 }
531
532 /**
533 * @brief Test adding basic filters.
534 *
535 * Test each filter type but only one filter at a time.
536 */
ZTEST(can_classic,test_add_filter)537 ZTEST(can_classic, test_add_filter)
538 {
539 int filter_id;
540
541 filter_id = add_rx_filter(can_dev, &test_std_filter_1, rx_std_callback_1);
542 can_remove_rx_filter(can_dev, filter_id);
543
544 filter_id = add_rx_filter(can_dev, &test_ext_filter_1, rx_ext_callback_1);
545 can_remove_rx_filter(can_dev, filter_id);
546
547 filter_id = add_rx_msgq(can_dev, &test_std_filter_1);
548 can_remove_rx_filter(can_dev, filter_id);
549
550 filter_id = add_rx_msgq(can_dev, &test_ext_filter_1);
551 can_remove_rx_filter(can_dev, filter_id);
552
553 filter_id = add_rx_filter(can_dev, &test_std_masked_filter_1, rx_std_mask_callback_1);
554 can_remove_rx_filter(can_dev, filter_id);
555
556 filter_id = add_rx_filter(can_dev, &test_ext_masked_filter_1, rx_ext_mask_callback_1);
557 can_remove_rx_filter(can_dev, filter_id);
558 }
559
560 /**
561 * @brief Test adding up to and above the maximum number of RX filters.
562 *
563 * @param ide standard (11-bit) CAN ID filters if false, or extended (29-bit) CAN ID filters if
564 * true.
565 * @param id_mask filter
566 */
add_remove_max_filters(bool ide)567 static void add_remove_max_filters(bool ide)
568 {
569 uint32_t id_mask = ide ? CAN_EXT_ID_MASK : CAN_STD_ID_MASK;
570 struct can_filter filter = {
571 .flags = (ide ? CAN_FILTER_IDE : 0),
572 .id = 0,
573 .mask = id_mask,
574 };
575 int filter_id;
576 int max;
577 int i;
578
579 max = can_get_max_filters(can_dev, ide);
580 if (max == -ENOSYS || max == 0) {
581 /*
582 * Skip test if max is not known or no filters of the given type
583 * is supported.
584 */
585 ztest_test_skip();
586 }
587
588 zassert_true(max > 0, "failed to get max filters (err %d)", max);
589
590 int filter_ids[max];
591
592 for (i = 0; i < max; i++) {
593 filter.id++;
594 filter_ids[i] = add_rx_msgq(can_dev, &filter);
595 }
596
597 filter.id++;
598 filter_id = can_add_rx_filter_msgq(can_dev, &can_msgq, &filter);
599 zassert_equal(filter_id, -ENOSPC, "added more than max filters");
600
601 for (i = 0; i < max; i++) {
602 can_remove_rx_filter(can_dev, filter_ids[i]);
603 }
604 }
605
606 /**
607 * @brief Test max standard (11-bit) CAN RX filters.
608 */
ZTEST_USER(can_classic,test_max_std_filters)609 ZTEST_USER(can_classic, test_max_std_filters)
610 {
611 add_remove_max_filters(false);
612 }
613
614 /**
615 * @brief Test max extended (29-bit) CAN RX filters.
616 */
ZTEST_USER(can_classic,test_max_ext_filters)617 ZTEST_USER(can_classic, test_max_ext_filters)
618 {
619 add_remove_max_filters(true);
620 }
621
622 /**
623 * @brief Test that no message is received when nothing was sent.
624 */
ZTEST_USER(can_classic,test_receive_timeout)625 ZTEST_USER(can_classic, test_receive_timeout)
626 {
627 struct can_frame frame;
628 int filter_id;
629 int err;
630
631 filter_id = add_rx_msgq(can_dev, &test_std_filter_1);
632
633 err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
634 zassert_equal(err, -EAGAIN, "received a frame without sending one");
635
636 can_remove_rx_filter(can_dev, filter_id);
637 }
638
639 /**
640 * @brief Test that transmit callback function is called.
641 */
ZTEST(can_classic,test_send_callback)642 ZTEST(can_classic, test_send_callback)
643 {
644 int err;
645
646 k_sem_reset(&tx_callback_sem);
647
648 send_test_frame_nowait(can_dev, &test_std_frame_1, tx_std_callback_1);
649
650 err = k_sem_take(&tx_callback_sem, TEST_SEND_TIMEOUT);
651 zassert_equal(err, 0, "missing TX callback");
652 }
653
654 /**
655 * @brief Test send/receive with standard (11-bit) CAN IDs.
656 */
ZTEST(can_classic,test_send_receive_std_id)657 ZTEST(can_classic, test_send_receive_std_id)
658 {
659 send_receive(&test_std_filter_1, &test_std_filter_2,
660 &test_std_frame_1, &test_std_frame_2);
661 }
662
663 /**
664 * @brief Test send/receive with extended (29-bit) CAN IDs.
665 */
ZTEST(can_classic,test_send_receive_ext_id)666 ZTEST(can_classic, test_send_receive_ext_id)
667 {
668 send_receive(&test_ext_filter_1, &test_ext_filter_2,
669 &test_ext_frame_1, &test_ext_frame_2);
670 }
671
672 /**
673 * @brief Test send/receive with standard (11-bit) masked CAN IDs.
674 */
ZTEST(can_classic,test_send_receive_std_id_masked)675 ZTEST(can_classic, test_send_receive_std_id_masked)
676 {
677 send_receive(&test_std_masked_filter_1, &test_std_masked_filter_2,
678 &test_std_frame_1, &test_std_frame_2);
679 }
680
681 /**
682 * @brief Test send/receive with extended (29-bit) masked CAN IDs.
683 */
ZTEST(can_classic,test_send_receive_ext_id_masked)684 ZTEST(can_classic, test_send_receive_ext_id_masked)
685 {
686 send_receive(&test_ext_masked_filter_1, &test_ext_masked_filter_2,
687 &test_ext_frame_1, &test_ext_frame_2);
688 }
689
690 /**
691 * @brief Test send/receive with messages buffered in a CAN message queue.
692 */
ZTEST_USER(can_classic,test_send_receive_msgq)693 ZTEST_USER(can_classic, test_send_receive_msgq)
694 {
695 struct k_msgq_attrs attrs;
696 struct can_frame frame;
697 int filter_id;
698 int nframes;
699 int err;
700 int i;
701
702 filter_id = add_rx_msgq(can_dev, &test_std_filter_1);
703
704 k_msgq_get_attrs(&can_msgq, &attrs);
705 nframes = attrs.max_msgs;
706
707 for (i = 0; i < nframes; i++) {
708 send_test_frame(can_dev, &test_std_frame_1);
709 }
710
711 for (i = 0; i < nframes; i++) {
712 err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
713 zassert_equal(err, 0, "receive timeout");
714 assert_frame_equal(&frame, &test_std_frame_1, 0);
715 }
716
717 for (i = 0; i < nframes; i++) {
718 send_test_frame(can_dev, &test_std_frame_1);
719 }
720
721 for (i = 0; i < nframes; i++) {
722 err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
723 zassert_equal(err, 0, "receive timeout");
724 assert_frame_equal(&frame, &test_std_frame_1, 0);
725 }
726
727 can_remove_rx_filter(can_dev, filter_id);
728 }
729
730 /**
731 * @brief Test send/receive with standard (11-bit) CAN IDs and remote transmission request (RTR).
732 */
ZTEST_USER(can_classic,test_send_receive_std_id_rtr)733 ZTEST_USER(can_classic, test_send_receive_std_id_rtr)
734 {
735 Z_TEST_SKIP_IFNDEF(CONFIG_CAN_ACCEPT_RTR);
736
737 send_receive_rtr(&test_std_filter_1, &test_std_frame_1, &test_std_rtr_frame_1);
738 }
739
740 /**
741 * @brief Test send/receive with extended (29-bit) CAN IDs and remote transmission request (RTR).
742 */
ZTEST_USER(can_classic,test_send_receive_ext_id_rtr)743 ZTEST_USER(can_classic, test_send_receive_ext_id_rtr)
744 {
745 Z_TEST_SKIP_IFNDEF(CONFIG_CAN_ACCEPT_RTR);
746
747 send_receive_rtr(&test_ext_filter_1, &test_ext_frame_1, &test_ext_rtr_frame_1);
748 }
749
750 /**
751 * @brief Test rejection of standard (11-bit) CAN IDs and remote transmission request (RTR).
752 */
ZTEST_USER(can_classic,test_reject_std_id_rtr)753 ZTEST_USER(can_classic, test_reject_std_id_rtr)
754 {
755 struct can_frame frame_buffer;
756 int filter_id;
757 int err;
758
759 Z_TEST_SKIP_IFDEF(CONFIG_CAN_ACCEPT_RTR);
760
761 filter_id = add_rx_msgq(can_dev, &test_std_filter_1);
762
763 err = can_send(can_dev, &test_std_rtr_frame_1, TEST_SEND_TIMEOUT, NULL, NULL);
764 if (err == -ENOTSUP) {
765 /* Not all drivers support transmission of RTR frames */
766 can_remove_rx_filter(can_dev, filter_id);
767 ztest_test_skip();
768 }
769 zassert_equal(err, 0, "failed to send RTR frame (err %d)", err);
770
771 err = k_msgq_get(&can_msgq, &frame_buffer, TEST_RECEIVE_TIMEOUT);
772 zassert_equal(err, -EAGAIN, "received a frame that should be rejected");
773
774 can_remove_rx_filter(can_dev, filter_id);
775 }
776
777 /**
778 * @brief Test rejection of extended (29-bit) CAN IDs and remote transmission request (RTR).
779 */
ZTEST_USER(can_classic,test_reject_ext_id_rtr)780 ZTEST_USER(can_classic, test_reject_ext_id_rtr)
781 {
782 struct can_frame frame_buffer;
783 int filter_id;
784 int err;
785
786 Z_TEST_SKIP_IFDEF(CONFIG_CAN_ACCEPT_RTR);
787
788 filter_id = add_rx_msgq(can_dev, &test_ext_filter_1);
789
790 err = can_send(can_dev, &test_ext_rtr_frame_1, TEST_SEND_TIMEOUT, NULL, NULL);
791 if (err == -ENOTSUP) {
792 /* Not all drivers support transmission of RTR frames */
793 can_remove_rx_filter(can_dev, filter_id);
794 ztest_test_skip();
795 }
796 zassert_equal(err, 0, "failed to send RTR frame (err %d)", err);
797
798 err = k_msgq_get(&can_msgq, &frame_buffer, TEST_RECEIVE_TIMEOUT);
799 zassert_equal(err, -EAGAIN, "received a frame that should be rejected");
800
801 can_remove_rx_filter(can_dev, filter_id);
802 }
803
804 /**
805 * @brief Test that non-matching CAN frames do not pass a filter.
806 */
ZTEST(can_classic,test_send_receive_wrong_id)807 ZTEST(can_classic, test_send_receive_wrong_id)
808 {
809 struct can_frame frame_buffer;
810 int filter_id;
811 int err;
812
813 filter_id = add_rx_msgq(can_dev, &test_std_filter_1);
814
815 send_test_frame(can_dev, &test_std_frame_2);
816
817 err = k_msgq_get(&can_msgq, &frame_buffer, TEST_RECEIVE_TIMEOUT);
818 zassert_equal(err, -EAGAIN, "received a frame that should not pass the filter");
819
820 can_remove_rx_filter(can_dev, filter_id);
821 }
822
823 /**
824 * @brief Test that frames with invalid Data Length Code (DLC) are rejected.
825 */
ZTEST_USER(can_classic,test_send_invalid_dlc)826 ZTEST_USER(can_classic, test_send_invalid_dlc)
827 {
828 struct can_frame frame = {0};
829 int err;
830
831 frame.id = TEST_CAN_STD_ID_1;
832 frame.dlc = CAN_MAX_DLC + 1;
833
834 err = can_send(can_dev, &frame, TEST_SEND_TIMEOUT, NULL, NULL);
835 zassert_equal(err, -EINVAL, "sent a frame with an invalid DLC");
836 }
837
838 /**
839 * @brief Test that CAN FD format frames are rejected in non-FD mode.
840 */
ZTEST_USER(can_classic,test_send_fd_format)841 ZTEST_USER(can_classic, test_send_fd_format)
842 {
843 struct can_frame frame = {0};
844 int err;
845
846 frame.id = TEST_CAN_STD_ID_1;
847 frame.dlc = 0;
848 frame.flags = CAN_FRAME_FDF;
849
850 err = can_send(can_dev, &frame, TEST_SEND_TIMEOUT, NULL, NULL);
851 zassert_equal(err, -ENOTSUP, "sent a CAN FD format frame in non-FD mode");
852 }
853
854 /**
855 * @brief Test CAN controller bus recovery.
856 */
ZTEST_USER(can_classic,test_recover)857 ZTEST_USER(can_classic, test_recover)
858 {
859 int err;
860
861 /* It is not possible to provoke a bus off state, but test the API call */
862 err = can_recover(can_dev, TEST_RECOVER_TIMEOUT);
863 if (err == -ENOTSUP) {
864 ztest_test_skip();
865 }
866
867 zassert_equal(err, 0, "failed to recover (err %d)", err);
868 }
869
870 /**
871 * @brief Test retrieving the state of the CAN controller.
872 */
ZTEST_USER(can_classic,test_get_state)873 ZTEST_USER(can_classic, test_get_state)
874 {
875 struct can_bus_err_cnt err_cnt;
876 enum can_state state;
877 int err;
878
879 err = can_get_state(can_dev, NULL, NULL);
880 zassert_equal(err, 0, "failed to get CAN state without destinations (err %d)", err);
881
882 err = can_get_state(can_dev, &state, NULL);
883 zassert_equal(err, 0, "failed to get CAN state (err %d)", err);
884
885 err = can_get_state(can_dev, NULL, &err_cnt);
886 zassert_equal(err, 0, "failed to get CAN error counters (err %d)", err);
887
888 err = can_get_state(can_dev, &state, &err_cnt);
889 zassert_equal(err, 0, "failed to get CAN state + error counters (err %d)", err);
890 }
891
892 /**
893 * @brief Test that CAN RX filters are preserved through CAN controller mode changes.
894 */
ZTEST_USER(can_classic,test_filters_preserved_through_mode_change)895 ZTEST_USER(can_classic, test_filters_preserved_through_mode_change)
896 {
897 struct can_frame frame;
898 enum can_state state;
899 int filter_id;
900 int err;
901
902 filter_id = add_rx_msgq(can_dev, &test_std_filter_1);
903 send_test_frame(can_dev, &test_std_frame_1);
904
905 err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
906 zassert_equal(err, 0, "receive timeout");
907 assert_frame_equal(&frame, &test_std_frame_1, 0);
908
909 err = can_stop(can_dev);
910 zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
911
912 err = can_get_state(can_dev, &state, NULL);
913 zassert_equal(err, 0, "failed to get CAN state (err %d)", err);
914 zassert_equal(state, CAN_STATE_STOPPED, "CAN controller not stopped");
915
916 err = can_set_mode(can_dev, CAN_MODE_NORMAL);
917 zassert_equal(err, 0, "failed to set normal mode (err %d)", err);
918 zassert_equal(CAN_MODE_NORMAL, can_get_mode(can_dev));
919
920 err = can_set_mode(can_dev, CAN_MODE_LOOPBACK);
921 zassert_equal(err, 0, "failed to set loopback-mode (err %d)", err);
922 zassert_equal(CAN_MODE_LOOPBACK, can_get_mode(can_dev));
923
924 err = can_start(can_dev);
925 zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
926
927 send_test_frame(can_dev, &test_std_frame_1);
928
929 err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
930 zassert_equal(err, 0, "receive timeout");
931 assert_frame_equal(&frame, &test_std_frame_1, 0);
932
933 can_remove_rx_filter(can_dev, filter_id);
934 }
935
936 /**
937 * @brief Test that CAN RX filters are preserved through CAN controller bitrate changes.
938 */
ZTEST_USER(can_classic,test_filters_preserved_through_bitrate_change)939 ZTEST_USER(can_classic, test_filters_preserved_through_bitrate_change)
940 {
941 struct can_frame frame;
942 enum can_state state;
943 int filter_id;
944 int err;
945
946 filter_id = add_rx_msgq(can_dev, &test_std_filter_1);
947 send_test_frame(can_dev, &test_std_frame_1);
948
949 err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
950 zassert_equal(err, 0, "receive timeout");
951 assert_frame_equal(&frame, &test_std_frame_1, 0);
952
953 err = can_stop(can_dev);
954 zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
955
956 err = can_get_state(can_dev, &state, NULL);
957 zassert_equal(err, 0, "failed to get CAN state (err %d)", err);
958 zassert_equal(state, CAN_STATE_STOPPED, "CAN controller not stopped");
959
960 err = can_set_bitrate(can_dev, TEST_BITRATE_2);
961 zassert_equal(err, 0, "failed to set bitrate");
962
963 err = can_set_bitrate(can_dev, TEST_BITRATE_1);
964 zassert_equal(err, 0, "failed to set bitrate");
965
966 err = can_start(can_dev);
967 zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
968
969 send_test_frame(can_dev, &test_std_frame_1);
970
971 err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
972 zassert_equal(err, 0, "receive timeout");
973 assert_frame_equal(&frame, &test_std_frame_1, 0);
974
975 can_remove_rx_filter(can_dev, filter_id);
976 }
977
978 /**
979 * @brief Test that CAN RX filters can be added while CAN controller is stopped.
980 */
ZTEST_USER(can_classic,test_filters_added_while_stopped)981 ZTEST_USER(can_classic, test_filters_added_while_stopped)
982 {
983 struct can_frame frame;
984 int filter_id;
985 int err;
986
987 err = can_stop(can_dev);
988 zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
989
990 filter_id = add_rx_msgq(can_dev, &test_std_filter_1);
991
992 err = can_start(can_dev);
993 zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
994
995 send_test_frame(can_dev, &test_std_frame_1);
996
997 err = k_msgq_get(&can_msgq, &frame, TEST_RECEIVE_TIMEOUT);
998 zassert_equal(err, 0, "receive timeout");
999 assert_frame_equal(&frame, &test_std_frame_1, 0);
1000
1001 can_remove_rx_filter(can_dev, filter_id);
1002 }
1003
1004 /**
1005 * @brief Test stopping is not allowed while stopped.
1006 */
ZTEST_USER(can_classic,test_stop_while_stopped)1007 ZTEST_USER(can_classic, test_stop_while_stopped)
1008 {
1009 int err;
1010
1011 err = can_stop(can_dev);
1012 zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
1013
1014 err = can_stop(can_dev);
1015 zassert_not_equal(err, 0, "stopped CAN controller while stopped");
1016 zassert_equal(err, -EALREADY, "wrong error return code (err %d)", err);
1017
1018 err = can_start(can_dev);
1019 zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
1020 }
1021
1022 /**
1023 * @brief Test starting is not allowed while started.
1024 */
ZTEST_USER(can_classic,test_start_while_started)1025 ZTEST_USER(can_classic, test_start_while_started)
1026 {
1027 int err;
1028
1029 err = can_start(can_dev);
1030 zassert_not_equal(err, 0, "started CAN controller while started");
1031 zassert_equal(err, -EALREADY, "wrong error return code (err %d)", err);
1032 }
1033
1034 /**
1035 * @brief Test recover is not allowed while started.
1036 */
ZTEST_USER(can_classic,test_recover_while_stopped)1037 ZTEST_USER(can_classic, test_recover_while_stopped)
1038 {
1039 int err;
1040
1041 err = can_stop(can_dev);
1042 zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
1043
1044 err = can_recover(can_dev, K_NO_WAIT);
1045 zassert_not_equal(err, 0, "recovered bus while stopped");
1046 zassert_equal(err, -ENETDOWN, "wrong error return code (err %d)", err);
1047
1048 err = can_start(can_dev);
1049 zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
1050 }
1051
1052 /**
1053 * @brief Test sending is not allowed while stopped.
1054 */
ZTEST_USER(can_classic,test_send_while_stopped)1055 ZTEST_USER(can_classic, test_send_while_stopped)
1056 {
1057 int err;
1058
1059 err = can_stop(can_dev);
1060 zassert_equal(err, 0, "failed to stop CAN controller (err %d)", err);
1061
1062 err = can_send(can_dev, &test_std_frame_1, TEST_SEND_TIMEOUT, NULL, NULL);
1063 zassert_not_equal(err, 0, "sent a frame in stopped state");
1064 zassert_equal(err, -ENETDOWN, "wrong error return code (err %d)", err);
1065
1066 err = can_start(can_dev);
1067 zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
1068 }
1069
1070 /**
1071 * @brief Test setting bitrate is not allowed while started.
1072 */
ZTEST_USER(can_classic,test_set_bitrate_while_started)1073 ZTEST_USER(can_classic, test_set_bitrate_while_started)
1074 {
1075 int err;
1076
1077 err = can_set_bitrate(can_dev, TEST_BITRATE_2);
1078 zassert_not_equal(err, 0, "changed bitrate while started");
1079 zassert_equal(err, -EBUSY, "wrong error return code (err %d)", err);
1080 }
1081
1082 /**
1083 * @brief Test setting timing is not allowed while started.
1084 */
ZTEST_USER(can_classic,test_set_timing_while_started)1085 ZTEST_USER(can_classic, test_set_timing_while_started)
1086 {
1087 struct can_timing timing = { 0 };
1088 int err;
1089
1090 err = can_calc_timing(can_dev, &timing, TEST_BITRATE_1, TEST_SAMPLE_POINT);
1091 zassert_ok(err, "failed to calculate timing (err %d)", err);
1092
1093 err = can_set_timing(can_dev, &timing);
1094 zassert_not_equal(err, 0, "changed timing while started");
1095 zassert_equal(err, -EBUSY, "wrong error return code (err %d)", err);
1096 }
1097
1098 /**
1099 * @brief Test setting mode is not allowed while started.
1100 */
ZTEST_USER(can_classic,test_set_mode_while_started)1101 ZTEST_USER(can_classic, test_set_mode_while_started)
1102 {
1103 int err;
1104
1105 err = can_set_mode(can_dev, CAN_MODE_NORMAL);
1106 zassert_not_equal(err, 0, "changed mode while started");
1107 zassert_equal(err, -EBUSY, "wrong error return code (err %d)", err);
1108 }
1109
can_classic_setup(void)1110 void *can_classic_setup(void)
1111 {
1112 int err;
1113
1114 k_sem_init(&rx_callback_sem, 0, 2);
1115 k_sem_init(&tx_callback_sem, 0, 2);
1116
1117 k_object_access_grant(&can_msgq, k_current_get());
1118 k_object_access_grant(can_dev, k_current_get());
1119
1120 zassert_true(device_is_ready(can_dev), "CAN device not ready");
1121
1122 (void)can_stop(can_dev);
1123
1124 err = can_set_mode(can_dev, CAN_MODE_LOOPBACK);
1125 zassert_equal(err, 0, "failed to set loopback mode (err %d)", err);
1126 zassert_equal(CAN_MODE_LOOPBACK, can_get_mode(can_dev));
1127
1128 err = can_start(can_dev);
1129 zassert_equal(err, 0, "failed to start CAN controller (err %d)", err);
1130
1131 return NULL;
1132 }
1133
1134 ZTEST_SUITE(can_classic, NULL, can_classic_setup, NULL, NULL, NULL);
1135
