1  /* SPDX-License-Identifier: GPL-2.0 */
2  /*
3   * linux/can/dev.h
4   *
5   * Definitions for the CAN network device driver interface
6   *
7   * Copyright (C) 2006 Andrey Volkov <avolkov@varma-el.com>
8   *               Varma Electronics Oy
9   *
10   * Copyright (C) 2008 Wolfgang Grandegger <wg@grandegger.com>
11   *
12   */
13  
14  #ifndef _CAN_DEV_H
15  #define _CAN_DEV_H
16  
17  #include <linux/can.h>
18  #include <linux/can/bittiming.h>
19  #include <linux/can/error.h>
20  #include <linux/can/length.h>
21  #include <linux/can/netlink.h>
22  #include <linux/can/skb.h>
23  #include <linux/ethtool.h>
24  #include <linux/netdevice.h>
25  
26  /*
27   * CAN mode
28   */
29  enum can_mode {
30  	CAN_MODE_STOP = 0,
31  	CAN_MODE_START,
32  	CAN_MODE_SLEEP
33  };
34  
35  enum can_termination_gpio {
36  	CAN_TERMINATION_GPIO_DISABLED = 0,
37  	CAN_TERMINATION_GPIO_ENABLED,
38  	CAN_TERMINATION_GPIO_MAX,
39  };
40  
41  /*
42   * CAN common private data
43   */
44  struct can_priv {
45  	struct net_device *dev;
46  	struct can_device_stats can_stats;
47  
48  	const struct can_bittiming_const *bittiming_const,
49  		*data_bittiming_const;
50  	struct can_bittiming bittiming, data_bittiming;
51  	const struct can_tdc_const *tdc_const;
52  	struct can_tdc tdc;
53  
54  	unsigned int bitrate_const_cnt;
55  	const u32 *bitrate_const;
56  	const u32 *data_bitrate_const;
57  	unsigned int data_bitrate_const_cnt;
58  	u32 bitrate_max;
59  	struct can_clock clock;
60  
61  	unsigned int termination_const_cnt;
62  	const u16 *termination_const;
63  	u16 termination;
64  	struct gpio_desc *termination_gpio;
65  	u16 termination_gpio_ohms[CAN_TERMINATION_GPIO_MAX];
66  
67  	unsigned int echo_skb_max;
68  	struct sk_buff **echo_skb;
69  
70  	enum can_state state;
71  
72  	/* CAN controller features - see include/uapi/linux/can/netlink.h */
73  	u32 ctrlmode;		/* current options setting */
74  	u32 ctrlmode_supported;	/* options that can be modified by netlink */
75  
76  	int restart_ms;
77  	struct delayed_work restart_work;
78  
79  	int (*do_set_bittiming)(struct net_device *dev);
80  	int (*do_set_data_bittiming)(struct net_device *dev);
81  	int (*do_set_mode)(struct net_device *dev, enum can_mode mode);
82  	int (*do_set_termination)(struct net_device *dev, u16 term);
83  	int (*do_get_state)(const struct net_device *dev,
84  			    enum can_state *state);
85  	int (*do_get_berr_counter)(const struct net_device *dev,
86  				   struct can_berr_counter *bec);
87  	int (*do_get_auto_tdcv)(const struct net_device *dev, u32 *tdcv);
88  };
89  
can_tdc_is_enabled(const struct can_priv * priv)90  static inline bool can_tdc_is_enabled(const struct can_priv *priv)
91  {
92  	return !!(priv->ctrlmode & CAN_CTRLMODE_TDC_MASK);
93  }
94  
95  /*
96   * can_get_relative_tdco() - TDCO relative to the sample point
97   *
98   * struct can_tdc::tdco represents the absolute offset from TDCV. Some
99   * controllers use instead an offset relative to the Sample Point (SP)
100   * such that:
101   *
102   * SSP = TDCV + absolute TDCO
103   *     = TDCV + SP + relative TDCO
104   *
105   * -+----------- one bit ----------+-- TX pin
106   *  |<--- Sample Point --->|
107   *
108   *                         --+----------- one bit ----------+-- RX pin
109   *  |<-------- TDCV -------->|
110   *                           |<------------------------>| absolute TDCO
111   *                           |<--- Sample Point --->|
112   *                           |                      |<->| relative TDCO
113   *  |<------------- Secondary Sample Point ------------>|
114   */
can_get_relative_tdco(const struct can_priv * priv)115  static inline s32 can_get_relative_tdco(const struct can_priv *priv)
116  {
117  	const struct can_bittiming *dbt = &priv->data_bittiming;
118  	s32 sample_point_in_tc = (CAN_SYNC_SEG + dbt->prop_seg +
119  				  dbt->phase_seg1) * dbt->brp;
120  
121  	return (s32)priv->tdc.tdco - sample_point_in_tc;
122  }
123  
124  /* helper to define static CAN controller features at device creation time */
can_set_static_ctrlmode(struct net_device * dev,u32 static_mode)125  static inline int __must_check can_set_static_ctrlmode(struct net_device *dev,
126  						       u32 static_mode)
127  {
128  	struct can_priv *priv = netdev_priv(dev);
129  
130  	/* alloc_candev() succeeded => netdev_priv() is valid at this point */
131  	if (priv->ctrlmode_supported & static_mode) {
132  		netdev_warn(dev,
133  			    "Controller features can not be supported and static at the same time\n");
134  		return -EINVAL;
135  	}
136  	priv->ctrlmode = static_mode;
137  
138  	/* override MTU which was set by default in can_setup()? */
139  	if (static_mode & CAN_CTRLMODE_FD)
140  		dev->mtu = CANFD_MTU;
141  
142  	return 0;
143  }
144  
can_get_static_ctrlmode(struct can_priv * priv)145  static inline u32 can_get_static_ctrlmode(struct can_priv *priv)
146  {
147  	return priv->ctrlmode & ~priv->ctrlmode_supported;
148  }
149  
can_is_canxl_dev_mtu(unsigned int mtu)150  static inline bool can_is_canxl_dev_mtu(unsigned int mtu)
151  {
152  	return (mtu >= CANXL_MIN_MTU && mtu <= CANXL_MAX_MTU);
153  }
154  
155  /* drop skb if it does not contain a valid CAN frame for sending */
can_dev_dropped_skb(struct net_device * dev,struct sk_buff * skb)156  static inline bool can_dev_dropped_skb(struct net_device *dev, struct sk_buff *skb)
157  {
158  	struct can_priv *priv = netdev_priv(dev);
159  
160  	if (priv->ctrlmode & CAN_CTRLMODE_LISTENONLY) {
161  		netdev_info_once(dev,
162  				 "interface in listen only mode, dropping skb\n");
163  		kfree_skb(skb);
164  		dev->stats.tx_dropped++;
165  		return true;
166  	}
167  
168  	return can_dropped_invalid_skb(dev, skb);
169  }
170  
171  void can_setup(struct net_device *dev);
172  
173  struct net_device *alloc_candev_mqs(int sizeof_priv, unsigned int echo_skb_max,
174  				    unsigned int txqs, unsigned int rxqs);
175  #define alloc_candev(sizeof_priv, echo_skb_max) \
176  	alloc_candev_mqs(sizeof_priv, echo_skb_max, 1, 1)
177  #define alloc_candev_mq(sizeof_priv, echo_skb_max, count) \
178  	alloc_candev_mqs(sizeof_priv, echo_skb_max, count, count)
179  void free_candev(struct net_device *dev);
180  
181  /* a candev safe wrapper around netdev_priv */
182  struct can_priv *safe_candev_priv(struct net_device *dev);
183  
184  int open_candev(struct net_device *dev);
185  void close_candev(struct net_device *dev);
186  int can_change_mtu(struct net_device *dev, int new_mtu);
187  int can_eth_ioctl_hwts(struct net_device *netdev, struct ifreq *ifr, int cmd);
188  int can_ethtool_op_get_ts_info_hwts(struct net_device *dev,
189  				    struct kernel_ethtool_ts_info *info);
190  
191  int register_candev(struct net_device *dev);
192  void unregister_candev(struct net_device *dev);
193  
194  int can_restart_now(struct net_device *dev);
195  void can_bus_off(struct net_device *dev);
196  
197  const char *can_get_state_str(const enum can_state state);
198  void can_state_get_by_berr_counter(const struct net_device *dev,
199  				   const struct can_berr_counter *bec,
200  				   enum can_state *tx_state,
201  				   enum can_state *rx_state);
202  void can_change_state(struct net_device *dev, struct can_frame *cf,
203  		      enum can_state tx_state, enum can_state rx_state);
204  
205  #ifdef CONFIG_OF
206  void of_can_transceiver(struct net_device *dev);
207  #else
of_can_transceiver(struct net_device * dev)208  static inline void of_can_transceiver(struct net_device *dev) { }
209  #endif
210  
211  extern struct rtnl_link_ops can_link_ops;
212  int can_netlink_register(void);
213  void can_netlink_unregister(void);
214  
215  #endif /* !_CAN_DEV_H */
216