1 /* SPDX-License-Identifier: GPL-2.0 */ 1 /* SPDX-License-Identifier: GPL-2.0 */
2 /* Copyright (C) 2020 Oliver Hartkopp <socketc 2 /* Copyright (C) 2020 Oliver Hartkopp <socketcan@hartkopp.net>
3 * Copyright (C) 2020 Marc Kleine-Budde <kerne 3 * Copyright (C) 2020 Marc Kleine-Budde <kernel@pengutronix.de>
4 * Copyright (C) 2020, 2023 Vincent Mailhol <m <<
5 */ 4 */
6 5
7 #ifndef _CAN_LENGTH_H 6 #ifndef _CAN_LENGTH_H
8 #define _CAN_LENGTH_H 7 #define _CAN_LENGTH_H
9 8
10 #include <linux/bits.h> <<
11 #include <linux/can.h> <<
12 #include <linux/can/netlink.h> <<
13 #include <linux/math.h> <<
14 <<
15 /* 9 /*
16 * Size of a Classical CAN Standard Frame head !! 10 * Size of a Classical CAN Standard Frame
17 * <<
18 * Name of Field <<
19 * ------------------------------------------- <<
20 * Start Of Frame (SOF) <<
21 * Arbitration field: <<
22 * base ID <<
23 * Remote Transmission Request (RTR) <<
24 * Control field: <<
25 * IDentifier Extension bit (IDE) <<
26 * FD Format indicator (FDF) <<
27 * Data Length Code (DLC) <<
28 * <<
29 * including all fields preceding the data fie <<
30 */ <<
31 #define CAN_FRAME_HEADER_SFF_BITS 19 <<
32 <<
33 /* <<
34 * Size of a Classical CAN Extended Frame head <<
35 * <<
36 * Name of Field <<
37 * ------------------------------------------- <<
38 * Start Of Frame (SOF) <<
39 * Arbitration field: <<
40 * base ID <<
41 * Substitute Remote Request (SRR) <<
42 * IDentifier Extension bit (IDE) <<
43 * ID extension <<
44 * Remote Transmission Request (RTR) <<
45 * Control field: <<
46 * FD Format indicator (FDF) <<
47 * Reserved bit (r0) <<
48 * Data length code (DLC) <<
49 * 11 *
50 * including all fields preceding the data fie !! 12 * Name of Field Bits
51 */ <<
52 #define CAN_FRAME_HEADER_EFF_BITS 39 <<
53 <<
54 /* <<
55 * Size of a CAN-FD Standard Frame in bits <<
56 * <<
57 * Name of Field <<
58 * ------------------------------------------- <<
59 * Start Of Frame (SOF) <<
60 * Arbitration field: <<
61 * base ID <<
62 * Remote Request Substitution (RRS) <<
63 * Control field: <<
64 * IDentifier Extension bit (IDE) <<
65 * FD Format indicator (FDF) <<
66 * Reserved bit (res) <<
67 * Bit Rate Switch (BRS) <<
68 * Error Status Indicator (ESI) <<
69 * Data length code (DLC) <<
70 * <<
71 * including all fields preceding the data fie <<
72 */ <<
73 #define CANFD_FRAME_HEADER_SFF_BITS 22 <<
74 <<
75 /* <<
76 * Size of a CAN-FD Extended Frame in bits <<
77 * <<
78 * Name of Field <<
79 * ------------------------------------------- 13 * ---------------------------------------------------------
80 * Start Of Frame (SOF) !! 14 * Start-of-frame 1
81 * Arbitration field: !! 15 * Identifier 11
82 * base ID !! 16 * Remote transmission request (RTR) 1
83 * Substitute Remote Request (SRR) !! 17 * Identifier extension bit (IDE) 1
84 * IDentifier Extension bit (IDE) !! 18 * Reserved bit (r0) 1
85 * ID extension !! 19 * Data length code (DLC) 4
86 * Remote Request Substitution (RRS) !! 20 * Data field 0...64
87 * Control field: !! 21 * CRC 15
88 * FD Format indicator (FDF) !! 22 * CRC delimiter 1
89 * Reserved bit (res) !! 23 * ACK slot 1
90 * Bit Rate Switch (BRS) !! 24 * ACK delimiter 1
91 * Error Status Indicator (ESI) !! 25 * End-of-frame (EOF) 7
92 * Data length code (DLC) !! 26 * Inter frame spacing 3
93 * 27 *
94 * including all fields preceding the data fie !! 28 * rounded up and ignoring bitstuffing
95 */ 29 */
96 #define CANFD_FRAME_HEADER_EFF_BITS 41 !! 30 #define CAN_FRAME_OVERHEAD_SFF DIV_ROUND_UP(47, 8)
97 31
98 /* 32 /*
99 * Size of a CAN CRC Field in bits !! 33 * Size of a Classical CAN Extended Frame
100 * 34 *
101 * Name of Field Bits 35 * Name of Field Bits
102 * ------------------------------------------- 36 * ---------------------------------------------------------
103 * CRC sequence (CRC15) 15 !! 37 * Start-of-frame 1
104 * CRC Delimiter 1 !! 38 * Identifier A 11
>> 39 * Substitute remote request (SRR) 1
>> 40 * Identifier extension bit (IDE) 1
>> 41 * Identifier B 18
>> 42 * Remote transmission request (RTR) 1
>> 43 * Reserved bits (r1, r0) 2
>> 44 * Data length code (DLC) 4
>> 45 * Data field 0...64
>> 46 * CRC 15
>> 47 * CRC delimiter 1
>> 48 * ACK slot 1
>> 49 * ACK delimiter 1
>> 50 * End-of-frame (EOF) 7
>> 51 * Inter frame spacing 3
105 * 52 *
106 * ignoring bitstuffing !! 53 * rounded up and ignoring bitstuffing
107 */ 54 */
108 #define CAN_FRAME_CRC_FIELD_BITS 16 !! 55 #define CAN_FRAME_OVERHEAD_EFF DIV_ROUND_UP(67, 8)
109 56
110 /* 57 /*
111 * Size of a CAN-FD CRC17 Field in bits (lengt !! 58 * Size of a CAN-FD Standard Frame
112 * 59 *
113 * Name of Field Bits 60 * Name of Field Bits
114 * ------------------------------------------- 61 * ---------------------------------------------------------
115 * Stuff Count 4 !! 62 * Start-of-frame 1
116 * CRC Sequence (CRC17) 17 !! 63 * Identifier 11
117 * CRC Delimiter 1 !! 64 * Reserved bit (r1) 1
118 * Fixed stuff bits 6 !! 65 * Identifier extension bit (IDE) 1
119 */ !! 66 * Flexible data rate format (FDF) 1
120 #define CANFD_FRAME_CRC17_FIELD_BITS 28 !! 67 * Reserved bit (r0) 1
121 !! 68 * Bit Rate Switch (BRS) 1
122 /* !! 69 * Error Status Indicator (ESI) 1
123 * Size of a CAN-FD CRC21 Field in bits (lengt !! 70 * Data length code (DLC) 4
>> 71 * Data field 0...512
>> 72 * Stuff Bit Count (SBC) 0...16: 4 20...64:5
>> 73 * CRC 0...16: 17 20...64:21
>> 74 * CRC delimiter (CD) 1
>> 75 * ACK slot (AS) 1
>> 76 * ACK delimiter (AD) 1
>> 77 * End-of-frame (EOF) 7
>> 78 * Inter frame spacing 3
124 * 79 *
125 * Name of Field Bits !! 80 * assuming CRC21, rounded up and ignoring bitstuffing
126 * ------------------------------------------- <<
127 * Stuff Count 4 <<
128 * CRC sequence (CRC21) 21 <<
129 * CRC Delimiter 1 <<
130 * Fixed stuff bits 7 <<
131 */ 81 */
132 #define CANFD_FRAME_CRC21_FIELD_BITS 33 !! 82 #define CANFD_FRAME_OVERHEAD_SFF DIV_ROUND_UP(61, 8)
133 83
134 /* 84 /*
135 * Size of a CAN(-FD) Frame footer in bits !! 85 * Size of a CAN-FD Extended Frame
136 * 86 *
137 * Name of Field Bits 87 * Name of Field Bits
138 * ------------------------------------------- 88 * ---------------------------------------------------------
139 * ACK slot 1 !! 89 * Start-of-frame 1
140 * ACK delimiter 1 !! 90 * Identifier A 11
141 * End Of Frame (EOF) 7 !! 91 * Substitute remote request (SRR) 1
>> 92 * Identifier extension bit (IDE) 1
>> 93 * Identifier B 18
>> 94 * Reserved bit (r1) 1
>> 95 * Flexible data rate format (FDF) 1
>> 96 * Reserved bit (r0) 1
>> 97 * Bit Rate Switch (BRS) 1
>> 98 * Error Status Indicator (ESI) 1
>> 99 * Data length code (DLC) 4
>> 100 * Data field 0...512
>> 101 * Stuff Bit Count (SBC) 0...16: 4 20...64:5
>> 102 * CRC 0...16: 17 20...64:21
>> 103 * CRC delimiter (CD) 1
>> 104 * ACK slot (AS) 1
>> 105 * ACK delimiter (AD) 1
>> 106 * End-of-frame (EOF) 7
>> 107 * Inter frame spacing 3
142 * 108 *
143 * including all fields following the CRC fiel !! 109 * assuming CRC21, rounded up and ignoring bitstuffing
144 */ 110 */
145 #define CAN_FRAME_FOOTER_BITS 9 !! 111 #define CANFD_FRAME_OVERHEAD_EFF DIV_ROUND_UP(80, 8)
146 <<
147 /* <<
148 * First part of the Inter Frame Space <<
149 * (a.k.a. IMF - intermission field) <<
150 */ <<
151 #define CAN_INTERMISSION_BITS 3 <<
152 <<
153 /** <<
154 * can_bitstuffing_len() - Calculate the maxim <<
155 * @destuffed_len: length of a destuffed bit s <<
156 * <<
157 * The worst bit stuffing case is a sequence i <<
158 * recessive bits alternate every four bits: <<
159 * <<
160 * Destuffed: 1 1111 0000 1111 0000 1111 <<
161 * Stuffed: 1 1111o 0000i 1111o 0000i 1111 <<
162 * <<
163 * Nomenclature <<
164 * <<
165 * - "": dominant bit <<
166 * - "o": dominant stuff bit <<
167 * - "1": recessive bit <<
168 * - "i": recessive stuff bit <<
169 * <<
170 * Aside from the first bit, one stuff bit is <<
171 * <<
172 * Return: length of the stuffed bit stream in <<
173 */ <<
174 #define can_bitstuffing_len(destuffed_len) <<
175 (destuffed_len + (destuffed_len - 1) / <<
176 <<
177 #define __can_bitstuffing_len(bitstuffing, des <<
178 (bitstuffing ? can_bitstuffing_len(des <<
179 destuffed_len) <<
180 <<
181 #define __can_cc_frame_bits(is_eff, bitstuffin <<
182 intermission, data <<
183 ( <<
184 __can_bitstuffing_len(bitstuffing, <<
185 (is_eff ? CAN_FRAME_HEADER_EFF <<
186 CAN_FRAME_HEADER_SFF <<
187 (data_len) * BITS_PER_BYTE + <<
188 CAN_FRAME_CRC_FIELD_BITS) + <<
189 CAN_FRAME_FOOTER_BITS + <<
190 (intermission ? CAN_INTERMISSION_BITS <<
191 ) <<
192 <<
193 #define __can_fd_frame_bits(is_eff, bitstuffin <<
194 intermission, data <<
195 ( <<
196 __can_bitstuffing_len(bitstuffing, <<
197 (is_eff ? CANFD_FRAME_HEADER_E <<
198 CANFD_FRAME_HEADER_S <<
199 (data_len) * BITS_PER_BYTE) + <<
200 ((data_len) <= 16 ? <<
201 CANFD_FRAME_CRC17_FIELD_BITS : <<
202 CANFD_FRAME_CRC21_FIELD_BITS) <<
203 CAN_FRAME_FOOTER_BITS + <<
204 (intermission ? CAN_INTERMISSION_BITS <<
205 ) <<
206 <<
207 /** <<
208 * can_frame_bits() - Calculate the number of <<
209 * CAN frame <<
210 * @is_fd: true: CAN-FD frame; false: Classica <<
211 * @is_eff: true: Extended frame; false: Stand <<
212 * @bitstuffing: true: calculate the bitstuffi <<
213 * calculate the bitstuffing best case (n <<
214 * bitstuffing). CAN-FD's fixed stuff bit <<
215 * @intermission: if and only if true, include <<
216 * assuming no bus idle (i.e. only the in <<
217 * speaking, the inter frame space is not <<
218 * frame. However, it is needed when calc <<
219 * between the Start Of Frame of two cons <<
220 * @data_len: length of the data field in byte <<
221 * can(fd)_frame->len. Should be zero for <<
222 * sanitization is done on @data_len and <<
223 * effects. <<
224 * <<
225 * Return: the numbers of bits on the wire of <<
226 */ <<
227 #define can_frame_bits(is_fd, is_eff, bitstuff <<
228 intermission, data_len) <<
229 ( <<
230 is_fd ? __can_fd_frame_bits(is_eff, bi <<
231 intermissi <<
232 __can_cc_frame_bits(is_eff, bi <<
233 intermissi <<
234 ) <<
235 <<
236 /* <<
237 * Number of bytes in a CAN frame <<
238 * (rounded up, including intermission) <<
239 */ <<
240 #define can_frame_bytes(is_fd, is_eff, bitstuf <<
241 DIV_ROUND_UP(can_frame_bits(is_fd, is_ <<
242 true, data <<
243 BITS_PER_BYTE) <<
244 112
245 /* 113 /*
246 * Maximum size of a Classical CAN frame 114 * Maximum size of a Classical CAN frame
247 * (rounded up, ignoring bitstuffing but inclu !! 115 * (rounded up and ignoring bitstuffing)
248 */ 116 */
249 #define CAN_FRAME_LEN_MAX can_frame_bytes(fals !! 117 #define CAN_FRAME_LEN_MAX (CAN_FRAME_OVERHEAD_EFF + CAN_MAX_DLEN)
250 118
251 /* 119 /*
252 * Maximum size of a CAN-FD frame 120 * Maximum size of a CAN-FD frame
253 * (rounded up, ignoring dynamic bitstuffing b !! 121 * (rounded up and ignoring bitstuffing)
254 */ 122 */
255 #define CANFD_FRAME_LEN_MAX can_frame_bytes(tr !! 123 #define CANFD_FRAME_LEN_MAX (CANFD_FRAME_OVERHEAD_EFF + CANFD_MAX_DLEN)
256 124
257 /* 125 /*
258 * can_cc_dlc2len(value) - convert a given dat 126 * can_cc_dlc2len(value) - convert a given data length code (dlc) of a
259 * Classical CAN frame into a valid data lengt 127 * Classical CAN frame into a valid data length of max. 8 bytes.
260 * 128 *
261 * To be used in the CAN netdriver receive pat 129 * To be used in the CAN netdriver receive path to ensure conformance with
262 * ISO 11898-1 Chapter 8.4.2.3 (DLC field) 130 * ISO 11898-1 Chapter 8.4.2.3 (DLC field)
263 */ 131 */
264 #define can_cc_dlc2len(dlc) (min_t(u8, (dl 132 #define can_cc_dlc2len(dlc) (min_t(u8, (dlc), CAN_MAX_DLEN))
265 133
266 /* helper to get the data length code (DLC) fo 134 /* helper to get the data length code (DLC) for Classical CAN raw DLC access */
267 static inline u8 can_get_cc_dlc(const struct c 135 static inline u8 can_get_cc_dlc(const struct can_frame *cf, const u32 ctrlmode)
268 { 136 {
269 /* return len8_dlc as dlc value only i 137 /* return len8_dlc as dlc value only if all conditions apply */
270 if ((ctrlmode & CAN_CTRLMODE_CC_LEN8_D 138 if ((ctrlmode & CAN_CTRLMODE_CC_LEN8_DLC) &&
271 (cf->len == CAN_MAX_DLEN) && 139 (cf->len == CAN_MAX_DLEN) &&
272 (cf->len8_dlc > CAN_MAX_DLEN && cf 140 (cf->len8_dlc > CAN_MAX_DLEN && cf->len8_dlc <= CAN_MAX_RAW_DLC))
273 return cf->len8_dlc; 141 return cf->len8_dlc;
274 142
275 /* return the payload length as dlc va 143 /* return the payload length as dlc value */
276 return cf->len; 144 return cf->len;
277 } 145 }
278 146
279 /* helper to set len and len8_dlc value for Cl 147 /* helper to set len and len8_dlc value for Classical CAN raw DLC access */
280 static inline void can_frame_set_cc_len(struct 148 static inline void can_frame_set_cc_len(struct can_frame *cf, const u8 dlc,
281 const 149 const u32 ctrlmode)
282 { 150 {
283 /* the caller already ensured that dlc 151 /* the caller already ensured that dlc is a value from 0 .. 15 */
284 if (ctrlmode & CAN_CTRLMODE_CC_LEN8_DL 152 if (ctrlmode & CAN_CTRLMODE_CC_LEN8_DLC && dlc > CAN_MAX_DLEN)
285 cf->len8_dlc = dlc; 153 cf->len8_dlc = dlc;
286 154
287 /* limit the payload length 'len' to C 155 /* limit the payload length 'len' to CAN_MAX_DLEN */
288 cf->len = can_cc_dlc2len(dlc); 156 cf->len = can_cc_dlc2len(dlc);
289 } 157 }
290 158
291 /* get data length from raw data length code ( 159 /* get data length from raw data length code (DLC) */
292 u8 can_fd_dlc2len(u8 dlc); 160 u8 can_fd_dlc2len(u8 dlc);
293 161
294 /* map the sanitized data length to an appropr 162 /* map the sanitized data length to an appropriate data length code */
295 u8 can_fd_len2dlc(u8 len); 163 u8 can_fd_len2dlc(u8 len);
296 164
297 /* calculate the CAN Frame length in bytes of 165 /* calculate the CAN Frame length in bytes of a given skb */
298 unsigned int can_skb_get_frame_len(const struc 166 unsigned int can_skb_get_frame_len(const struct sk_buff *skb);
299 167
300 /* map the data length to an appropriate data 168 /* map the data length to an appropriate data link layer length */
301 static inline u8 canfd_sanitize_len(u8 len) 169 static inline u8 canfd_sanitize_len(u8 len)
302 { 170 {
303 return can_fd_dlc2len(can_fd_len2dlc(l 171 return can_fd_dlc2len(can_fd_len2dlc(len));
304 } 172 }
305 173
306 #endif /* !_CAN_LENGTH_H */ 174 #endif /* !_CAN_LENGTH_H */
307 175
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.