[mirror_ubuntu-bionic-kernel.git] / drivers / net / fjes / fjes_hw.h

/*
 *  FUJITSU Extended Socket Network Device driver
 *  Copyright (c) 2015 FUJITSU LIMITED
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * The full GNU General Public License is included in this distribution in
 * the file called "COPYING".
 *
 */

#ifndef FJES_HW_H_
#define FJES_HW_H_

#include <linux/netdevice.h>
#include <linux/if_vlan.h>
#include <linux/vmalloc.h>

#include "fjes_regs.h"

struct fjes_hw;

#define EP_BUFFER_SUPPORT_VLAN_MAX 4
#define EP_BUFFER_INFO_SIZE 4096

#define FJES_DEVICE_RESET_TIMEOUT  ((17 + 1) * 3 * 8) /* sec */
#define FJES_COMMAND_REQ_TIMEOUT  ((5 + 1) * 3 * 8) /* sec */
#define FJES_COMMAND_REQ_BUFF_TIMEOUT	(60 * 3) /* sec */
#define FJES_COMMAND_EPSTOP_WAIT_TIMEOUT	(1) /* sec */

#define FJES_CMD_REQ_ERR_INFO_PARAM  (0x0001)
#define FJES_CMD_REQ_ERR_INFO_STATUS (0x0002)

#define FJES_CMD_REQ_RES_CODE_NORMAL (0)
#define FJES_CMD_REQ_RES_CODE_BUSY   (1)

#define FJES_ZONING_STATUS_DISABLE	(0x00)
#define FJES_ZONING_STATUS_ENABLE	(0x01)
#define FJES_ZONING_STATUS_INVALID	(0xFF)

#define FJES_ZONING_ZONE_TYPE_NONE (0xFF)

#define FJES_TX_DELAY_SEND_NONE		(0)
#define FJES_TX_DELAY_SEND_PENDING	(1)

#define FJES_RX_STOP_REQ_NONE		(0x0)
#define FJES_RX_STOP_REQ_DONE		(0x1)
#define FJES_RX_STOP_REQ_REQUEST	(0x2)
#define FJES_RX_POLL_WORK		(0x4)
#define FJES_RX_MTU_CHANGING_DONE	(0x8)

#define EP_BUFFER_SIZE \
	(((sizeof(union ep_buffer_info) + (128 * (64 * 1024))) \
		/ EP_BUFFER_INFO_SIZE) * EP_BUFFER_INFO_SIZE)

#define EP_RING_NUM(buffer_size, frame_size) \
		(u32)((buffer_size) / (frame_size))
#define EP_RING_INDEX(_num, _max) (((_num) + (_max)) % (_max))
#define EP_RING_INDEX_INC(_num, _max) \
	((_num) = EP_RING_INDEX((_num) + 1, (_max)))
#define EP_RING_FULL(_head, _tail, _max)				\
	(0 == EP_RING_INDEX(((_tail) - (_head)), (_max)))
#define EP_RING_EMPTY(_head, _tail, _max) \
	(1 == EP_RING_INDEX(((_tail) - (_head)), (_max)))

#define FJES_MTU_TO_BUFFER_SIZE(mtu) \
	(ETH_HLEN + VLAN_HLEN + (mtu) + ETH_FCS_LEN)
#define FJES_MTU_TO_FRAME_SIZE(mtu) \
	(sizeof(struct esmem_frame) + FJES_MTU_TO_BUFFER_SIZE(mtu))
#define FJES_MTU_DEFINE(size) \
	((size) - sizeof(struct esmem_frame) - \
	(ETH_HLEN + VLAN_HLEN + ETH_FCS_LEN))

#define FJES_DEV_COMMAND_INFO_REQ_LEN	(4)
#define FJES_DEV_COMMAND_INFO_RES_LEN(epnum) (8 + 2 * (epnum))
#define FJES_DEV_COMMAND_SHARE_BUFFER_REQ_LEN(txb, rxb) \
	(24 + (8 * ((txb) / EP_BUFFER_INFO_SIZE + (rxb) / EP_BUFFER_INFO_SIZE)))
#define FJES_DEV_COMMAND_SHARE_BUFFER_RES_LEN	(8)
#define FJES_DEV_COMMAND_UNSHARE_BUFFER_REQ_LEN	(8)
#define FJES_DEV_COMMAND_UNSHARE_BUFFER_RES_LEN	(8)

#define FJES_DEV_REQ_BUF_SIZE(maxep) \
	FJES_DEV_COMMAND_SHARE_BUFFER_REQ_LEN(EP_BUFFER_SIZE, EP_BUFFER_SIZE)
#define FJES_DEV_RES_BUF_SIZE(maxep) \
	FJES_DEV_COMMAND_INFO_RES_LEN(maxep)

/* Frame & MTU */
struct esmem_frame {
	__le32 frame_size;
	u8 frame_data[];
};

/* EP partner status */
enum ep_partner_status {
	EP_PARTNER_UNSHARE,
	EP_PARTNER_SHARED,
	EP_PARTNER_WAITING,
	EP_PARTNER_COMPLETE,
	EP_PARTNER_STATUS_MAX,
};

/* shared status region */
struct fjes_device_shared_info {
	int epnum;
	u8 ep_status[];
};

/* structures for command control request data*/
union fjes_device_command_req {
	struct {
		__le32 length;
	} info;
	struct {
		__le32 length;
		__le32 epid;
		__le64 buffer[];
	} share_buffer;
	struct {
		__le32 length;
		__le32 epid;
	} unshare_buffer;
	struct {
		__le32 length;
		__le32 mode;
		__le64 buffer_len;
		__le64 buffer[];
	} start_trace;
	struct {
		__le32 length;
	} stop_trace;
};

/* structures for command control response data */
union fjes_device_command_res {
	struct {
		__le32 length;
		__le32 code;
		struct {
			u8 es_status;
			u8 zone;
		} info[];
	} info;
	struct {
		__le32 length;
		__le32 code;
	} share_buffer;
	struct {
		__le32 length;
		__le32 code;
	} unshare_buffer;
	struct {
		__le32 length;
		__le32 code;
	} start_trace;
	struct {
		__le32 length;
		__le32 code;
	} stop_trace;
};

/* request command type */
enum fjes_dev_command_request_type {
	FJES_CMD_REQ_INFO		= 0x0001,
	FJES_CMD_REQ_SHARE_BUFFER	= 0x0002,
	FJES_CMD_REQ_UNSHARE_BUFFER	= 0x0004,
};

/* parameter for command control */
struct fjes_device_command_param {
	u32 req_len;
	phys_addr_t req_start;
	u32 res_len;
	phys_addr_t res_start;
	phys_addr_t share_start;
};

/* error code for command control */
enum fjes_dev_command_response_e {
	FJES_CMD_STATUS_UNKNOWN,
	FJES_CMD_STATUS_NORMAL,
	FJES_CMD_STATUS_TIMEOUT,
	FJES_CMD_STATUS_ERROR_PARAM,
	FJES_CMD_STATUS_ERROR_STATUS,
};

/* EP buffer information */
union ep_buffer_info {
	u8 raw[EP_BUFFER_INFO_SIZE];

	struct _ep_buffer_info_common_t {
		u32 version;
	} common;

	struct _ep_buffer_info_v1_t {
		u32 version;
		u32 info_size;

		u32 buffer_size;
		u16 count_max;

		u16 _rsv_1;

		u32 frame_max;
		u8 mac_addr[ETH_ALEN];

		u16 _rsv_2;
		u32 _rsv_3;

		u16 tx_status;
		u16 rx_status;

		u32 head;
		u32 tail;

		u16 vlan_id[EP_BUFFER_SUPPORT_VLAN_MAX];

	} v1i;

};

/* statistics of EP */
struct fjes_drv_ep_stats {
	u64 com_regist_buf_exec;
	u64 com_unregist_buf_exec;
	u64 send_intr_rx;
	u64 send_intr_unshare;
	u64 send_intr_zoneupdate;
	u64 recv_intr_rx;
	u64 recv_intr_unshare;
	u64 recv_intr_stop;
	u64 recv_intr_zoneupdate;
	u64 tx_buffer_full;
	u64 tx_dropped_not_shared;
	u64 tx_dropped_ver_mismatch;
	u64 tx_dropped_buf_size_mismatch;
	u64 tx_dropped_vlanid_mismatch;
};

/* buffer pair for Extended Partition */
struct ep_share_mem_info {
	struct epbuf_handler {
		void *buffer;
		size_t size;
		union ep_buffer_info *info;
		u8 *ring;
	} tx, rx;

	struct rtnl_link_stats64 net_stats;
	struct fjes_drv_ep_stats ep_stats;

	u16 tx_status_work;

	u8 es_status;
	u8 zone;
};

struct es_device_trace {
	u32 record_num;
	u32 current_record;
	u32 status_flag;
	u32 _rsv;

	struct {
			u16 epid;
			u16 dir_offset;
			u32 data;
			u64 tsc;
	} record[];
};

struct fjes_hw_info {
	struct fjes_device_shared_info *share;
	union fjes_device_command_req *req_buf;
	u64 req_buf_size;
	union fjes_device_command_res *res_buf;
	u64 res_buf_size;

	int *my_epid;
	int *max_epid;

	struct es_device_trace *trace;
	u64 trace_size;

	struct mutex lock; /* buffer lock*/

	unsigned long buffer_share_bit;
	unsigned long buffer_unshare_reserve_bit;
};

struct fjes_hw {
	void *back;

	unsigned long txrx_stop_req_bit;
	unsigned long epstop_req_bit;
	struct work_struct update_zone_task;
	struct work_struct epstop_task;

	int my_epid;
	int max_epid;

	struct ep_share_mem_info *ep_shm_info;

	struct fjes_hw_resource {
		u64 start;
		u64 size;
		int irq;
	} hw_res;

	u8 *base;

	struct fjes_hw_info hw_info;

	spinlock_t rx_status_lock; /* spinlock for rx_status */
};

int fjes_hw_init(struct fjes_hw *);
void fjes_hw_exit(struct fjes_hw *);
int fjes_hw_reset(struct fjes_hw *);
int fjes_hw_request_info(struct fjes_hw *);
int fjes_hw_register_buff_addr(struct fjes_hw *, int,
			       struct ep_share_mem_info *);
int fjes_hw_unregister_buff_addr(struct fjes_hw *, int);
void fjes_hw_init_command_registers(struct fjes_hw *,
				    struct fjes_device_command_param *);
void fjes_hw_setup_epbuf(struct epbuf_handler *, u8 *, u32);
int fjes_hw_raise_interrupt(struct fjes_hw *, int, enum REG_ICTL_MASK);
void fjes_hw_set_irqmask(struct fjes_hw *, enum REG_ICTL_MASK, bool);
u32 fjes_hw_capture_interrupt_status(struct fjes_hw *);
void fjes_hw_raise_epstop(struct fjes_hw *);
int fjes_hw_wait_epstop(struct fjes_hw *);
enum ep_partner_status
	fjes_hw_get_partner_ep_status(struct fjes_hw *, int);

bool fjes_hw_epid_is_same_zone(struct fjes_hw *, int);
int fjes_hw_epid_is_shared(struct fjes_device_shared_info *, int);
bool fjes_hw_check_epbuf_version(struct epbuf_handler *, u32);
bool fjes_hw_check_mtu(struct epbuf_handler *, u32);
bool fjes_hw_check_vlan_id(struct epbuf_handler *, u16);
bool fjes_hw_set_vlan_id(struct epbuf_handler *, u16);
void fjes_hw_del_vlan_id(struct epbuf_handler *, u16);
bool fjes_hw_epbuf_rx_is_empty(struct epbuf_handler *);
void *fjes_hw_epbuf_rx_curpkt_get_addr(struct epbuf_handler *, size_t *);
void fjes_hw_epbuf_rx_curpkt_drop(struct epbuf_handler *);
int fjes_hw_epbuf_tx_pkt_send(struct epbuf_handler *, void *, size_t);

#endif /* FJES_HW_H_ */
Commit	Line	Data
8cdc3f6c TI	1	/*
	2	* FUJITSU Extended Socket Network Device driver
	3	* Copyright (c) 2015 FUJITSU LIMITED
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms and conditions of the GNU General Public License,
	7	* version 2, as published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along with
	15	* this program; if not, see <http://www.gnu.org/licenses/>.
	16	*
	17	* The full GNU General Public License is included in this distribution in
	18	* the file called "COPYING".
	19	*
	20	*/
	21
	22	#ifndef FJES_HW_H_
	23	#define FJES_HW_H_
	24
	25	#include <linux/netdevice.h>
	26	#include <linux/if_vlan.h>
	27	#include <linux/vmalloc.h>
	28
	29	#include "fjes_regs.h"
	30
	31	struct fjes_hw;
	32
	33	#define EP_BUFFER_SUPPORT_VLAN_MAX 4
	34	#define EP_BUFFER_INFO_SIZE 4096
	35
da5a2383 TI	36	#define FJES_DEVICE_RESET_TIMEOUT ((17 + 1) * 3 * 8) /* sec */
	37	#define FJES_COMMAND_REQ_TIMEOUT ((5 + 1) * 3 * 8) /* sec */
	38	#define FJES_COMMAND_REQ_BUFF_TIMEOUT (60 * 3) /* sec */
e5d486dc	39	#define FJES_COMMAND_EPSTOP_WAIT_TIMEOUT (1) /* sec */
3bb025d4 TI	40
	41	#define FJES_CMD_REQ_ERR_INFO_PARAM (0x0001)
	42	#define FJES_CMD_REQ_ERR_INFO_STATUS (0x0002)
	43
	44	#define FJES_CMD_REQ_RES_CODE_NORMAL (0)
7950e6c5	45	#define FJES_CMD_REQ_RES_CODE_BUSY (1)
8cdc3f6c	46
e5d486dc TI	47	#define FJES_ZONING_STATUS_DISABLE (0x00)
	48	#define FJES_ZONING_STATUS_ENABLE (0x01)
	49	#define FJES_ZONING_STATUS_INVALID (0xFF)
	50
	51	#define FJES_ZONING_ZONE_TYPE_NONE (0xFF)
	52
9acf51cb TI	53	#define FJES_TX_DELAY_SEND_NONE (0)
	54	#define FJES_TX_DELAY_SEND_PENDING (1)
	55
e5d486dc TI	56	#define FJES_RX_STOP_REQ_NONE (0x0)
	57	#define FJES_RX_STOP_REQ_DONE (0x1)
	58	#define FJES_RX_STOP_REQ_REQUEST (0x2)
	59	#define FJES_RX_POLL_WORK (0x4)
16bbec3a	60	#define FJES_RX_MTU_CHANGING_DONE (0x8)
e5d486dc	61
8cdc3f6c TI	62	#define EP_BUFFER_SIZE \
	63	(((sizeof(union ep_buffer_info) + (128 * (64 * 1024))) \
	64	/ EP_BUFFER_INFO_SIZE) * EP_BUFFER_INFO_SIZE)
	65
	66	#define EP_RING_NUM(buffer_size, frame_size) \
	67	(u32)((buffer_size) / (frame_size))
9acf51cb TI	68	#define EP_RING_INDEX(_num, _max) (((_num) + (_max)) % (_max))
	69	#define EP_RING_INDEX_INC(_num, _max) \
	70	((_num) = EP_RING_INDEX((_num) + 1, (_max)))
	71	#define EP_RING_FULL(_head, _tail, _max) \
	72	(0 == EP_RING_INDEX(((_tail) - (_head)), (_max)))
26585930 TI	73	#define EP_RING_EMPTY(_head, _tail, _max) \
26585930 TI	74	(1 == EP_RING_INDEX(((_tail) - (_head)), (_max)))
8cdc3f6c TI	75
	76	#define FJES_MTU_TO_BUFFER_SIZE(mtu) \
	77	(ETH_HLEN + VLAN_HLEN + (mtu) + ETH_FCS_LEN)
	78	#define FJES_MTU_TO_FRAME_SIZE(mtu) \
	79	(sizeof(struct esmem_frame) + FJES_MTU_TO_BUFFER_SIZE(mtu))
	80	#define FJES_MTU_DEFINE(size) \
	81	((size) - sizeof(struct esmem_frame) - \
	82	(ETH_HLEN + VLAN_HLEN + ETH_FCS_LEN))
	83
3bb025d4	84	#define FJES_DEV_COMMAND_INFO_REQ_LEN (4)
8cdc3f6c TI	85	#define FJES_DEV_COMMAND_INFO_RES_LEN(epnum) (8 + 2 * (epnum))
	86	#define FJES_DEV_COMMAND_SHARE_BUFFER_REQ_LEN(txb, rxb) \
	87	(24 + (8 * ((txb) / EP_BUFFER_INFO_SIZE + (rxb) / EP_BUFFER_INFO_SIZE)))
7950e6c5 TI	88	#define FJES_DEV_COMMAND_SHARE_BUFFER_RES_LEN (8)
	89	#define FJES_DEV_COMMAND_UNSHARE_BUFFER_REQ_LEN (8)
	90	#define FJES_DEV_COMMAND_UNSHARE_BUFFER_RES_LEN (8)
8cdc3f6c TI	91
	92	#define FJES_DEV_REQ_BUF_SIZE(maxep) \
	93	FJES_DEV_COMMAND_SHARE_BUFFER_REQ_LEN(EP_BUFFER_SIZE, EP_BUFFER_SIZE)
	94	#define FJES_DEV_RES_BUF_SIZE(maxep) \
	95	FJES_DEV_COMMAND_INFO_RES_LEN(maxep)
	96
	97	/* Frame & MTU */
	98	struct esmem_frame {
	99	__le32 frame_size;
	100	u8 frame_data[];
	101	};
	102
e5d486dc TI	103	/* EP partner status */
	104	enum ep_partner_status {
	105	EP_PARTNER_UNSHARE,
	106	EP_PARTNER_SHARED,
	107	EP_PARTNER_WAITING,
	108	EP_PARTNER_COMPLETE,
	109	EP_PARTNER_STATUS_MAX,
	110	};
	111
8cdc3f6c TI	112	/* shared status region */
	113	struct fjes_device_shared_info {
	114	int epnum;
	115	u8 ep_status[];
	116	};
	117
	118	/* structures for command control request data*/
	119	union fjes_device_command_req {
	120	struct {
	121	__le32 length;
	122	} info;
	123	struct {
	124	__le32 length;
	125	__le32 epid;
	126	__le64 buffer[];
	127	} share_buffer;
	128	struct {
	129	__le32 length;
	130	__le32 epid;
	131	} unshare_buffer;
	132	struct {
	133	__le32 length;
	134	__le32 mode;
	135	__le64 buffer_len;
	136	__le64 buffer[];
	137	} start_trace;
	138	struct {
	139	__le32 length;
	140	} stop_trace;
	141	};
	142
	143	/* structures for command control response data */
	144	union fjes_device_command_res {
	145	struct {
	146	__le32 length;
	147	__le32 code;
	148	struct {
	149	u8 es_status;
	150	u8 zone;
	151	} info[];
	152	} info;
	153	struct {
	154	__le32 length;
	155	__le32 code;
	156	} share_buffer;
	157	struct {
	158	__le32 length;
	159	__le32 code;
	160	} unshare_buffer;
	161	struct {
	162	__le32 length;
	163	__le32 code;
	164	} start_trace;
	165	struct {
	166	__le32 length;
	167	__le32 code;
	168	} stop_trace;
	169	};
	170
3bb025d4 TI	171	/* request command type */
	172	enum fjes_dev_command_request_type {
	173	FJES_CMD_REQ_INFO = 0x0001,
	174	FJES_CMD_REQ_SHARE_BUFFER = 0x0002,
	175	FJES_CMD_REQ_UNSHARE_BUFFER = 0x0004,
	176	};
	177
8cdc3f6c TI	178	/* parameter for command control */
	179	struct fjes_device_command_param {
	180	u32 req_len;
	181	phys_addr_t req_start;
	182	u32 res_len;
	183	phys_addr_t res_start;
	184	phys_addr_t share_start;
	185	};
	186
3bb025d4 TI	187	/* error code for command control */
	188	enum fjes_dev_command_response_e {
	189	FJES_CMD_STATUS_UNKNOWN,
	190	FJES_CMD_STATUS_NORMAL,
	191	FJES_CMD_STATUS_TIMEOUT,
	192	FJES_CMD_STATUS_ERROR_PARAM,
	193	FJES_CMD_STATUS_ERROR_STATUS,
	194	};
	195
8cdc3f6c TI	196	/* EP buffer information */
	197	union ep_buffer_info {
	198	u8 raw[EP_BUFFER_INFO_SIZE];
	199
	200	struct _ep_buffer_info_common_t {
	201	u32 version;
	202	} common;
	203
	204	struct _ep_buffer_info_v1_t {
	205	u32 version;
	206	u32 info_size;
	207
	208	u32 buffer_size;
	209	u16 count_max;
	210
	211	u16 _rsv_1;
	212
	213	u32 frame_max;
	214	u8 mac_addr[ETH_ALEN];
	215
	216	u16 _rsv_2;
	217	u32 _rsv_3;
	218
	219	u16 tx_status;
	220	u16 rx_status;
	221
	222	u32 head;
	223	u32 tail;
	224
	225	u16 vlan_id[EP_BUFFER_SUPPORT_VLAN_MAX];
	226
	227	} v1i;
	228
	229	};
	230
21b7efbc TI	231	/* statistics of EP */
	232	struct fjes_drv_ep_stats {
	233	u64 com_regist_buf_exec;
	234	u64 com_unregist_buf_exec;
	235	u64 send_intr_rx;
	236	u64 send_intr_unshare;
	237	u64 send_intr_zoneupdate;
	238	u64 recv_intr_rx;
	239	u64 recv_intr_unshare;
	240	u64 recv_intr_stop;
	241	u64 recv_intr_zoneupdate;
	242	u64 tx_buffer_full;
	243	u64 tx_dropped_not_shared;
	244	u64 tx_dropped_ver_mismatch;
	245	u64 tx_dropped_buf_size_mismatch;
	246	u64 tx_dropped_vlanid_mismatch;
	247	};
	248
8cdc3f6c TI	249	/* buffer pair for Extended Partition */
	250	struct ep_share_mem_info {
	251	struct epbuf_handler {
	252	void *buffer;
	253	size_t size;
	254	union ep_buffer_info *info;
	255	u8 *ring;
	256	} tx, rx;
	257
	258	struct rtnl_link_stats64 net_stats;
21b7efbc	259	struct fjes_drv_ep_stats ep_stats;
8cdc3f6c TI	260
	261	u16 tx_status_work;
	262
	263	u8 es_status;
	264	u8 zone;
	265	};
	266
	267	struct es_device_trace {
	268	u32 record_num;
	269	u32 current_record;
	270	u32 status_flag;
	271	u32 _rsv;
	272
	273	struct {
	274	u16 epid;
	275	u16 dir_offset;
	276	u32 data;
	277	u64 tsc;
	278	} record[];
	279	};
	280
	281	struct fjes_hw_info {
	282	struct fjes_device_shared_info *share;
	283	union fjes_device_command_req *req_buf;
	284	u64 req_buf_size;
	285	union fjes_device_command_res *res_buf;
	286	u64 res_buf_size;
	287
	288	int *my_epid;
	289	int *max_epid;
	290
	291	struct es_device_trace *trace;
	292	u64 trace_size;
	293
	294	struct mutex lock; /* buffer lock*/
	295
	296	unsigned long buffer_share_bit;
	297	unsigned long buffer_unshare_reserve_bit;
	298	};
	299
	300	struct fjes_hw {
	301	void *back;
	302
	303	unsigned long txrx_stop_req_bit;
	304	unsigned long epstop_req_bit;
785f28e0	305	struct work_struct update_zone_task;
b5a9152d	306	struct work_struct epstop_task;
8cdc3f6c TI	307
	308	int my_epid;
	309	int max_epid;
	310
	311	struct ep_share_mem_info *ep_shm_info;
	312
	313	struct fjes_hw_resource {
	314	u64 start;
	315	u64 size;
	316	int irq;
	317	} hw_res;
	318
	319	u8 *base;
	320
	321	struct fjes_hw_info hw_info;
bd5a2569 TI	322
bd5a2569 TI	323	spinlock_t rx_status_lock; /* spinlock for rx_status */
8cdc3f6c TI	324	};
	325
	326	int fjes_hw_init(struct fjes_hw *);
a18aaec2	327	void fjes_hw_exit(struct fjes_hw *);
8cdc3f6c	328	int fjes_hw_reset(struct fjes_hw *);
3bb025d4	329	int fjes_hw_request_info(struct fjes_hw *);
7950e6c5 TI	330	int fjes_hw_register_buff_addr(struct fjes_hw *, int,
	331	struct ep_share_mem_info *);
	332	int fjes_hw_unregister_buff_addr(struct fjes_hw *, int);
8cdc3f6c TI	333	void fjes_hw_init_command_registers(struct fjes_hw *,
	334	struct fjes_device_command_param *);
	335	void fjes_hw_setup_epbuf(struct epbuf_handler , u8 , u32);
e5d486dc	336	int fjes_hw_raise_interrupt(struct fjes_hw *, int, enum REG_ICTL_MASK);
8cdc3f6c	337	void fjes_hw_set_irqmask(struct fjes_hw *, enum REG_ICTL_MASK, bool);
e5d486dc TI	338	u32 fjes_hw_capture_interrupt_status(struct fjes_hw *);
	339	void fjes_hw_raise_epstop(struct fjes_hw *);
	340	int fjes_hw_wait_epstop(struct fjes_hw *);
	341	enum ep_partner_status
	342	fjes_hw_get_partner_ep_status(struct fjes_hw *, int);
	343
	344	bool fjes_hw_epid_is_same_zone(struct fjes_hw *, int);
	345	int fjes_hw_epid_is_shared(struct fjes_device_shared_info *, int);
9acf51cb TI	346	bool fjes_hw_check_epbuf_version(struct epbuf_handler *, u32);
	347	bool fjes_hw_check_mtu(struct epbuf_handler *, u32);
	348	bool fjes_hw_check_vlan_id(struct epbuf_handler *, u16);
3e3fedda TI	349	bool fjes_hw_set_vlan_id(struct epbuf_handler *, u16);
3e3fedda TI	350	void fjes_hw_del_vlan_id(struct epbuf_handler *, u16);
26585930 TI	351	bool fjes_hw_epbuf_rx_is_empty(struct epbuf_handler *);
	352	void fjes_hw_epbuf_rx_curpkt_get_addr(struct epbuf_handler , size_t *);
	353	void fjes_hw_epbuf_rx_curpkt_drop(struct epbuf_handler *);
9acf51cb	354	int fjes_hw_epbuf_tx_pkt_send(struct epbuf_handler , void , size_t);
8cdc3f6c TI	355
8cdc3f6c TI	356	#endif /* FJES_HW_H_ */