1/* SPDX-License-Identifier: GPL-2.0 */ 2/* Copyright (C) 2020 Oliver Hartkopp <socketcan@hartkopp.net> 3 * Copyright (C) 2020 Marc Kleine-Budde <kernel@pengutronix.de> 4 * Copyright (C) 2020, 2023 Vincent Mailhol <mailhol.vincent@wanadoo.fr> 5 */ 6 7#ifndef _CAN_LENGTH_H 8#define _CAN_LENGTH_H 9 10#include <linux/bits.h> 11#include <linux/can.h> 12#include <linux/can/netlink.h> 13#include <linux/math.h> 14 15/* 16 * Size of a Classical CAN Standard Frame header in bits 17 * 18 * Name of Field Bits 19 * --------------------------------------------------------- 20 * Start Of Frame (SOF) 1 21 * Arbitration field: 22 * base ID 11 23 * Remote Transmission Request (RTR) 1 24 * Control field: 25 * IDentifier Extension bit (IDE) 1 26 * FD Format indicator (FDF) 1 27 * Data Length Code (DLC) 4 28 * 29 * including all fields preceding the data field, ignoring bitstuffing 30 */ 31#define CAN_FRAME_HEADER_SFF_BITS 19 32 33/* 34 * Size of a Classical CAN Extended Frame header in bits 35 * 36 * Name of Field Bits 37 * --------------------------------------------------------- 38 * Start Of Frame (SOF) 1 39 * Arbitration field: 40 * base ID 11 41 * Substitute Remote Request (SRR) 1 42 * IDentifier Extension bit (IDE) 1 43 * ID extension 18 44 * Remote Transmission Request (RTR) 1 45 * Control field: 46 * FD Format indicator (FDF) 1 47 * Reserved bit (r0) 1 48 * Data length code (DLC) 4 49 * 50 * including all fields preceding the data field, ignoring bitstuffing 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 Bits 58 * --------------------------------------------------------- 59 * Start Of Frame (SOF) 1 60 * Arbitration field: 61 * base ID 11 62 * Remote Request Substitution (RRS) 1 63 * Control field: 64 * IDentifier Extension bit (IDE) 1 65 * FD Format indicator (FDF) 1 66 * Reserved bit (res) 1 67 * Bit Rate Switch (BRS) 1 68 * Error Status Indicator (ESI) 1 69 * Data length code (DLC) 4 70 * 71 * including all fields preceding the data field, ignoring bitstuffing 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 Bits 79 * --------------------------------------------------------- 80 * Start Of Frame (SOF) 1 81 * Arbitration field: 82 * base ID 11 83 * Substitute Remote Request (SRR) 1 84 * IDentifier Extension bit (IDE) 1 85 * ID extension 18 86 * Remote Request Substitution (RRS) 1 87 * Control field: 88 * FD Format indicator (FDF) 1 89 * Reserved bit (res) 1 90 * Bit Rate Switch (BRS) 1 91 * Error Status Indicator (ESI) 1 92 * Data length code (DLC) 4 93 * 94 * including all fields preceding the data field, ignoring bitstuffing 95 */ 96#define CANFD_FRAME_HEADER_EFF_BITS 41 97 98/* 99 * Size of a CAN CRC Field in bits 100 * 101 * Name of Field Bits 102 * --------------------------------------------------------- 103 * CRC sequence (CRC15) 15 104 * CRC Delimiter 1 105 * 106 * ignoring bitstuffing 107 */ 108#define CAN_FRAME_CRC_FIELD_BITS 16 109 110/* 111 * Size of a CAN-FD CRC17 Field in bits (length: 0..16) 112 * 113 * Name of Field Bits 114 * --------------------------------------------------------- 115 * Stuff Count 4 116 * CRC Sequence (CRC17) 17 117 * CRC Delimiter 1 118 * Fixed stuff bits 6 119 */ 120#define CANFD_FRAME_CRC17_FIELD_BITS 28 121 122/* 123 * Size of a CAN-FD CRC21 Field in bits (length: 20..64) 124 * 125 * Name of Field Bits 126 * --------------------------------------------------------- 127 * Stuff Count 4 128 * CRC sequence (CRC21) 21 129 * CRC Delimiter 1 130 * Fixed stuff bits 7 131 */ 132#define CANFD_FRAME_CRC21_FIELD_BITS 33 133 134/* 135 * Size of a CAN(-FD) Frame footer in bits 136 * 137 * Name of Field Bits 138 * --------------------------------------------------------- 139 * ACK slot 1 140 * ACK delimiter 1 141 * End Of Frame (EOF) 7 142 * 143 * including all fields following the CRC field 144 */ 145#define CAN_FRAME_FOOTER_BITS 9 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 maximum length with bitstuffing 155 * @destuffed_len: length of a destuffed bit stream 156 * 157 * The worst bit stuffing case is a sequence in which dominant and 158 * recessive bits alternate every four bits: 159 * 160 * Destuffed: 1 1111 0000 1111 0000 1111 161 * Stuffed: 1 1111o 0000i 1111o 0000i 1111o 162 * 163 * Nomenclature 164 * 165 * - "0": 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 added every four bits. 171 * 172 * Return: length of the stuffed bit stream in the worst case scenario. 173 */ 174#define can_bitstuffing_len(destuffed_len) \ 175 (destuffed_len + (destuffed_len - 1) / 4) 176 177#define __can_bitstuffing_len(bitstuffing, destuffed_len) \ 178 (bitstuffing ? can_bitstuffing_len(destuffed_len) : \ 179 destuffed_len) 180 181#define __can_cc_frame_bits(is_eff, bitstuffing, \ 182 intermission, data_len) \ 183( \ 184 __can_bitstuffing_len(bitstuffing, \ 185 (is_eff ? CAN_FRAME_HEADER_EFF_BITS : \ 186 CAN_FRAME_HEADER_SFF_BITS) + \ 187 (data_len) * BITS_PER_BYTE + \ 188 CAN_FRAME_CRC_FIELD_BITS) + \ 189 CAN_FRAME_FOOTER_BITS + \ 190 (intermission ? CAN_INTERMISSION_BITS : 0) \ 191) 192 193#define __can_fd_frame_bits(is_eff, bitstuffing, \ 194 intermission, data_len) \ 195( \ 196 __can_bitstuffing_len(bitstuffing, \ 197 (is_eff ? CANFD_FRAME_HEADER_EFF_BITS : \ 198 CANFD_FRAME_HEADER_SFF_BITS) + \ 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 : 0) \ 205) 206 207/** 208 * can_frame_bits() - Calculate the number of bits on the wire in a 209 * CAN frame 210 * @is_fd: true: CAN-FD frame; false: Classical CAN frame. 211 * @is_eff: true: Extended frame; false: Standard frame. 212 * @bitstuffing: true: calculate the bitstuffing worst case; false: 213 * calculate the bitstuffing best case (no dynamic 214 * bitstuffing). CAN-FD's fixed stuff bits are always included. 215 * @intermission: if and only if true, include the inter frame space 216 * assuming no bus idle (i.e. only the intermission). Strictly 217 * speaking, the inter frame space is not part of the 218 * frame. However, it is needed when calculating the delay 219 * between the Start Of Frame of two consecutive frames. 220 * @data_len: length of the data field in bytes. Correspond to 221 * can(fd)_frame->len. Should be zero for remote frames. No 222 * sanitization is done on @data_len and it shall have no side 223 * effects. 224 * 225 * Return: the numbers of bits on the wire of a CAN frame. 226 */ 227#define can_frame_bits(is_fd, is_eff, bitstuffing, \ 228 intermission, data_len) \ 229( \ 230 is_fd ? __can_fd_frame_bits(is_eff, bitstuffing, \ 231 intermission, data_len) : \ 232 __can_cc_frame_bits(is_eff, bitstuffing, \ 233 intermission, data_len) \ 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, bitstuffing, data_len) \ 241 DIV_ROUND_UP(can_frame_bits(is_fd, is_eff, bitstuffing, \ 242 true, data_len), \ 243 BITS_PER_BYTE) 244 245/* 246 * Maximum size of a Classical CAN frame 247 * (rounded up, ignoring bitstuffing but including intermission) 248 */ 249#define CAN_FRAME_LEN_MAX can_frame_bytes(false, true, false, CAN_MAX_DLEN) 250 251/* 252 * Maximum size of a CAN-FD frame 253 * (rounded up, ignoring dynamic bitstuffing but including intermission) 254 */ 255#define CANFD_FRAME_LEN_MAX can_frame_bytes(true, true, false, CANFD_MAX_DLEN) 256 257/* 258 * can_cc_dlc2len(value) - convert a given data length code (dlc) of a 259 * Classical CAN frame into a valid data length of max. 8 bytes. 260 * 261 * To be used in the CAN netdriver receive path to ensure conformance with 262 * ISO 11898-1 Chapter 8.4.2.3 (DLC field) 263 */ 264#define can_cc_dlc2len(dlc) (min_t(u8, (dlc), CAN_MAX_DLEN)) 265 266/* helper to get the data length code (DLC) for Classical CAN raw DLC access */ 267static inline u8 can_get_cc_dlc(const struct can_frame *cf, const u32 ctrlmode) 268{ 269 /* return len8_dlc as dlc value only if all conditions apply */ 270 if ((ctrlmode & CAN_CTRLMODE_CC_LEN8_DLC) && 271 (cf->len == CAN_MAX_DLEN) && 272 (cf->len8_dlc > CAN_MAX_DLEN && cf->len8_dlc <= CAN_MAX_RAW_DLC)) 273 return cf->len8_dlc; 274 275 /* return the payload length as dlc value */ 276 return cf->len; 277} 278 279/* helper to set len and len8_dlc value for Classical CAN raw DLC access */ 280static inline void can_frame_set_cc_len(struct can_frame *cf, const u8 dlc, 281 const u32 ctrlmode) 282{ 283 /* the caller already ensured that dlc is a value from 0 .. 15 */ 284 if (ctrlmode & CAN_CTRLMODE_CC_LEN8_DLC && dlc > CAN_MAX_DLEN) 285 cf->len8_dlc = dlc; 286 287 /* limit the payload length 'len' to CAN_MAX_DLEN */ 288 cf->len = can_cc_dlc2len(dlc); 289} 290 291/* get data length from raw data length code (DLC) */ 292u8 can_fd_dlc2len(u8 dlc); 293 294/* map the sanitized data length to an appropriate data length code */ 295u8 can_fd_len2dlc(u8 len); 296 297/* calculate the CAN Frame length in bytes of a given skb */ 298unsigned int can_skb_get_frame_len(const struct sk_buff *skb); 299 300/* map the data length to an appropriate data link layer length */ 301static inline u8 canfd_sanitize_len(u8 len) 302{ 303 return can_fd_dlc2len(can_fd_len2dlc(len)); 304} 305 306#endif /* !_CAN_LENGTH_H */ 307