logo

oasis-root

Compiled tree of Oasis Linux based on own branch at <https://hacktivis.me/git/oasis/> git clone https://anongit.hacktivis.me/git/oasis-root.git

can.h (11496B)


  1. /* SPDX-License-Identifier: ((GPL-2.0-only WITH Linux-syscall-note) OR BSD-3-Clause) */
  2. /*
  3. * linux/can.h
  4. *
  5. * Definitions for CAN network layer (socket addr / CAN frame / CAN filter)
  6. *
  7. * Authors: Oliver Hartkopp <oliver.hartkopp@volkswagen.de>
  8. * Urs Thuermann <urs.thuermann@volkswagen.de>
  9. * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
  10. * All rights reserved.
  11. *
  12. * Redistribution and use in source and binary forms, with or without
  13. * modification, are permitted provided that the following conditions
  14. * are met:
  15. * 1. Redistributions of source code must retain the above copyright
  16. * notice, this list of conditions and the following disclaimer.
  17. * 2. Redistributions in binary form must reproduce the above copyright
  18. * notice, this list of conditions and the following disclaimer in the
  19. * documentation and/or other materials provided with the distribution.
  20. * 3. Neither the name of Volkswagen nor the names of its contributors
  21. * may be used to endorse or promote products derived from this software
  22. * without specific prior written permission.
  23. *
  24. * Alternatively, provided that this notice is retained in full, this
  25. * software may be distributed under the terms of the GNU General
  26. * Public License ("GPL") version 2, in which case the provisions of the
  27. * GPL apply INSTEAD OF those given above.
  28. *
  29. * The provided data structures and external interfaces from this code
  30. * are not restricted to be used by modules with a GPL compatible license.
  31. *
  32. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33. * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34. * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  35. * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  36. * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  37. * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  38. * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  39. * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  40. * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  41. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  42. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  43. * DAMAGE.
  44. */
  45. #ifndef _CAN_H
  46. #define _CAN_H
  47. #include <linux/types.h>
  48. #include <linux/socket.h>
  49. #include <linux/stddef.h> /* for offsetof */
  50. /* controller area network (CAN) kernel definitions */
  51. /* special address description flags for the CAN_ID */
  52. #define CAN_EFF_FLAG 0x80000000U /* EFF/SFF is set in the MSB */
  53. #define CAN_RTR_FLAG 0x40000000U /* remote transmission request */
  54. #define CAN_ERR_FLAG 0x20000000U /* error message frame */
  55. /* valid bits in CAN ID for frame formats */
  56. #define CAN_SFF_MASK 0x000007FFU /* standard frame format (SFF) */
  57. #define CAN_EFF_MASK 0x1FFFFFFFU /* extended frame format (EFF) */
  58. #define CAN_ERR_MASK 0x1FFFFFFFU /* omit EFF, RTR, ERR flags */
  59. #define CANXL_PRIO_MASK CAN_SFF_MASK /* 11 bit priority mask */
  60. /*
  61. * Controller Area Network Identifier structure
  62. *
  63. * bit 0-28 : CAN identifier (11/29 bit)
  64. * bit 29 : error message frame flag (0 = data frame, 1 = error message)
  65. * bit 30 : remote transmission request flag (1 = rtr frame)
  66. * bit 31 : frame format flag (0 = standard 11 bit, 1 = extended 29 bit)
  67. */
  68. typedef __u32 canid_t;
  69. #define CAN_SFF_ID_BITS 11
  70. #define CAN_EFF_ID_BITS 29
  71. #define CANXL_PRIO_BITS CAN_SFF_ID_BITS
  72. /*
  73. * Controller Area Network Error Message Frame Mask structure
  74. *
  75. * bit 0-28 : error class mask (see include/uapi/linux/can/error.h)
  76. * bit 29-31 : set to zero
  77. */
  78. typedef __u32 can_err_mask_t;
  79. /* CAN payload length and DLC definitions according to ISO 11898-1 */
  80. #define CAN_MAX_DLC 8
  81. #define CAN_MAX_RAW_DLC 15
  82. #define CAN_MAX_DLEN 8
  83. /* CAN FD payload length and DLC definitions according to ISO 11898-7 */
  84. #define CANFD_MAX_DLC 15
  85. #define CANFD_MAX_DLEN 64
  86. /*
  87. * CAN XL payload length and DLC definitions according to ISO 11898-1
  88. * CAN XL DLC ranges from 0 .. 2047 => data length from 1 .. 2048 byte
  89. */
  90. #define CANXL_MIN_DLC 0
  91. #define CANXL_MAX_DLC 2047
  92. #define CANXL_MAX_DLC_MASK 0x07FF
  93. #define CANXL_MIN_DLEN 1
  94. #define CANXL_MAX_DLEN 2048
  95. /**
  96. * struct can_frame - Classical CAN frame structure (aka CAN 2.0B)
  97. * @can_id: CAN ID of the frame and CAN_*_FLAG flags, see canid_t definition
  98. * @len: CAN frame payload length in byte (0 .. 8)
  99. * @can_dlc: deprecated name for CAN frame payload length in byte (0 .. 8)
  100. * @__pad: padding
  101. * @__res0: reserved / padding
  102. * @len8_dlc: optional DLC value (9 .. 15) at 8 byte payload length
  103. * len8_dlc contains values from 9 .. 15 when the payload length is
  104. * 8 bytes but the DLC value (see ISO 11898-1) is greater then 8.
  105. * CAN_CTRLMODE_CC_LEN8_DLC flag has to be enabled in CAN driver.
  106. * @data: CAN frame payload (up to 8 byte)
  107. */
  108. struct can_frame {
  109. canid_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */
  110. union {
  111. /* CAN frame payload length in byte (0 .. CAN_MAX_DLEN)
  112. * was previously named can_dlc so we need to carry that
  113. * name for legacy support
  114. */
  115. __u8 len;
  116. __u8 can_dlc; /* deprecated */
  117. } __attribute__((packed)); /* disable padding added in some ABIs */
  118. __u8 __pad; /* padding */
  119. __u8 __res0; /* reserved / padding */
  120. __u8 len8_dlc; /* optional DLC for 8 byte payload length (9 .. 15) */
  121. __u8 data[CAN_MAX_DLEN] __attribute__((aligned(8)));
  122. };
  123. /*
  124. * defined bits for canfd_frame.flags
  125. *
  126. * The use of struct canfd_frame implies the FD Frame (FDF) bit to
  127. * be set in the CAN frame bitstream on the wire. The FDF bit switch turns
  128. * the CAN controllers bitstream processor into the CAN FD mode which creates
  129. * two new options within the CAN FD frame specification:
  130. *
  131. * Bit Rate Switch - to indicate a second bitrate is/was used for the payload
  132. * Error State Indicator - represents the error state of the transmitting node
  133. *
  134. * As the CANFD_ESI bit is internally generated by the transmitting CAN
  135. * controller only the CANFD_BRS bit is relevant for real CAN controllers when
  136. * building a CAN FD frame for transmission. Setting the CANFD_ESI bit can make
  137. * sense for virtual CAN interfaces to test applications with echoed frames.
  138. *
  139. * The struct can_frame and struct canfd_frame intentionally share the same
  140. * layout to be able to write CAN frame content into a CAN FD frame structure.
  141. * When this is done the former differentiation via CAN_MTU / CANFD_MTU gets
  142. * lost. CANFD_FDF allows programmers to mark CAN FD frames in the case of
  143. * using struct canfd_frame for mixed CAN / CAN FD content (dual use).
  144. * Since the introduction of CAN XL the CANFD_FDF flag is set in all CAN FD
  145. * frame structures provided by the CAN subsystem of the Linux kernel.
  146. */
  147. #define CANFD_BRS 0x01 /* bit rate switch (second bitrate for payload data) */
  148. #define CANFD_ESI 0x02 /* error state indicator of the transmitting node */
  149. #define CANFD_FDF 0x04 /* mark CAN FD for dual use of struct canfd_frame */
  150. /**
  151. * struct canfd_frame - CAN flexible data rate frame structure
  152. * @can_id: CAN ID of the frame and CAN_*_FLAG flags, see canid_t definition
  153. * @len: frame payload length in byte (0 .. CANFD_MAX_DLEN)
  154. * @flags: additional flags for CAN FD
  155. * @__res0: reserved / padding
  156. * @__res1: reserved / padding
  157. * @data: CAN FD frame payload (up to CANFD_MAX_DLEN byte)
  158. */
  159. struct canfd_frame {
  160. canid_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */
  161. __u8 len; /* frame payload length in byte */
  162. __u8 flags; /* additional flags for CAN FD */
  163. __u8 __res0; /* reserved / padding */
  164. __u8 __res1; /* reserved / padding */
  165. __u8 data[CANFD_MAX_DLEN] __attribute__((aligned(8)));
  166. };
  167. /*
  168. * defined bits for canxl_frame.flags
  169. *
  170. * The canxl_frame.flags element contains two bits CANXL_XLF and CANXL_SEC
  171. * and shares the relative position of the struct can[fd]_frame.len element.
  172. * The CANXL_XLF bit ALWAYS needs to be set to indicate a valid CAN XL frame.
  173. * As a side effect setting this bit intentionally breaks the length checks
  174. * for Classical CAN and CAN FD frames.
  175. *
  176. * Undefined bits in canxl_frame.flags are reserved and shall be set to zero.
  177. */
  178. #define CANXL_XLF 0x80 /* mandatory CAN XL frame flag (must always be set!) */
  179. #define CANXL_SEC 0x01 /* Simple Extended Content (security/segmentation) */
  180. /* the 8-bit VCID is optionally placed in the canxl_frame.prio element */
  181. #define CANXL_VCID_OFFSET 16 /* bit offset of VCID in prio element */
  182. #define CANXL_VCID_VAL_MASK 0xFFUL /* VCID is an 8-bit value */
  183. #define CANXL_VCID_MASK (CANXL_VCID_VAL_MASK << CANXL_VCID_OFFSET)
  184. /**
  185. * struct canxl_frame - CAN with e'X'tended frame 'L'ength frame structure
  186. * @prio: 11 bit arbitration priority with zero'ed CAN_*_FLAG flags / VCID
  187. * @flags: additional flags for CAN XL
  188. * @sdt: SDU (service data unit) type
  189. * @len: frame payload length in byte (CANXL_MIN_DLEN .. CANXL_MAX_DLEN)
  190. * @af: acceptance field
  191. * @data: CAN XL frame payload (CANXL_MIN_DLEN .. CANXL_MAX_DLEN byte)
  192. *
  193. * @prio shares the same position as @can_id from struct can[fd]_frame.
  194. */
  195. struct canxl_frame {
  196. canid_t prio; /* 11 bit priority for arbitration / 8 bit VCID */
  197. __u8 flags; /* additional flags for CAN XL */
  198. __u8 sdt; /* SDU (service data unit) type */
  199. __u16 len; /* frame payload length in byte */
  200. __u32 af; /* acceptance field */
  201. __u8 data[CANXL_MAX_DLEN];
  202. };
  203. #define CAN_MTU (sizeof(struct can_frame))
  204. #define CANFD_MTU (sizeof(struct canfd_frame))
  205. #define CANXL_MTU (sizeof(struct canxl_frame))
  206. #define CANXL_HDR_SIZE (offsetof(struct canxl_frame, data))
  207. #define CANXL_MIN_MTU (CANXL_HDR_SIZE + 64)
  208. #define CANXL_MAX_MTU CANXL_MTU
  209. /* particular protocols of the protocol family PF_CAN */
  210. #define CAN_RAW 1 /* RAW sockets */
  211. #define CAN_BCM 2 /* Broadcast Manager */
  212. #define CAN_TP16 3 /* VAG Transport Protocol v1.6 */
  213. #define CAN_TP20 4 /* VAG Transport Protocol v2.0 */
  214. #define CAN_MCNET 5 /* Bosch MCNet */
  215. #define CAN_ISOTP 6 /* ISO 15765-2 Transport Protocol */
  216. #define CAN_J1939 7 /* SAE J1939 */
  217. #define CAN_NPROTO 8
  218. #define SOL_CAN_BASE 100
  219. /**
  220. * struct sockaddr_can - the sockaddr structure for CAN sockets
  221. * @can_family: address family number AF_CAN.
  222. * @can_ifindex: CAN network interface index.
  223. * @can_addr: protocol specific address information
  224. */
  225. struct sockaddr_can {
  226. __kernel_sa_family_t can_family;
  227. int can_ifindex;
  228. union {
  229. /* transport protocol class address information (e.g. ISOTP) */
  230. struct { canid_t rx_id, tx_id; } tp;
  231. /* J1939 address information */
  232. struct {
  233. /* 8 byte name when using dynamic addressing */
  234. __u64 name;
  235. /* pgn:
  236. * 8 bit: PS in PDU2 case, else 0
  237. * 8 bit: PF
  238. * 1 bit: DP
  239. * 1 bit: reserved
  240. */
  241. __u32 pgn;
  242. /* 1 byte address */
  243. __u8 addr;
  244. } j1939;
  245. /* reserved for future CAN protocols address information */
  246. } can_addr;
  247. };
  248. /**
  249. * struct can_filter - CAN ID based filter in can_register().
  250. * @can_id: relevant bits of CAN ID which are not masked out.
  251. * @can_mask: CAN mask (see description)
  252. *
  253. * Description:
  254. * A filter matches, when
  255. *
  256. * <received_can_id> & mask == can_id & mask
  257. *
  258. * The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
  259. * filter for error message frames (CAN_ERR_FLAG bit set in mask).
  260. */
  261. struct can_filter {
  262. canid_t can_id;
  263. canid_t can_mask;
  264. };
  265. #define CAN_INV_FILTER 0x20000000U /* to be set in can_filter.can_id */
  266. #endif /* !_UAPI_CAN_H */