Line data    Source code

       1           1 : /** @file
       2             :  * @brief SocketCAN utilities.
       3             :  *
       4             :  * Utilities for SocketCAN support.
       5             :  */
       6             : 
       7             : /*
       8             :  * Copyright (c) 2019 Intel Corporation
       9             :  *
      10             :  * SPDX-License-Identifier: Apache-2.0
      11             :  */
      12             : 
      13             : #ifndef ZEPHYR_INCLUDE_NET_SOCKETCAN_UTILS_H_
      14             : #define ZEPHYR_INCLUDE_NET_SOCKETCAN_UTILS_H_
      15             : 
      16             : #include <zephyr/drivers/can.h>
      17             : #include <zephyr/net/socketcan.h>
      18             : 
      19             : #ifdef __cplusplus
      20             : extern "C" {
      21             : #endif
      22             : 
      23             : /**
      24             :  * @brief SocketCAN utilities
      25             :  * @addtogroup socket_can
      26             :  * @{
      27             :  */
      28             : 
      29             : /**
      30             :  * @brief Translate a @a socketcan_frame struct to a @a can_frame struct.
      31             :  *
      32             :  * @param sframe Pointer to sockecan_frame struct.
      33             :  * @param zframe Pointer to can_frame struct.
      34             :  */
      35           1 : static inline void socketcan_to_can_frame(const struct socketcan_frame *sframe,
      36             :                                           struct can_frame *zframe)
      37             : {
      38             :         memset(zframe, 0, sizeof(*zframe));
      39             : 
      40             :         zframe->flags |= (sframe->can_id & BIT(31)) != 0 ? CAN_FRAME_IDE : 0;
      41             :         zframe->flags |= (sframe->can_id & BIT(30)) != 0 ? CAN_FRAME_RTR : 0;
      42             :         zframe->flags |= (sframe->flags & CANFD_FDF) != 0 ? CAN_FRAME_FDF : 0;
      43             :         zframe->flags |= (sframe->flags & CANFD_BRS) != 0 ? CAN_FRAME_BRS : 0;
      44             :         zframe->id = sframe->can_id & BIT_MASK(29);
      45             :         zframe->dlc = can_bytes_to_dlc(sframe->len);
      46             : 
      47             :         if ((zframe->flags & CAN_FRAME_RTR) == 0U) {
      48             :                 memcpy(zframe->data, sframe->data,
      49             :                        MIN(sframe->len, MIN(sizeof(sframe->data), sizeof(zframe->data))));
      50             :         }
      51             : }
      52             : 
      53             : /**
      54             :  * @brief Translate a @a can_frame struct to a @a socketcan_frame struct.
      55             :  *
      56             :  * @param zframe Pointer to can_frame struct.
      57             :  * @param sframe  Pointer to socketcan_frame struct.
      58             :  */
      59           1 : static inline void socketcan_from_can_frame(const struct can_frame *zframe,
      60             :                                             struct socketcan_frame *sframe)
      61             : {
      62             :         memset(sframe, 0, sizeof(*sframe));
      63             : 
      64             :         sframe->can_id = zframe->id;
      65             :         sframe->can_id |= (zframe->flags & CAN_FRAME_IDE) != 0 ? BIT(31) : 0;
      66             :         sframe->can_id |= (zframe->flags & CAN_FRAME_RTR) != 0 ? BIT(30) : 0;
      67             :         sframe->len = can_dlc_to_bytes(zframe->dlc);
      68             : 
      69             :         if ((zframe->flags & CAN_FRAME_FDF) != 0) {
      70             :                 sframe->flags |= CANFD_FDF;
      71             :         }
      72             : 
      73             :         if ((zframe->flags & CAN_FRAME_BRS) != 0) {
      74             :                 sframe->flags |= CANFD_BRS;
      75             :         }
      76             : 
      77             :         if ((zframe->flags & CAN_FRAME_RTR) == 0U) {
      78             :                 memcpy(sframe->data, zframe->data,
      79             :                        MIN(sframe->len, MIN(sizeof(zframe->data), sizeof(sframe->data))));
      80             :         }
      81             : }
      82             : 
      83             : /**
      84             :  * @brief Translate a @a socketcan_filter struct to a @a can_filter struct.
      85             :  *
      86             :  * @param sfilter Pointer to socketcan_filter struct.
      87             :  * @param zfilter Pointer to can_filter struct.
      88             :  */
      89           1 : static inline void socketcan_to_can_filter(const struct socketcan_filter *sfilter,
      90             :                                            struct can_filter *zfilter)
      91             : {
      92             :         memset(zfilter, 0, sizeof(*zfilter));
      93             : 
      94             :         zfilter->flags |= (sfilter->can_id & BIT(31)) != 0 ? CAN_FILTER_IDE : 0;
      95             :         zfilter->id = sfilter->can_id & BIT_MASK(29);
      96             :         zfilter->mask = sfilter->can_mask & BIT_MASK(29);
      97             : }
      98             : 
      99             : /**
     100             :  * @brief Translate a @a can_filter struct to a @a socketcan_filter struct.
     101             :  *
     102             :  * @param zfilter Pointer to can_filter struct.
     103             :  * @param sfilter Pointer to socketcan_filter struct.
     104             :  */
     105           1 : static inline void socketcan_from_can_filter(const struct can_filter *zfilter,
     106             :                                              struct socketcan_filter *sfilter)
     107             : {
     108             :         memset(sfilter, 0, sizeof(*sfilter));
     109             : 
     110             :         sfilter->can_id = zfilter->id;
     111             :         sfilter->can_id |= (zfilter->flags & CAN_FILTER_IDE) != 0 ? BIT(31) : 0;
     112             : 
     113             :         sfilter->can_mask = zfilter->mask;
     114             :         sfilter->can_mask |= (zfilter->flags & CAN_FILTER_IDE) != 0 ? BIT(31) : 0;
     115             : 
     116             :         if (!IS_ENABLED(CONFIG_CAN_ACCEPT_RTR)) {
     117             :                 sfilter->can_mask |= BIT(30);
     118             :         }
     119             : }
     120             : 
     121             : /**
     122             :  * @}
     123             :  */
     124             : 
     125             : #ifdef __cplusplus
     126             : }
     127             : #endif
     128             : 
     129             : #endif /* ZEPHYR_INCLUDE_NET_SOCKETCAN_H_ */