// SPDX-License-Identifier: GPL-2.0-only/* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix * Copyright (C) 2006 Andrey Volkov, Varma Electronics * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com> */ #include <linux/can/dev.h>#include <linux/module.h>#include <net/can.h> #define MOD_DESC "CAN device driver interface" MODULE_DESCRIPTION(MOD_DESC);MODULE_LICENSE("GPL v2");MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>"); /* Local echo of CAN messages * * CAN network devices *should* support a local echo functionality * (see Documentation/networking/can.rst). To test the handling of CAN * interfaces that do not support the local echo both driver types are * implemented. In the case that the driver does not support the echo * the IFF_ECHO remains clear in dev->flags. This causes the PF_CAN core * to perform the echo as a fallback solution. */void can_flush_echo_skb(struct net_device *dev){	struct can_priv *priv = netdev_priv(dev);	struct net_device_stats *stats = &dev->stats;	int i; 	for (i = 0; i < priv->echo_skb_max; i++) {		if (priv->echo_skb[i]) {			kfree_skb(priv->echo_skb[i]);			priv->echo_skb[i] = NULL;			stats->tx_dropped++;			stats->tx_aborted_errors++;		}	}} /* Put the skb on the stack to be looped backed locally lateron * * The function is typically called in the start_xmit function * of the device driver. The driver must protect access to * priv->echo_skb, if necessary. */int can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,		     unsigned int idx, unsigned int frame_len){	struct can_priv *priv = netdev_priv(dev);	struct can_skb_ext *csx; 	if (idx >= priv->echo_skb_max) {		netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n",			   __func__, idx, priv->echo_skb_max);		return -EINVAL;	} 	/* check flag whether this packet has to be looped back */	if (!(dev->flags & IFF_ECHO) ||	    (skb->protocol != htons(ETH_P_CAN) &&	     skb->protocol != htons(ETH_P_CANFD) &&	     skb->protocol != htons(ETH_P_CANXL))) {		kfree_skb(skb);		return 0;	} 	if (!priv->echo_skb[idx]) {		skb = can_create_echo_skb(skb);		if (!skb)			return -ENOMEM; 		/* make settings for echo to reduce code in irq context */		skb->ip_summed = CHECKSUM_UNNECESSARY;		skb->dev = dev; 		/* save frame_len to reuse it when transmission is completed */		csx = can_skb_ext_find(skb);		if (csx)			csx->can_framelen = frame_len; 		if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)			skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS; 		skb_tx_timestamp(skb); 		/* save this skb for tx interrupt echo handling */		priv->echo_skb[idx] = skb;	} else {		/* locking problem with netif_stop_queue() ?? */		netdev_err(dev, "%s: BUG! echo_skb %d is occupied!\n", __func__, idx);		kfree_skb(skb);		return -EBUSY;	} 	return 0;}EXPORT_SYMBOL_GPL(can_put_echo_skb); struct sk_buff *__can_get_echo_skb(struct net_device *dev, unsigned int idx,		   unsigned int *len_ptr, unsigned int *frame_len_ptr){	struct can_priv *priv = netdev_priv(dev); 	if (idx >= priv->echo_skb_max) {		netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n",			   __func__, idx, priv->echo_skb_max);		return NULL;	} 	if (priv->echo_skb[idx]) {		/* Using "struct canfd_frame::len" for the frame		 * length is supported on both CAN and CANFD frames.		 */		struct sk_buff *skb = priv->echo_skb[idx];		struct can_skb_ext *csx; 		if (skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS)			skb_tstamp_tx(skb, skb_hwtstamps(skb)); 		/* get the real payload length for netdev statistics */		*len_ptr = can_skb_get_data_len(skb); 		if (frame_len_ptr) {			csx = can_skb_ext_find(skb);			if (csx)				*frame_len_ptr = csx->can_framelen;			else				*frame_len_ptr = 0;		} 		priv->echo_skb[idx] = NULL; 		if (skb->pkt_type == PACKET_LOOPBACK) {			skb->pkt_type = PACKET_BROADCAST;		} else {			dev_consume_skb_any(skb);			return NULL;		} 		return skb;	} 	return NULL;} /* Get the skb from the stack and loop it back locally * * The function is typically called when the TX done interrupt * is handled in the device driver. The driver must protect * access to priv->echo_skb, if necessary. */unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx,			      unsigned int *frame_len_ptr){	struct sk_buff *skb;	unsigned int len; 	skb = __can_get_echo_skb(dev, idx, &len, frame_len_ptr);	if (!skb)		return 0; 	skb_get(skb);	if (netif_rx(skb) == NET_RX_SUCCESS)		dev_consume_skb_any(skb);	else		dev_kfree_skb_any(skb); 	return len;}EXPORT_SYMBOL_GPL(can_get_echo_skb); /* Remove the skb from the stack and free it. * * The function is typically called when TX failed. */void can_free_echo_skb(struct net_device *dev, unsigned int idx,		       unsigned int *frame_len_ptr){	struct can_priv *priv = netdev_priv(dev); 	if (idx >= priv->echo_skb_max) {		netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n",			   __func__, idx, priv->echo_skb_max);		return;	} 	if (priv->echo_skb[idx]) {		struct sk_buff *skb = priv->echo_skb[idx];		struct can_skb_ext *csx; 		if (frame_len_ptr) {			csx = can_skb_ext_find(skb);			if (csx)				*frame_len_ptr = csx->can_framelen;			else				*frame_len_ptr = 0;		} 		dev_kfree_skb_any(skb);		priv->echo_skb[idx] = NULL;	}}EXPORT_SYMBOL_GPL(can_free_echo_skb); /* fill common values for CAN sk_buffs */static void init_can_skb(struct sk_buff *skb){	skb->pkt_type = PACKET_BROADCAST;	skb->ip_summed = CHECKSUM_UNNECESSARY;} struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf){	struct sk_buff *skb;	struct can_skb_ext *csx; 	skb = netdev_alloc_skb(dev, sizeof(struct can_frame));	if (unlikely(!skb))		goto out_error_cc; 	csx = can_skb_ext_add(skb);	if (!csx) {		kfree_skb(skb);		goto out_error_cc;	} 	skb->protocol = htons(ETH_P_CAN);	init_can_skb(skb);	csx->can_iif = dev->ifindex; 	*cf = skb_put_zero(skb, sizeof(struct can_frame)); 	return skb; out_error_cc:	*cf = NULL; 	return NULL;}EXPORT_SYMBOL_GPL(alloc_can_skb); struct sk_buff *alloc_canfd_skb(struct net_device *dev,				struct canfd_frame **cfd){	struct sk_buff *skb;	struct can_skb_ext *csx; 	skb = netdev_alloc_skb(dev, sizeof(struct canfd_frame));	if (unlikely(!skb))		goto out_error_fd; 	csx = can_skb_ext_add(skb);	if (!csx) {		kfree_skb(skb);		goto out_error_fd;	} 	skb->protocol = htons(ETH_P_CANFD);	init_can_skb(skb);	csx->can_iif = dev->ifindex; 	*cfd = skb_put_zero(skb, sizeof(struct canfd_frame)); 	/* set CAN FD flag by default */	(*cfd)->flags = CANFD_FDF; 	return skb; out_error_fd:	*cfd = NULL; 	return NULL;}EXPORT_SYMBOL_GPL(alloc_canfd_skb); struct sk_buff *alloc_canxl_skb(struct net_device *dev,				struct canxl_frame **cxl,				unsigned int data_len){	struct sk_buff *skb;	struct can_skb_ext *csx; 	if (data_len < CANXL_MIN_DLEN || data_len > CANXL_MAX_DLEN)		goto out_error_xl; 	skb = netdev_alloc_skb(dev, CANXL_HDR_SIZE + data_len);	if (unlikely(!skb))		goto out_error_xl; 	csx = can_skb_ext_add(skb);	if (!csx) {		kfree_skb(skb);		goto out_error_xl;	} 	skb->protocol = htons(ETH_P_CANXL);	init_can_skb(skb);	csx->can_iif = dev->ifindex; 	*cxl = skb_put_zero(skb, CANXL_HDR_SIZE + data_len); 	/* set CAN XL flag and length information by default */	(*cxl)->flags = CANXL_XLF;	(*cxl)->len = data_len; 	return skb; out_error_xl:	*cxl = NULL; 	return NULL;}EXPORT_SYMBOL_GPL(alloc_canxl_skb); struct sk_buff *alloc_can_err_skb(struct net_device *dev, struct can_frame **cf){	struct sk_buff *skb; 	skb = alloc_can_skb(dev, cf);	if (unlikely(!skb))		return NULL; 	(*cf)->can_id = CAN_ERR_FLAG;	(*cf)->len = CAN_ERR_DLC; 	return skb;}EXPORT_SYMBOL_GPL(alloc_can_err_skb); /* Check for outgoing skbs that have not been created by the CAN subsystem */static bool can_skb_init_valid(struct net_device *dev, struct sk_buff *skb){	struct can_skb_ext *csx = can_skb_ext_find(skb); 	/* af_packet does not apply CAN skb specific settings */	if (skb->ip_summed == CHECKSUM_NONE || !csx) {		/* init CAN skb content */		if (!csx) {			csx = can_skb_ext_add(skb);			if (!csx)				return false;		} 		csx->can_iif = dev->ifindex;		skb->ip_summed = CHECKSUM_UNNECESSARY; 		/* perform proper loopback on capable devices */		if (dev->flags & IFF_ECHO)			skb->pkt_type = PACKET_LOOPBACK;		else			skb->pkt_type = PACKET_HOST; 		skb_reset_mac_header(skb);		skb_reset_network_header(skb);		skb_reset_transport_header(skb); 		/* set CANFD_FDF flag for CAN FD frames */		if (can_is_canfd_skb(skb)) {			struct canfd_frame *cfd; 			cfd = (struct canfd_frame *)skb->data;			cfd->flags |= CANFD_FDF;		}	} 	return true;} /* Drop a given socketbuffer if it does not contain a valid CAN frame. */bool can_dropped_invalid_skb(struct net_device *dev, struct sk_buff *skb){	switch (ntohs(skb->protocol)) {	case ETH_P_CAN:		if (!can_is_can_skb(skb))			goto inval_skb;		break; 	case ETH_P_CANFD:		if (!can_is_canfd_skb(skb))			goto inval_skb;		break; 	case ETH_P_CANXL:		if (!can_is_canxl_skb(skb))			goto inval_skb;		break; 	default:		goto inval_skb;	} 	if (!can_skb_init_valid(dev, skb))		goto inval_skb; 	return false; inval_skb:	kfree_skb(skb);	dev->stats.tx_dropped++;	return true;}EXPORT_SYMBOL_GPL(can_dropped_invalid_skb);