1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix 3 * Copyright (C) 2006 Andrey Volkov, Varma Electronics 4 * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com> 5 */ 6 7 #include <linux/can/can-ml.h> 8 #include <linux/can/dev.h> 9 #include <linux/module.h> 10 #include <net/can.h> 11 12 #define MOD_DESC "CAN device driver interface" 13 14 MODULE_DESCRIPTION(MOD_DESC); 15 MODULE_LICENSE("GPL v2"); 16 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>"); 17 18 /* Local echo of CAN messages 19 * 20 * CAN network devices *should* support a local echo functionality 21 * (see Documentation/networking/can.rst). To test the handling of CAN 22 * interfaces that do not support the local echo both driver types are 23 * implemented. In the case that the driver does not support the echo 24 * the IFF_ECHO remains clear in dev->flags. This causes the PF_CAN core 25 * to perform the echo as a fallback solution. 26 */ 27 void can_flush_echo_skb(struct net_device *dev) 28 { 29 struct can_priv *priv = netdev_priv(dev); 30 struct net_device_stats *stats = &dev->stats; 31 int i; 32 33 for (i = 0; i < priv->echo_skb_max; i++) { 34 if (priv->echo_skb[i]) { 35 kfree_skb(priv->echo_skb[i]); 36 priv->echo_skb[i] = NULL; 37 stats->tx_dropped++; 38 stats->tx_aborted_errors++; 39 } 40 } 41 } 42 43 /* Put the skb on the stack to be looped backed locally lateron 44 * 45 * The function is typically called in the start_xmit function 46 * of the device driver. The driver must protect access to 47 * priv->echo_skb, if necessary. 48 */ 49 int can_put_echo_skb(struct sk_buff *skb, struct net_device *dev, 50 unsigned int idx, unsigned int frame_len) 51 { 52 struct can_priv *priv = netdev_priv(dev); 53 struct can_skb_ext *csx; 54 55 if (idx >= priv->echo_skb_max) { 56 netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n", 57 __func__, idx, priv->echo_skb_max); 58 dev_kfree_skb_any(skb); 59 return -EINVAL; 60 } 61 62 /* check flag whether this packet has to be looped back */ 63 if (!(dev->flags & IFF_ECHO) || 64 (skb->protocol != htons(ETH_P_CAN) && 65 skb->protocol != htons(ETH_P_CANFD) && 66 skb->protocol != htons(ETH_P_CANXL))) { 67 dev_kfree_skb_any(skb); 68 return 0; 69 } 70 71 if (!priv->echo_skb[idx]) { 72 skb = can_create_echo_skb(skb); 73 if (!skb) 74 return -ENOMEM; 75 76 /* make settings for echo to reduce code in irq context */ 77 skb->ip_summed = CHECKSUM_UNNECESSARY; 78 skb->dev = dev; 79 80 /* save frame_len to reuse it when transmission is completed */ 81 csx = can_skb_ext_find(skb); 82 if (csx) 83 csx->can_framelen = frame_len; 84 85 if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) 86 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS; 87 88 skb_tx_timestamp(skb); 89 90 /* save this skb for tx interrupt echo handling */ 91 priv->echo_skb[idx] = skb; 92 } else { 93 /* locking problem with netif_stop_queue() ?? */ 94 netdev_err(dev, "%s: BUG! echo_skb %d is occupied!\n", __func__, idx); 95 dev_kfree_skb_any(skb); 96 return -EBUSY; 97 } 98 99 return 0; 100 } 101 EXPORT_SYMBOL_GPL(can_put_echo_skb); 102 103 struct sk_buff * 104 __can_get_echo_skb(struct net_device *dev, unsigned int idx, 105 unsigned int *len_ptr, unsigned int *frame_len_ptr) 106 { 107 struct can_priv *priv = netdev_priv(dev); 108 109 if (idx >= priv->echo_skb_max) { 110 netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n", 111 __func__, idx, priv->echo_skb_max); 112 return NULL; 113 } 114 115 if (priv->echo_skb[idx]) { 116 /* Using "struct canfd_frame::len" for the frame 117 * length is supported on both CAN and CANFD frames. 118 */ 119 struct sk_buff *skb = priv->echo_skb[idx]; 120 struct can_skb_ext *csx; 121 122 if (skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS) 123 skb_tstamp_tx(skb, skb_hwtstamps(skb)); 124 125 /* get the real payload length for netdev statistics */ 126 *len_ptr = can_skb_get_data_len(skb); 127 128 if (frame_len_ptr) { 129 csx = can_skb_ext_find(skb); 130 if (csx) 131 *frame_len_ptr = csx->can_framelen; 132 else 133 *frame_len_ptr = 0; 134 } 135 136 priv->echo_skb[idx] = NULL; 137 138 if (skb->pkt_type == PACKET_LOOPBACK) { 139 skb->pkt_type = PACKET_BROADCAST; 140 } else { 141 dev_consume_skb_any(skb); 142 return NULL; 143 } 144 145 return skb; 146 } 147 148 return NULL; 149 } 150 151 /* Get the skb from the stack and loop it back locally 152 * 153 * The function is typically called when the TX done interrupt 154 * is handled in the device driver. The driver must protect 155 * access to priv->echo_skb, if necessary. 156 */ 157 unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx, 158 unsigned int *frame_len_ptr) 159 { 160 struct sk_buff *skb; 161 unsigned int len; 162 163 skb = __can_get_echo_skb(dev, idx, &len, frame_len_ptr); 164 if (!skb) 165 return 0; 166 167 skb_get(skb); 168 if (netif_rx(skb) == NET_RX_SUCCESS) 169 dev_consume_skb_any(skb); 170 else 171 dev_kfree_skb_any(skb); 172 173 return len; 174 } 175 EXPORT_SYMBOL_GPL(can_get_echo_skb); 176 177 /* Remove the skb from the stack and free it. 178 * 179 * The function is typically called when TX failed. 180 */ 181 void can_free_echo_skb(struct net_device *dev, unsigned int idx, 182 unsigned int *frame_len_ptr) 183 { 184 struct can_priv *priv = netdev_priv(dev); 185 186 if (idx >= priv->echo_skb_max) { 187 netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n", 188 __func__, idx, priv->echo_skb_max); 189 return; 190 } 191 192 if (priv->echo_skb[idx]) { 193 struct sk_buff *skb = priv->echo_skb[idx]; 194 struct can_skb_ext *csx; 195 196 if (frame_len_ptr) { 197 csx = can_skb_ext_find(skb); 198 if (csx) 199 *frame_len_ptr = csx->can_framelen; 200 else 201 *frame_len_ptr = 0; 202 } 203 204 dev_kfree_skb_any(skb); 205 priv->echo_skb[idx] = NULL; 206 } 207 } 208 EXPORT_SYMBOL_GPL(can_free_echo_skb); 209 210 /* fill common values for CAN sk_buffs */ 211 static void init_can_skb(struct sk_buff *skb) 212 { 213 skb->pkt_type = PACKET_BROADCAST; 214 skb->ip_summed = CHECKSUM_UNNECESSARY; 215 216 skb_reset_mac_header(skb); 217 skb_reset_network_header(skb); 218 skb_reset_transport_header(skb); 219 } 220 221 struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf) 222 { 223 struct sk_buff *skb; 224 struct can_skb_ext *csx; 225 226 skb = netdev_alloc_skb(dev, sizeof(struct can_frame)); 227 if (unlikely(!skb)) 228 goto out_error_cc; 229 230 csx = can_skb_ext_add(skb); 231 if (!csx) { 232 dev_kfree_skb_any(skb); 233 goto out_error_cc; 234 } 235 236 skb->protocol = htons(ETH_P_CAN); 237 init_can_skb(skb); 238 csx->can_iif = dev->ifindex; 239 240 *cf = skb_put_zero(skb, sizeof(struct can_frame)); 241 242 return skb; 243 244 out_error_cc: 245 *cf = NULL; 246 247 return NULL; 248 } 249 EXPORT_SYMBOL_GPL(alloc_can_skb); 250 251 struct sk_buff *alloc_canfd_skb(struct net_device *dev, 252 struct canfd_frame **cfd) 253 { 254 struct sk_buff *skb; 255 struct can_skb_ext *csx; 256 257 skb = netdev_alloc_skb(dev, sizeof(struct canfd_frame)); 258 if (unlikely(!skb)) 259 goto out_error_fd; 260 261 csx = can_skb_ext_add(skb); 262 if (!csx) { 263 dev_kfree_skb_any(skb); 264 goto out_error_fd; 265 } 266 267 skb->protocol = htons(ETH_P_CANFD); 268 init_can_skb(skb); 269 csx->can_iif = dev->ifindex; 270 271 *cfd = skb_put_zero(skb, sizeof(struct canfd_frame)); 272 273 /* set CAN FD flag by default */ 274 (*cfd)->flags = CANFD_FDF; 275 276 return skb; 277 278 out_error_fd: 279 *cfd = NULL; 280 281 return NULL; 282 } 283 EXPORT_SYMBOL_GPL(alloc_canfd_skb); 284 285 struct sk_buff *alloc_canxl_skb(struct net_device *dev, 286 struct canxl_frame **cxl, 287 unsigned int data_len) 288 { 289 struct sk_buff *skb; 290 struct can_skb_ext *csx; 291 292 if (data_len < CANXL_MIN_DLEN || data_len > CANXL_MAX_DLEN) 293 goto out_error_xl; 294 295 skb = netdev_alloc_skb(dev, CANXL_HDR_SIZE + data_len); 296 if (unlikely(!skb)) 297 goto out_error_xl; 298 299 csx = can_skb_ext_add(skb); 300 if (!csx) { 301 dev_kfree_skb_any(skb); 302 goto out_error_xl; 303 } 304 305 skb->protocol = htons(ETH_P_CANXL); 306 init_can_skb(skb); 307 csx->can_iif = dev->ifindex; 308 309 *cxl = skb_put_zero(skb, CANXL_HDR_SIZE + data_len); 310 311 /* set CAN XL flag and length information by default */ 312 (*cxl)->flags = CANXL_XLF; 313 (*cxl)->len = data_len; 314 315 return skb; 316 317 out_error_xl: 318 *cxl = NULL; 319 320 return NULL; 321 } 322 EXPORT_SYMBOL_GPL(alloc_canxl_skb); 323 324 struct sk_buff *alloc_can_err_skb(struct net_device *dev, struct can_frame **cf) 325 { 326 struct sk_buff *skb; 327 328 skb = alloc_can_skb(dev, cf); 329 if (unlikely(!skb)) 330 return NULL; 331 332 (*cf)->can_id = CAN_ERR_FLAG; 333 (*cf)->len = CAN_ERR_DLC; 334 335 return skb; 336 } 337 EXPORT_SYMBOL_GPL(alloc_can_err_skb); 338 339 /* Check for outgoing skbs that have not been created by the CAN subsystem */ 340 static bool can_skb_init_valid(struct net_device *dev, struct sk_buff *skb) 341 { 342 struct can_skb_ext *csx = can_skb_ext_find(skb); 343 344 /* af_packet does not apply CAN skb specific settings */ 345 if (skb->ip_summed == CHECKSUM_NONE || !csx) { 346 /* init CAN skb content */ 347 if (!csx) { 348 csx = can_skb_ext_add(skb); 349 if (!csx) 350 return false; 351 } 352 353 csx->can_iif = dev->ifindex; 354 skb->ip_summed = CHECKSUM_UNNECESSARY; 355 356 /* perform proper loopback on capable devices */ 357 if (dev->flags & IFF_ECHO) 358 skb->pkt_type = PACKET_LOOPBACK; 359 else 360 skb->pkt_type = PACKET_HOST; 361 362 skb_reset_mac_header(skb); 363 skb_reset_network_header(skb); 364 skb_reset_transport_header(skb); 365 366 /* set CANFD_FDF flag for CAN FD frames */ 367 if (can_is_canfd_skb(skb)) { 368 struct canfd_frame *cfd; 369 370 cfd = (struct canfd_frame *)skb->data; 371 cfd->flags |= CANFD_FDF; 372 } 373 } 374 375 return true; 376 } 377 378 /* Drop a given socketbuffer if it does not contain a valid CAN frame. */ 379 bool can_dropped_invalid_skb(struct net_device *dev, struct sk_buff *skb) 380 { 381 switch (ntohs(skb->protocol)) { 382 case ETH_P_CAN: 383 if (!can_is_can_skb(skb)) 384 goto inval_skb; 385 break; 386 387 case ETH_P_CANFD: 388 if (!can_is_canfd_skb(skb)) 389 goto inval_skb; 390 break; 391 392 case ETH_P_CANXL: 393 if (!can_cap_enabled(dev, CAN_CAP_XL) || !can_is_canxl_skb(skb)) 394 goto inval_skb; 395 break; 396 397 default: 398 goto inval_skb; 399 } 400 401 if (!can_skb_init_valid(dev, skb)) 402 goto inval_skb; 403 404 return false; 405 406 inval_skb: 407 dev_kfree_skb_any(skb); 408 dev->stats.tx_dropped++; 409 return true; 410 } 411 EXPORT_SYMBOL_GPL(can_dropped_invalid_skb); 412