[linux-2.6-block.git] / arch / um / drivers / vector_kern.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 2002 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 */

#ifndef __UM_VECTOR_KERN_H
#define __UM_VECTOR_KERN_H

#include <linux/netdevice.h>
#include <linux/platform_device.h>
#include <linux/skbuff.h>
#include <linux/socket.h>
#include <linux/list.h>
#include <linux/ctype.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>
#include "vector_user.h"

/* Queue structure specially adapted for multiple enqueue/dequeue
 * in a mmsgrecv/mmsgsend context
 */

/* Dequeue method */

#define QUEUE_SENDMSG 0
#define QUEUE_SENDMMSG 1

#define VECTOR_RX 1
#define VECTOR_TX (1 << 1)
#define VECTOR_BPF (1 << 2)
#define VECTOR_QDISC_BYPASS (1 << 3)

#define ETH_MAX_PACKET 1500
#define ETH_HEADER_OTHER 32 /* just in case someone decides to go mad on QnQ */

struct vector_queue {
	struct mmsghdr *mmsg_vector;
	void **skbuff_vector;
	 /* backlink to device which owns us */
	struct net_device *dev;
	spinlock_t head_lock;
	spinlock_t tail_lock;
	int queue_depth, head, tail, max_depth, max_iov_frags;
	short options;
};

struct vector_estats {
	uint64_t rx_queue_max;
	uint64_t rx_queue_running_average;
	uint64_t tx_queue_max;
	uint64_t tx_queue_running_average;
	uint64_t rx_encaps_errors;
	uint64_t tx_timeout_count;
	uint64_t tx_restart_queue;
	uint64_t tx_kicks;
	uint64_t tx_flow_control_xon;
	uint64_t tx_flow_control_xoff;
	uint64_t rx_csum_offload_good;
	uint64_t rx_csum_offload_errors;
	uint64_t sg_ok;
	uint64_t sg_linearized;
};

#define VERIFY_HEADER_NOK -1
#define VERIFY_HEADER_OK 0
#define VERIFY_CSUM_OK 1

struct vector_private {
	struct list_head list;
	spinlock_t lock;
	struct net_device *dev;

	int unit;

	/* Timeout timer in TX */

	struct timer_list tl;

	/* Scheduled "remove device" work */
	struct work_struct reset_tx;
	struct vector_fds *fds;

	struct vector_queue *rx_queue;
	struct vector_queue *tx_queue;

	int rx_irq;
	int tx_irq;

	struct arglist *parsed;

	void *transport_data; /* transport specific params if needed */

	int max_packet;
	int req_size; /* different from max packet - used for TSO */
	int headroom;

	int options;

	/* remote address if any - some transports will leave this as null */

	int header_size;
	int rx_header_size;
	int coalesce;

	void *header_rxbuffer;
	void *header_txbuffer;

	int (*form_header)(uint8_t *header,
		struct sk_buff *skb, struct vector_private *vp);
	int (*verify_header)(uint8_t *header,
		struct sk_buff *skb, struct vector_private *vp);

	spinlock_t stats_lock;

	struct tasklet_struct tx_poll;
	bool rexmit_scheduled;
	bool opened;
	bool in_write_poll;
	bool in_error;

	/* ethtool stats */

	struct vector_estats estats;
	void *bpf;

	char user[0];
};

extern int build_transport_data(struct vector_private *vp);

#endif
Commit	Line	Data
dbddf429	1	/* SPDX-License-Identifier: GPL-2.0 */
49da7e64 AI	2	/*
49da7e64 AI	3	* Copyright (C) 2002 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
49da7e64 AI	4	*/
	5
	6	#ifndef __UM_VECTOR_KERN_H
	7	#define __UM_VECTOR_KERN_H
	8
	9	#include <linux/netdevice.h>
	10	#include <linux/platform_device.h>
	11	#include <linux/skbuff.h>
	12	#include <linux/socket.h>
	13	#include <linux/list.h>
	14	#include <linux/ctype.h>
	15	#include <linux/workqueue.h>
	16	#include <linux/interrupt.h>
	17	#include "vector_user.h"
	18
	19	/* Queue structure specially adapted for multiple enqueue/dequeue
	20	* in a mmsgrecv/mmsgsend context
	21	*/
	22
	23	/* Dequeue method */
	24
	25	#define QUEUE_SENDMSG 0
	26	#define QUEUE_SENDMMSG 1
	27
	28	#define VECTOR_RX 1
	29	#define VECTOR_TX (1 << 1)
	30	#define VECTOR_BPF (1 << 2)
e40238de	31	#define VECTOR_QDISC_BYPASS (1 << 3)
49da7e64 AI	32
	33	#define ETH_MAX_PACKET 1500
	34	#define ETH_HEADER_OTHER 32 /* just in case someone decides to go mad on QnQ */
	35
	36	struct vector_queue {
	37	struct mmsghdr *mmsg_vector;
	38	void **skbuff_vector;
	39	/* backlink to device which owns us */
	40	struct net_device *dev;
	41	spinlock_t head_lock;
	42	spinlock_t tail_lock;
	43	int queue_depth, head, tail, max_depth, max_iov_frags;
	44	short options;
	45	};
	46
	47	struct vector_estats {
	48	uint64_t rx_queue_max;
	49	uint64_t rx_queue_running_average;
	50	uint64_t tx_queue_max;
	51	uint64_t tx_queue_running_average;
	52	uint64_t rx_encaps_errors;
	53	uint64_t tx_timeout_count;
	54	uint64_t tx_restart_queue;
	55	uint64_t tx_kicks;
	56	uint64_t tx_flow_control_xon;
	57	uint64_t tx_flow_control_xoff;
	58	uint64_t rx_csum_offload_good;
	59	uint64_t rx_csum_offload_errors;
	60	uint64_t sg_ok;
	61	uint64_t sg_linearized;
	62	};
	63
	64	#define VERIFY_HEADER_NOK -1
	65	#define VERIFY_HEADER_OK 0
	66	#define VERIFY_CSUM_OK 1
	67
	68	struct vector_private {
	69	struct list_head list;
	70	spinlock_t lock;
	71	struct net_device *dev;
	72
	73	int unit;
	74
	75	/* Timeout timer in TX */
	76
	77	struct timer_list tl;
	78
	79	/* Scheduled "remove device" work */
	80	struct work_struct reset_tx;
	81	struct vector_fds *fds;
	82
	83	struct vector_queue *rx_queue;
	84	struct vector_queue *tx_queue;
	85
	86	int rx_irq;
	87	int tx_irq;
	88
	89	struct arglist *parsed;
	90
	91	void transport_data; / transport specific params if needed */
	92
	93	int max_packet;
	94	int req_size; /* different from max packet - used for TSO */
	95	int headroom;
96
97	int options;
98
99	/* remote address if any - some transports will leave this as null */
100
101	int header_size;
102	int rx_header_size;
103	int coalesce;
104
105	void *header_rxbuffer;
106	void *header_txbuffer;
107
108	int (form_header)(uint8_t header,
109	struct sk_buff skb, struct vector_private vp);
110	int (verify_header)(uint8_t header,
111	struct sk_buff skb, struct vector_private vp);
112
113	spinlock_t stats_lock;
114
115	struct tasklet_struct tx_poll;
116	bool rexmit_scheduled;
117	bool opened;
118	bool in_write_poll;
d47761db	119	bool in_error;
49da7e64 AI	120
	121	/* ethtool stats */
	122
	123	struct vector_estats estats;
	124	void *bpf;
	125
	126	char user[0];
	127	};
	128
	129	extern int build_transport_data(struct vector_private *vp);
	130
	131	#endif