[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / linux / can / dev.h

/*
 * 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/netlink.h>
#include <linux/can/error.h>
#include <linux/can/led.h>

/*
 * CAN mode
 */
enum can_mode {
	CAN_MODE_STOP = 0,
	CAN_MODE_START,
	CAN_MODE_SLEEP
};

/*
 * CAN common private data
 */
struct can_priv {
	struct net_device *dev;
	struct can_device_stats can_stats;

	struct can_bittiming bittiming;
	const struct can_bittiming_const *bittiming_const;
	struct can_clock clock;

	enum can_state state;
	u32 ctrlmode;
	u32 ctrlmode_supported;

	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_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);

	unsigned int echo_skb_max;
	struct sk_buff **echo_skb;

#ifdef CONFIG_CAN_LEDS
	struct led_trigger *tx_led_trig;
	char tx_led_trig_name[CAN_LED_NAME_SZ];
	struct led_trigger *rx_led_trig;
	char rx_led_trig_name[CAN_LED_NAME_SZ];
#endif
};

/*
 * get_can_dlc(value) - helper macro to cast a given data length code (dlc)
 * to __u8 and ensure the dlc value to be max. 8 bytes.
 *
 * To be used in the CAN netdriver receive path to ensure conformance with
 * ISO 11898-1 Chapter 8.4.2.3 (DLC field)
 */
#define get_can_dlc(i)		(min_t(__u8, (i), CAN_MAX_DLC))
#define get_canfd_dlc(i)	(min_t(__u8, (i), CANFD_MAX_DLC))

/* Drop a given socketbuffer if it does not contain a valid CAN frame. */
static inline int can_dropped_invalid_skb(struct net_device *dev,
					  struct sk_buff *skb)
{
	const struct canfd_frame *cfd = (struct canfd_frame *)skb->data;

	if (skb->protocol == htons(ETH_P_CAN)) {
		if (unlikely(skb->len != CAN_MTU ||
			     cfd->len > CAN_MAX_DLEN))
			goto inval_skb;
	} else if (skb->protocol == htons(ETH_P_CANFD)) {
		if (unlikely(skb->len != CANFD_MTU ||
			     cfd->len > CANFD_MAX_DLEN))
			goto inval_skb;
	} else
		goto inval_skb;

	return 0;

inval_skb:
	kfree_skb(skb);
	dev->stats.tx_dropped++;
	return 1;
}

/* get data length from can_dlc with sanitized can_dlc */
u8 can_dlc2len(u8 can_dlc);

/* map the sanitized data length to an appropriate data length code */
u8 can_len2dlc(u8 len);

struct net_device *alloc_candev(int sizeof_priv, unsigned int echo_skb_max);
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);

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);

void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
		      unsigned int idx);
unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx);
void can_free_echo_skb(struct net_device *dev, unsigned int idx);

struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf);
struct sk_buff *alloc_can_err_skb(struct net_device *dev,
				  struct can_frame **cf);

#endif /* CAN_DEV_H */
Commit	Line	Data
39549eef WG	1	/*
	2	* linux/can/dev.h
	3	*
	4	* Definitions for the CAN network device driver interface
	5	*
	6	* Copyright (C) 2006 Andrey Volkov <avolkov@varma-el.com>
	7	* Varma Electronics Oy
	8	*
	9	* Copyright (C) 2008 Wolfgang Grandegger <wg@grandegger.com>
	10	*
39549eef WG	11	*/
	12
	13	#ifndef CAN_DEV_H
	14	#define CAN_DEV_H
	15
829e0015	16	#include <linux/can.h>
39549eef WG	17	#include <linux/can/netlink.h>
39549eef WG	18	#include <linux/can/error.h>
996a953d	19	#include <linux/can/led.h>
39549eef WG	20
	21	/*
	22	* CAN mode
	23	*/
	24	enum can_mode {
	25	CAN_MODE_STOP = 0,
	26	CAN_MODE_START,
	27	CAN_MODE_SLEEP
	28	};
	29
	30	/*
	31	* CAN common private data
	32	*/
39549eef	33	struct can_priv {
ebee2e2f	34	struct net_device *dev;
39549eef WG	35	struct can_device_stats can_stats;
	36
	37	struct can_bittiming bittiming;
194b9a4c	38	const struct can_bittiming_const *bittiming_const;
39549eef WG	39	struct can_clock clock;
	40
	41	enum can_state state;
	42	u32 ctrlmode;
ad72c347	43	u32 ctrlmode_supported;
39549eef WG	44
39549eef WG	45	int restart_ms;
ebee2e2f	46	struct delayed_work restart_work;
39549eef	47
39549eef WG	48	int (do_set_bittiming)(struct net_device dev);
	49	int (do_set_mode)(struct net_device dev, enum can_mode mode);
	50	int (do_get_state)(const struct net_device dev,
	51	enum can_state *state);
52c793f2 WG	52	int (do_get_berr_counter)(const struct net_device dev,
52c793f2 WG	53	struct can_berr_counter *bec);
a6e4bc53 WG	54
	55	unsigned int echo_skb_max;
	56	struct sk_buff **echo_skb;
996a953d FB	57
	58	#ifdef CONFIG_CAN_LEDS
	59	struct led_trigger *tx_led_trig;
	60	char tx_led_trig_name[CAN_LED_NAME_SZ];
	61	struct led_trigger *rx_led_trig;
	62	char rx_led_trig_name[CAN_LED_NAME_SZ];
	63	#endif
39549eef WG	64	};
39549eef WG	65
c7cd606f OH	66	/*
	67	* get_can_dlc(value) - helper macro to cast a given data length code (dlc)
	68	* to __u8 and ensure the dlc value to be max. 8 bytes.
	69	*
	70	* To be used in the CAN netdriver receive path to ensure conformance with
	71	* ISO 11898-1 Chapter 8.4.2.3 (DLC field)
	72	*/
1e0625fa OH	73	#define get_can_dlc(i) (min_t(__u8, (i), CAN_MAX_DLC))
1e0625fa OH	74	#define get_canfd_dlc(i) (min_t(__u8, (i), CANFD_MAX_DLC))
c7cd606f	75
3ccd4c61 OH	76	/* Drop a given socketbuffer if it does not contain a valid CAN frame. */
	77	static inline int can_dropped_invalid_skb(struct net_device *dev,
	78	struct sk_buff *skb)
	79	{
1e0625fa OH	80	const struct canfd_frame cfd = (struct canfd_frame )skb->data;
	81
	82	if (skb->protocol == htons(ETH_P_CAN)) {
	83	if (unlikely(skb->len != CAN_MTU \|\|
	84	cfd->len > CAN_MAX_DLEN))
	85	goto inval_skb;
	86	} else if (skb->protocol == htons(ETH_P_CANFD)) {
	87	if (unlikely(skb->len != CANFD_MTU \|\|
	88	cfd->len > CANFD_MAX_DLEN))
	89	goto inval_skb;
	90	} else
	91	goto inval_skb;
3ccd4c61 OH	92
3ccd4c61 OH	93	return 0;
1e0625fa OH	94
	95	inval_skb:
	96	kfree_skb(skb);
	97	dev->stats.tx_dropped++;
	98	return 1;
3ccd4c61 OH	99	}
3ccd4c61 OH	100
1e0625fa OH	101	/* get data length from can_dlc with sanitized can_dlc */
	102	u8 can_dlc2len(u8 can_dlc);
	103
	104	/* map the sanitized data length to an appropriate data length code */
	105	u8 can_len2dlc(u8 len);
	106
a6e4bc53	107	struct net_device *alloc_candev(int sizeof_priv, unsigned int echo_skb_max);
39549eef WG	108	void free_candev(struct net_device *dev);
39549eef WG	109
bf03a537 KVD	110	/* a candev safe wrapper around netdev_priv */
	111	struct can_priv safe_candev_priv(struct net_device dev);
	112
39549eef WG	113	int open_candev(struct net_device *dev);
	114	void close_candev(struct net_device *dev);
	115
	116	int register_candev(struct net_device *dev);
	117	void unregister_candev(struct net_device *dev);
	118
	119	int can_restart_now(struct net_device *dev);
	120	void can_bus_off(struct net_device *dev);
	121
a6e4bc53 WG	122	void can_put_echo_skb(struct sk_buff skb, struct net_device dev,
a6e4bc53 WG	123	unsigned int idx);
cf5046b3	124	unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx);
a6e4bc53	125	void can_free_echo_skb(struct net_device *dev, unsigned int idx);
39549eef	126
7b6856a0 WG	127	struct sk_buff alloc_can_skb(struct net_device dev, struct can_frame **cf);
	128	struct sk_buff alloc_can_err_skb(struct net_device dev,
	129	struct can_frame **cf);
	130
39549eef	131	#endif /* CAN_DEV_H */