Contributors: 19
| Author |
Tokens |
Token Proportion |
Commits |
Commit Proportion |
| Wolfgang Grandegger |
304 |
36.94% |
5 |
8.77% |
| Vincent Mailhol |
212 |
25.76% |
18 |
31.58% |
| Oliver Hartkopp |
117 |
14.22% |
10 |
17.54% |
| Marc Kleine-Budde |
63 |
7.65% |
9 |
15.79% |
| Zhu Yi |
31 |
3.77% |
1 |
1.75% |
| Oleksij Rempel |
23 |
2.79% |
1 |
1.75% |
| Franklin S Cooper Jr |
16 |
1.94% |
1 |
1.75% |
| Andri Yngvason |
13 |
1.58% |
1 |
1.75% |
| Vadim Fedorenko |
12 |
1.46% |
1 |
1.75% |
| Sergei Miroshnichenko |
7 |
0.85% |
1 |
1.75% |
| Kurt Van Dijck |
7 |
0.85% |
1 |
1.75% |
| Gerhard Bertelsmann |
6 |
0.73% |
1 |
1.75% |
| Anant Gole |
3 |
0.36% |
1 |
1.75% |
| Christian Pellegrin |
3 |
0.36% |
1 |
1.75% |
| Fabio Baltieri |
2 |
0.24% |
1 |
1.75% |
| Yaowei Bai |
1 |
0.12% |
1 |
1.75% |
| Wolfram Sang |
1 |
0.12% |
1 |
1.75% |
| Greg Kroah-Hartman |
1 |
0.12% |
1 |
1.75% |
| Kory Maincent |
1 |
0.12% |
1 |
1.75% |
| Total |
823 |
|
57 |
|
/* SPDX-License-Identifier: GPL-2.0 */
/*
* linux/can/dev.h
*
* Definitions for the CAN network device driver interface
*
* Copyright (C) 2006 Andrey Volkov <avolkov@varma-el.com>
* Varma Electronics Oy
*
* Copyright (C) 2008 Wolfgang Grandegger <wg@grandegger.com>
*
*/
#ifndef _CAN_DEV_H
#define _CAN_DEV_H
#include <linux/can.h>
#include <linux/can/bittiming.h>
#include <linux/can/error.h>
#include <linux/can/length.h>
#include <linux/can/netlink.h>
#include <linux/can/skb.h>
#include <linux/ethtool.h>
#include <linux/netdevice.h>
/*
* CAN mode
*/
enum can_mode {
CAN_MODE_STOP = 0,
CAN_MODE_START,
CAN_MODE_SLEEP
};
enum can_termination_gpio {
CAN_TERMINATION_GPIO_DISABLED = 0,
CAN_TERMINATION_GPIO_ENABLED,
CAN_TERMINATION_GPIO_MAX,
};
/*
* CAN common private data
*/
struct can_priv {
struct net_device *dev;
struct can_device_stats can_stats;
const struct can_bittiming_const *bittiming_const;
struct can_bittiming bittiming;
struct data_bittiming_params fd, xl;
unsigned int bitrate_const_cnt;
const u32 *bitrate_const;
u32 bitrate_max;
struct can_clock clock;
unsigned int termination_const_cnt;
const u16 *termination_const;
u16 termination;
struct gpio_desc *termination_gpio;
u16 termination_gpio_ohms[CAN_TERMINATION_GPIO_MAX];
unsigned int echo_skb_max;
struct sk_buff **echo_skb;
enum can_state state;
/* CAN controller features - see include/uapi/linux/can/netlink.h */
u32 ctrlmode; /* current options setting */
u32 ctrlmode_supported; /* options that can be modified by netlink */
int restart_ms;
struct delayed_work restart_work;
int (*do_set_bittiming)(struct net_device *dev);
int (*do_set_mode)(struct net_device *dev, enum can_mode mode);
int (*do_set_termination)(struct net_device *dev, u16 term);
int (*do_get_state)(const struct net_device *dev,
enum can_state *state);
int (*do_get_berr_counter)(const struct net_device *dev,
struct can_berr_counter *bec);
};
static inline bool can_fd_tdc_is_enabled(const struct can_priv *priv)
{
return !!(priv->ctrlmode & CAN_CTRLMODE_FD_TDC_MASK);
}
static inline bool can_xl_tdc_is_enabled(const struct can_priv *priv)
{
return !!(priv->ctrlmode & CAN_CTRLMODE_XL_TDC_MASK);
}
static inline u32 can_get_static_ctrlmode(struct can_priv *priv)
{
return priv->ctrlmode & ~priv->ctrlmode_supported;
}
static inline bool can_is_canxl_dev_mtu(unsigned int mtu)
{
return (mtu >= CANXL_MIN_MTU && mtu <= CANXL_MAX_MTU);
}
void can_setup(struct net_device *dev);
struct net_device *alloc_candev_mqs(int sizeof_priv, unsigned int echo_skb_max,
unsigned int txqs, unsigned int rxqs);
#define alloc_candev(sizeof_priv, echo_skb_max) \
alloc_candev_mqs(sizeof_priv, echo_skb_max, 1, 1)
#define alloc_candev_mq(sizeof_priv, echo_skb_max, count) \
alloc_candev_mqs(sizeof_priv, echo_skb_max, count, count)
void free_candev(struct net_device *dev);
/* a candev safe wrapper around netdev_priv */
struct can_priv *safe_candev_priv(struct net_device *dev);
int open_candev(struct net_device *dev);
void close_candev(struct net_device *dev);
void can_set_default_mtu(struct net_device *dev);
void can_set_cap_info(struct net_device *dev);
int __must_check can_set_static_ctrlmode(struct net_device *dev,
u32 static_mode);
int can_hwtstamp_get(struct net_device *netdev,
struct kernel_hwtstamp_config *cfg);
int can_hwtstamp_set(struct net_device *netdev,
struct kernel_hwtstamp_config *cfg,
struct netlink_ext_ack *extack);
int can_ethtool_op_get_ts_info_hwts(struct net_device *dev,
struct kernel_ethtool_ts_info *info);
int register_candev(struct net_device *dev);
void unregister_candev(struct net_device *dev);
int can_restart_now(struct net_device *dev);
void can_bus_off(struct net_device *dev);
const char *can_get_state_str(const enum can_state state);
const char *can_get_ctrlmode_str(u32 ctrlmode);
static inline bool can_dev_in_xl_only_mode(struct can_priv *priv)
{
const u32 mixed_mode = CAN_CTRLMODE_FD | CAN_CTRLMODE_XL;
/* When CAN XL is enabled but FD is disabled we are running in
* the so-called 'CANXL-only mode' where the error signalling is
* disabled. This helper function determines the required value
* to disable error signalling in the CAN XL controller.
* The so-called CC/FD/XL 'mixed mode' requires error signalling.
*/
return ((priv->ctrlmode & mixed_mode) == CAN_CTRLMODE_XL);
}
/* drop skb if it does not contain a valid CAN frame for sending */
static inline bool can_dev_dropped_skb(struct net_device *dev, struct sk_buff *skb)
{
struct can_priv *priv = netdev_priv(dev);
u32 silent_mode = priv->ctrlmode & (CAN_CTRLMODE_LISTENONLY |
CAN_CTRLMODE_RESTRICTED);
if (silent_mode) {
netdev_info_once(dev, "interface in %s mode, dropping skb\n",
can_get_ctrlmode_str(silent_mode));
goto invalid_skb;
}
if (!(priv->ctrlmode & CAN_CTRLMODE_FD) && can_is_canfd_skb(skb)) {
netdev_info_once(dev, "CAN FD is disabled, dropping skb\n");
goto invalid_skb;
}
if (can_dev_in_xl_only_mode(priv) && !can_is_canxl_skb(skb)) {
netdev_info_once(dev,
"Error signaling is disabled, dropping skb\n");
goto invalid_skb;
}
return can_dropped_invalid_skb(dev, skb);
invalid_skb:
kfree_skb(skb);
dev->stats.tx_dropped++;
return true;
}
void can_state_get_by_berr_counter(const struct net_device *dev,
const struct can_berr_counter *bec,
enum can_state *tx_state,
enum can_state *rx_state);
void can_change_state(struct net_device *dev, struct can_frame *cf,
enum can_state tx_state, enum can_state rx_state);
#ifdef CONFIG_OF
void of_can_transceiver(struct net_device *dev);
#else
static inline void of_can_transceiver(struct net_device *dev) { }
#endif
extern struct rtnl_link_ops can_link_ops;
int can_netlink_register(void);
void can_netlink_unregister(void);
#endif /* !_CAN_DEV_H */