[linux-2.6-block.git] / drivers / net / ethernet / ti / netcp.h

/*
 * NetCP driver local header
 *
 * Copyright (C) 2014 Texas Instruments Incorporated
 * Authors:	Sandeep Nair <sandeep_n@ti.com>
 *		Sandeep Paulraj <s-paulraj@ti.com>
 *		Cyril Chemparathy <cyril@ti.com>
 *		Santosh Shilimkar <santosh.shilimkar@ti.com>
 *		Wingman Kwok <w-kwok2@ti.com>
 *		Murali Karicheri <m-karicheri2@ti.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation version 2.
 *
 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
 * kind, whether express or implied; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */
#ifndef __NETCP_H__
#define __NETCP_H__

#include <linux/netdevice.h>
#include <linux/soc/ti/knav_dma.h>

/* Maximum Ethernet frame size supported by Keystone switch */
#define NETCP_MAX_FRAME_SIZE		9504

#define SGMII_LINK_MAC_MAC_AUTONEG	0
#define SGMII_LINK_MAC_PHY		1
#define SGMII_LINK_MAC_MAC_FORCED	2
#define SGMII_LINK_MAC_FIBER		3
#define SGMII_LINK_MAC_PHY_NO_MDIO	4
#define XGMII_LINK_MAC_PHY		10
#define XGMII_LINK_MAC_MAC_FORCED	11

struct netcp_device;

struct netcp_tx_pipe {
	struct netcp_device	*netcp_device;
	void			*dma_queue;
	unsigned int		dma_queue_id;
	/* To port for packet forwarded to switch. Used only by ethss */
	u8			switch_to_port;
#define	SWITCH_TO_PORT_IN_TAGINFO	BIT(0)
	u8			flags;
	void			*dma_channel;
	const char		*dma_chan_name;
};

#define ADDR_NEW			BIT(0)
#define ADDR_VALID			BIT(1)

enum netcp_addr_type {
	ADDR_ANY,
	ADDR_DEV,
	ADDR_UCAST,
	ADDR_MCAST,
	ADDR_BCAST
};

struct netcp_addr {
	struct netcp_intf	*netcp;
	unsigned char		addr[ETH_ALEN];
	enum netcp_addr_type	type;
	unsigned int		flags;
	struct list_head	node;
};

struct netcp_intf {
	struct device		*dev;
	struct device		*ndev_dev;
	struct net_device	*ndev;
	bool			big_endian;
	unsigned int		tx_compl_qid;
	void			*tx_pool;
	struct list_head	txhook_list_head;
	unsigned int		tx_pause_threshold;
	void			*tx_compl_q;

	unsigned int		tx_resume_threshold;
	void			*rx_queue;
	void			*rx_pool;
	struct list_head	rxhook_list_head;
	unsigned int		rx_queue_id;
	void			*rx_fdq[KNAV_DMA_FDQ_PER_CHAN];
	struct napi_struct	rx_napi;
	struct napi_struct	tx_napi;

	void			*rx_channel;
	const char		*dma_chan_name;
	u32			rx_pool_size;
	u32			rx_pool_region_id;
	u32			tx_pool_size;
	u32			tx_pool_region_id;
	struct list_head	module_head;
	struct list_head	interface_list;
	struct list_head	addr_list;
	bool			netdev_registered;
	bool			primary_module_attached;

	/* Lock used for protecting Rx/Tx hook list management */
	spinlock_t		lock;
	struct netcp_device	*netcp_device;
	struct device_node	*node_interface;

	/* DMA configuration data */
	u32			msg_enable;
	u32			rx_queue_depths[KNAV_DMA_FDQ_PER_CHAN];
};

#define	NETCP_PSDATA_LEN		KNAV_DMA_NUM_PS_WORDS
struct netcp_packet {
	struct sk_buff		*skb;
	u32			*epib;
	u32			*psdata;
	unsigned int		psdata_len;
	struct netcp_intf	*netcp;
	struct netcp_tx_pipe	*tx_pipe;
	bool			rxtstamp_complete;
	void			*ts_context;

	int	(*txtstamp_complete)(void *ctx, struct netcp_packet *pkt);
};

static inline u32 *netcp_push_psdata(struct netcp_packet *p_info,
				     unsigned int bytes)
{
	u32 *buf;
	unsigned int words;

	if ((bytes & 0x03) != 0)
		return NULL;
	words = bytes >> 2;

	if ((p_info->psdata_len + words) > NETCP_PSDATA_LEN)
		return NULL;

	p_info->psdata_len += words;
	buf = &p_info->psdata[NETCP_PSDATA_LEN - p_info->psdata_len];
	return buf;
}

static inline int netcp_align_psdata(struct netcp_packet *p_info,
				     unsigned int byte_align)
{
	int padding;

	switch (byte_align) {
	case 0:
		padding = -EINVAL;
		break;
	case 1:
	case 2:
	case 4:
		padding = 0;
		break;
	case 8:
		padding = (p_info->psdata_len << 2) % 8;
		break;
	case 16:
		padding = (p_info->psdata_len << 2) % 16;
		break;
	default:
		padding = (p_info->psdata_len << 2) % byte_align;
		break;
	}
	return padding;
}

struct netcp_module {
	const char		*name;
	struct module		*owner;
	bool			primary;

	/* probe/remove: called once per NETCP instance */
	int	(*probe)(struct netcp_device *netcp_device,
			 struct device *device, struct device_node *node,
			 void **inst_priv);
	int	(*remove)(struct netcp_device *netcp_device, void *inst_priv);

	/* attach/release: called once per network interface */
	int	(*attach)(void *inst_priv, struct net_device *ndev,
			  struct device_node *node, void **intf_priv);
	int	(*release)(void *intf_priv);
	int	(*open)(void *intf_priv, struct net_device *ndev);
	int	(*close)(void *intf_priv, struct net_device *ndev);
	int	(*add_addr)(void *intf_priv, struct netcp_addr *naddr);
	int	(*del_addr)(void *intf_priv, struct netcp_addr *naddr);
	int	(*add_vid)(void *intf_priv, int vid);
	int	(*del_vid)(void *intf_priv, int vid);
	int	(*ioctl)(void *intf_priv, struct ifreq *req, int cmd);

	/* used internally */
	struct list_head	module_list;
	struct list_head	interface_list;
};

int netcp_register_module(struct netcp_module *module);
void netcp_unregister_module(struct netcp_module *module);
void *netcp_module_get_intf_data(struct netcp_module *module,
				 struct netcp_intf *intf);

int netcp_txpipe_init(struct netcp_tx_pipe *tx_pipe,
		      struct netcp_device *netcp_device,
		      const char *dma_chan_name, unsigned int dma_queue_id);
int netcp_txpipe_open(struct netcp_tx_pipe *tx_pipe);
int netcp_txpipe_close(struct netcp_tx_pipe *tx_pipe);

typedef int netcp_hook_rtn(int order, void *data, struct netcp_packet *packet);
int netcp_register_txhook(struct netcp_intf *netcp_priv, int order,
			  netcp_hook_rtn *hook_rtn, void *hook_data);
int netcp_unregister_txhook(struct netcp_intf *netcp_priv, int order,
			    netcp_hook_rtn *hook_rtn, void *hook_data);
int netcp_register_rxhook(struct netcp_intf *netcp_priv, int order,
			  netcp_hook_rtn *hook_rtn, void *hook_data);
int netcp_unregister_rxhook(struct netcp_intf *netcp_priv, int order,
			    netcp_hook_rtn *hook_rtn, void *hook_data);
void *netcp_device_find_module(struct netcp_device *netcp_device,
			       const char *name);

/* SGMII functions */
int netcp_sgmii_reset(void __iomem *sgmii_ofs, int port);
bool netcp_sgmii_rtreset(void __iomem *sgmii_ofs, int port, bool set);
int netcp_sgmii_get_port_link(void __iomem *sgmii_ofs, int port);
int netcp_sgmii_config(void __iomem *sgmii_ofs, int port, u32 interface);

/* XGBE SERDES init functions */
int netcp_xgbe_serdes_init(void __iomem *serdes_regs, void __iomem *xgbe_regs);

#endif	/* __NETCP_H__ */
Commit	Line	Data
84640e27 KM	1	/*
	2	* NetCP driver local header
	3	*
	4	* Copyright (C) 2014 Texas Instruments Incorporated
	5	* Authors: Sandeep Nair <sandeep_n@ti.com>
	6	* Sandeep Paulraj <s-paulraj@ti.com>
	7	* Cyril Chemparathy <cyril@ti.com>
	8	* Santosh Shilimkar <santosh.shilimkar@ti.com>
	9	* Wingman Kwok <w-kwok2@ti.com>
	10	* Murali Karicheri <m-karicheri2@ti.com>
	11	*
	12	* This program is free software; you can redistribute it and/or
	13	* modify it under the terms of the GNU General Public License as
	14	* published by the Free Software Foundation version 2.
	15	*
	16	* This program is distributed "as is" WITHOUT ANY WARRANTY of any
	17	* kind, whether express or implied; without even the implied warranty
	18	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*/
	21	#ifndef __NETCP_H__
	22	#define __NETCP_H__
	23
	24	#include <linux/netdevice.h>
	25	#include <linux/soc/ti/knav_dma.h>
	26
	27	/* Maximum Ethernet frame size supported by Keystone switch */
	28	#define NETCP_MAX_FRAME_SIZE 9504
	29
	30	#define SGMII_LINK_MAC_MAC_AUTONEG 0
	31	#define SGMII_LINK_MAC_PHY 1
	32	#define SGMII_LINK_MAC_MAC_FORCED 2
	33	#define SGMII_LINK_MAC_FIBER 3
	34	#define SGMII_LINK_MAC_PHY_NO_MDIO 4
	35	#define XGMII_LINK_MAC_PHY 10
	36	#define XGMII_LINK_MAC_MAC_FORCED 11
	37
	38	struct netcp_device;
	39
	40	struct netcp_tx_pipe {
	41	struct netcp_device *netcp_device;
	42	void *dma_queue;
	43	unsigned int dma_queue_id;
e170f409 KM	44	/* To port for packet forwarded to switch. Used only by ethss */
	45	u8 switch_to_port;
	46	#define SWITCH_TO_PORT_IN_TAGINFO BIT(0)
	47	u8 flags;
84640e27 KM	48	void *dma_channel;
	49	const char *dma_chan_name;
	50	};
	51
	52	#define ADDR_NEW BIT(0)
	53	#define ADDR_VALID BIT(1)
	54
	55	enum netcp_addr_type {
	56	ADDR_ANY,
	57	ADDR_DEV,
	58	ADDR_UCAST,
	59	ADDR_MCAST,
	60	ADDR_BCAST
	61	};
	62
	63	struct netcp_addr {
	64	struct netcp_intf *netcp;
	65	unsigned char addr[ETH_ALEN];
	66	enum netcp_addr_type type;
	67	unsigned int flags;
	68	struct list_head node;
	69	};
	70
	71	struct netcp_intf {
	72	struct device *dev;
	73	struct device *ndev_dev;
	74	struct net_device *ndev;
	75	bool big_endian;
	76	unsigned int tx_compl_qid;
	77	void *tx_pool;
	78	struct list_head txhook_list_head;
	79	unsigned int tx_pause_threshold;
	80	void *tx_compl_q;
	81
	82	unsigned int tx_resume_threshold;
	83	void *rx_queue;
	84	void *rx_pool;
	85	struct list_head rxhook_list_head;
	86	unsigned int rx_queue_id;
	87	void *rx_fdq[KNAV_DMA_FDQ_PER_CHAN];
84640e27 KM	88	struct napi_struct rx_napi;
	89	struct napi_struct tx_napi;
	90
	91	void *rx_channel;
	92	const char *dma_chan_name;
	93	u32 rx_pool_size;
	94	u32 rx_pool_region_id;
	95	u32 tx_pool_size;
	96	u32 tx_pool_region_id;
	97	struct list_head module_head;
	98	struct list_head interface_list;
	99	struct list_head addr_list;
	100	bool netdev_registered;
	101	bool primary_module_attached;
	102
	103	/* Lock used for protecting Rx/Tx hook list management */
	104	spinlock_t lock;
	105	struct netcp_device *netcp_device;
	106	struct device_node *node_interface;
	107
	108	/* DMA configuration data */
	109	u32 msg_enable;
	110	u32 rx_queue_depths[KNAV_DMA_FDQ_PER_CHAN];
	111	};
	112
	113	#define NETCP_PSDATA_LEN KNAV_DMA_NUM_PS_WORDS
	114	struct netcp_packet {
	115	struct sk_buff *skb;
	116	u32 *epib;
	117	u32 *psdata;
	118	unsigned int psdata_len;
	119	struct netcp_intf *netcp;
	120	struct netcp_tx_pipe *tx_pipe;
	121	bool rxtstamp_complete;
	122	void *ts_context;
	123
	124	int (txtstamp_complete)(void ctx, struct netcp_packet *pkt);
	125	};
	126
	127	static inline u32 netcp_push_psdata(struct netcp_packet p_info,
	128	unsigned int bytes)
	129	{
	130	u32 *buf;
	131	unsigned int words;
	132
	133	if ((bytes & 0x03) != 0)
	134	return NULL;
	135	words = bytes >> 2;
	136
	137	if ((p_info->psdata_len + words) > NETCP_PSDATA_LEN)
	138	return NULL;
	139
	140	p_info->psdata_len += words;
	141	buf = &p_info->psdata[NETCP_PSDATA_LEN - p_info->psdata_len];
	142	return buf;
	143	}
	144
	145	static inline int netcp_align_psdata(struct netcp_packet *p_info,
	146	unsigned int byte_align)
	147	{
	148	int padding;
	149
	150	switch (byte_align) {
	151	case 0:
152	padding = -EINVAL;
153	break;
154	case 1:
155	case 2:
156	case 4:
157	padding = 0;
158	break;
159	case 8:
160	padding = (p_info->psdata_len << 2) % 8;
161	break;
162	case 16:
163	padding = (p_info->psdata_len << 2) % 16;
164	break;
165	default:
166	padding = (p_info->psdata_len << 2) % byte_align;
167	break;
168	}
169	return padding;
170	}
171
172	struct netcp_module {
173	const char *name;
174	struct module *owner;
175	bool primary;
176
177	/* probe/remove: called once per NETCP instance */
178	int (probe)(struct netcp_device netcp_device,
179	struct device device, struct device_node node,
180	void **inst_priv);
181	int (remove)(struct netcp_device netcp_device, void *inst_priv);
182
183	/* attach/release: called once per network interface */
184	int (attach)(void inst_priv, struct net_device *ndev,
185	struct device_node node, void *intf_priv);
186	int (release)(void intf_priv);
187	int (open)(void intf_priv, struct net_device *ndev);
188	int (close)(void intf_priv, struct net_device *ndev);
189	int (add_addr)(void intf_priv, struct netcp_addr *naddr);
190	int (del_addr)(void intf_priv, struct netcp_addr *naddr);
191	int (add_vid)(void intf_priv, int vid);
192	int (del_vid)(void intf_priv, int vid);
193	int (ioctl)(void intf_priv, struct ifreq *req, int cmd);
194
195	/* used internally */
196	struct list_head module_list;
197	struct list_head interface_list;
198	};
199
200	int netcp_register_module(struct netcp_module *module);
201	void netcp_unregister_module(struct netcp_module *module);
202	void netcp_module_get_intf_data(struct netcp_module module,
203	struct netcp_intf *intf);
204
205	int netcp_txpipe_init(struct netcp_tx_pipe *tx_pipe,
206	struct netcp_device *netcp_device,
207	const char *dma_chan_name, unsigned int dma_queue_id);
208	int netcp_txpipe_open(struct netcp_tx_pipe *tx_pipe);
209	int netcp_txpipe_close(struct netcp_tx_pipe *tx_pipe);
210
211	typedef int netcp_hook_rtn(int order, void data, struct netcp_packet packet);
212	int netcp_register_txhook(struct netcp_intf *netcp_priv, int order,
213	netcp_hook_rtn hook_rtn, void hook_data);
214	int netcp_unregister_txhook(struct netcp_intf *netcp_priv, int order,
215	netcp_hook_rtn hook_rtn, void hook_data);
216	int netcp_register_rxhook(struct netcp_intf *netcp_priv, int order,
217	netcp_hook_rtn hook_rtn, void hook_data);
218	int netcp_unregister_rxhook(struct netcp_intf *netcp_priv, int order,
219	netcp_hook_rtn hook_rtn, void hook_data);
220	void netcp_device_find_module(struct netcp_device netcp_device,
221	const char *name);
222
223	/* SGMII functions */
224	int netcp_sgmii_reset(void __iomem *sgmii_ofs, int port);
7025e88a	225	bool netcp_sgmii_rtreset(void __iomem *sgmii_ofs, int port, bool set);
84640e27 KM	226	int netcp_sgmii_get_port_link(void __iomem *sgmii_ofs, int port);
	227	int netcp_sgmii_config(void __iomem *sgmii_ofs, int port, u32 interface);
	228
	229	/* XGBE SERDES init functions */
	230	int netcp_xgbe_serdes_init(void __iomem serdes_regs, void __iomem xgbe_regs);
	231
	232	#endif /* __NETCP_H__ */