[deliverable/linux.git] / drivers / net / ethernet / sfc / mcdi_mac.c

/****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2009-2010 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation, incorporated herein by reference.
 */

#include "net_driver.h"
#include "efx.h"
#include "mcdi.h"
#include "mcdi_pcol.h"

int efx_mcdi_set_mac(struct efx_nic *efx)
{
	u32 reject, fcntl;
	u8 cmdbytes[MC_CMD_SET_MAC_IN_LEN];

	memcpy(cmdbytes + MC_CMD_SET_MAC_IN_ADDR_OFST,
	       efx->net_dev->dev_addr, ETH_ALEN);

	MCDI_SET_DWORD(cmdbytes, SET_MAC_IN_MTU,
			EFX_MAX_FRAME_LEN(efx->net_dev->mtu));
	MCDI_SET_DWORD(cmdbytes, SET_MAC_IN_DRAIN, 0);

	/* The MCDI command provides for controlling accept/reject
	 * of broadcast packets too, but the driver doesn't currently
	 * expose this. */
	reject = (efx->promiscuous) ? 0 :
		(1 << MC_CMD_SET_MAC_IN_REJECT_UNCST_LBN);
	MCDI_SET_DWORD(cmdbytes, SET_MAC_IN_REJECT, reject);

	switch (efx->wanted_fc) {
	case EFX_FC_RX | EFX_FC_TX:
		fcntl = MC_CMD_FCNTL_BIDIR;
		break;
	case EFX_FC_RX:
		fcntl = MC_CMD_FCNTL_RESPOND;
		break;
	default:
		fcntl = MC_CMD_FCNTL_OFF;
		break;
	}
	if (efx->wanted_fc & EFX_FC_AUTO)
		fcntl = MC_CMD_FCNTL_AUTO;
	if (efx->fc_disable)
		fcntl = MC_CMD_FCNTL_OFF;

	MCDI_SET_DWORD(cmdbytes, SET_MAC_IN_FCNTL, fcntl);

	return efx_mcdi_rpc(efx, MC_CMD_SET_MAC, cmdbytes, sizeof(cmdbytes),
			    NULL, 0, NULL);
}

bool efx_mcdi_mac_check_fault(struct efx_nic *efx)
{
	u8 outbuf[MC_CMD_GET_LINK_OUT_LEN];
	size_t outlength;
	int rc;

	BUILD_BUG_ON(MC_CMD_GET_LINK_IN_LEN != 0);

	rc = efx_mcdi_rpc(efx, MC_CMD_GET_LINK, NULL, 0,
			  outbuf, sizeof(outbuf), &outlength);
	if (rc) {
		netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
			  __func__, rc);
		return true;
	}

	return MCDI_DWORD(outbuf, GET_LINK_OUT_MAC_FAULT) != 0;
}

int efx_mcdi_mac_stats(struct efx_nic *efx, dma_addr_t dma_addr,
		       u32 dma_len, int enable, int clear)
{
	u8 inbuf[MC_CMD_MAC_STATS_IN_LEN];
	int rc;
	efx_dword_t *cmd_ptr;
	int period = enable ? 1000 : 0;
	u32 addr_hi;
	u32 addr_lo;

	BUILD_BUG_ON(MC_CMD_MAC_STATS_OUT_DMA_LEN != 0);

	addr_lo = ((u64)dma_addr) >> 0;
	addr_hi = ((u64)dma_addr) >> 32;

	MCDI_SET_DWORD(inbuf, MAC_STATS_IN_DMA_ADDR_LO, addr_lo);
	MCDI_SET_DWORD(inbuf, MAC_STATS_IN_DMA_ADDR_HI, addr_hi);
	cmd_ptr = (efx_dword_t *)MCDI_PTR(inbuf, MAC_STATS_IN_CMD);
	EFX_POPULATE_DWORD_7(*cmd_ptr,
			     MC_CMD_MAC_STATS_IN_DMA, !!enable,
			     MC_CMD_MAC_STATS_IN_CLEAR, clear,
			     MC_CMD_MAC_STATS_IN_PERIODIC_CHANGE, 1,
			     MC_CMD_MAC_STATS_IN_PERIODIC_ENABLE, !!enable,
			     MC_CMD_MAC_STATS_IN_PERIODIC_CLEAR, 0,
			     MC_CMD_MAC_STATS_IN_PERIODIC_NOEVENT, 1,
			     MC_CMD_MAC_STATS_IN_PERIOD_MS, period);
	MCDI_SET_DWORD(inbuf, MAC_STATS_IN_DMA_LEN, dma_len);

	rc = efx_mcdi_rpc(efx, MC_CMD_MAC_STATS, inbuf, sizeof(inbuf),
			  NULL, 0, NULL);
	if (rc)
		goto fail;

	return 0;

fail:
	netif_err(efx, hw, efx->net_dev, "%s: %s failed rc=%d\n",
		  __func__, enable ? "enable" : "disable", rc);
	return rc;
}

int efx_mcdi_mac_reconfigure(struct efx_nic *efx)
{
	int rc;

	WARN_ON(!mutex_is_locked(&efx->mac_lock));

	rc = efx_mcdi_set_mac(efx);
	if (rc != 0)
		return rc;

	return efx_mcdi_rpc(efx, MC_CMD_SET_MCAST_HASH,
			    efx->multicast_hash.byte,
			    sizeof(efx->multicast_hash),
			    NULL, 0, NULL);
}
Commit	Line	Data
afd4aea0 BH	1	/****************************************************************************
afd4aea0 BH	2	* Driver for Solarflare Solarstorm network controllers and boards
0a6f40c6	3	* Copyright 2009-2010 Solarflare Communications Inc.
afd4aea0 BH	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 as published
	7	* by the Free Software Foundation, incorporated herein by reference.
	8	*/
	9
	10	#include "net_driver.h"
	11	#include "efx.h"
afd4aea0 BH	12	#include "mcdi.h"
	13	#include "mcdi_pcol.h"
	14
cd2d5b52	15	int efx_mcdi_set_mac(struct efx_nic *efx)
afd4aea0 BH	16	{
	17	u32 reject, fcntl;
	18	u8 cmdbytes[MC_CMD_SET_MAC_IN_LEN];
	19
	20	memcpy(cmdbytes + MC_CMD_SET_MAC_IN_ADDR_OFST,
	21	efx->net_dev->dev_addr, ETH_ALEN);
	22
	23	MCDI_SET_DWORD(cmdbytes, SET_MAC_IN_MTU,
	24	EFX_MAX_FRAME_LEN(efx->net_dev->mtu));
	25	MCDI_SET_DWORD(cmdbytes, SET_MAC_IN_DRAIN, 0);
	26
	27	/* The MCDI command provides for controlling accept/reject
	28	* of broadcast packets too, but the driver doesn't currently
	29	* expose this. */
	30	reject = (efx->promiscuous) ? 0 :
	31	(1 << MC_CMD_SET_MAC_IN_REJECT_UNCST_LBN);
	32	MCDI_SET_DWORD(cmdbytes, SET_MAC_IN_REJECT, reject);
	33
	34	switch (efx->wanted_fc) {
	35	case EFX_FC_RX \| EFX_FC_TX:
	36	fcntl = MC_CMD_FCNTL_BIDIR;
	37	break;
	38	case EFX_FC_RX:
	39	fcntl = MC_CMD_FCNTL_RESPOND;
	40	break;
	41	default:
	42	fcntl = MC_CMD_FCNTL_OFF;
	43	break;
	44	}
	45	if (efx->wanted_fc & EFX_FC_AUTO)
	46	fcntl = MC_CMD_FCNTL_AUTO;
a606f432 SH	47	if (efx->fc_disable)
a606f432 SH	48	fcntl = MC_CMD_FCNTL_OFF;
afd4aea0 BH	49
	50	MCDI_SET_DWORD(cmdbytes, SET_MAC_IN_FCNTL, fcntl);
	51
	52	return efx_mcdi_rpc(efx, MC_CMD_SET_MAC, cmdbytes, sizeof(cmdbytes),
	53	NULL, 0, NULL);
	54	}
	55
1daf4170	56	bool efx_mcdi_mac_check_fault(struct efx_nic *efx)
afd4aea0 BH	57	{
	58	u8 outbuf[MC_CMD_GET_LINK_OUT_LEN];
	59	size_t outlength;
	60	int rc;
	61
	62	BUILD_BUG_ON(MC_CMD_GET_LINK_IN_LEN != 0);
	63
	64	rc = efx_mcdi_rpc(efx, MC_CMD_GET_LINK, NULL, 0,
	65	outbuf, sizeof(outbuf), &outlength);
1daf4170 BH	66	if (rc) {
	67	netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n",
	68	__func__, rc);
	69	return true;
	70	}
afd4aea0	71
1daf4170	72	return MCDI_DWORD(outbuf, GET_LINK_OUT_MAC_FAULT) != 0;
afd4aea0 BH	73	}
	74
	75	int efx_mcdi_mac_stats(struct efx_nic *efx, dma_addr_t dma_addr,
	76	u32 dma_len, int enable, int clear)
	77	{
	78	u8 inbuf[MC_CMD_MAC_STATS_IN_LEN];
	79	int rc;
	80	efx_dword_t *cmd_ptr;
3a595102	81	int period = enable ? 1000 : 0;
afd4aea0 BH	82	u32 addr_hi;
	83	u32 addr_lo;
	84
05a9320f	85	BUILD_BUG_ON(MC_CMD_MAC_STATS_OUT_DMA_LEN != 0);
afd4aea0 BH	86
	87	addr_lo = ((u64)dma_addr) >> 0;
	88	addr_hi = ((u64)dma_addr) >> 32;
	89
	90	MCDI_SET_DWORD(inbuf, MAC_STATS_IN_DMA_ADDR_LO, addr_lo);
	91	MCDI_SET_DWORD(inbuf, MAC_STATS_IN_DMA_ADDR_HI, addr_hi);
	92	cmd_ptr = (efx_dword_t *)MCDI_PTR(inbuf, MAC_STATS_IN_CMD);
3a595102	93	EFX_POPULATE_DWORD_7(*cmd_ptr,
05a9320f BH	94	MC_CMD_MAC_STATS_IN_DMA, !!enable,
	95	MC_CMD_MAC_STATS_IN_CLEAR, clear,
	96	MC_CMD_MAC_STATS_IN_PERIODIC_CHANGE, 1,
	97	MC_CMD_MAC_STATS_IN_PERIODIC_ENABLE, !!enable,
	98	MC_CMD_MAC_STATS_IN_PERIODIC_CLEAR, 0,
	99	MC_CMD_MAC_STATS_IN_PERIODIC_NOEVENT, 1,
	100	MC_CMD_MAC_STATS_IN_PERIOD_MS, period);
afd4aea0 BH	101	MCDI_SET_DWORD(inbuf, MAC_STATS_IN_DMA_LEN, dma_len);
	102
	103	rc = efx_mcdi_rpc(efx, MC_CMD_MAC_STATS, inbuf, sizeof(inbuf),
	104	NULL, 0, NULL);
	105	if (rc)
	106	goto fail;
	107
	108	return 0;
	109
	110	fail:
62776d03 BH	111	netif_err(efx, hw, efx->net_dev, "%s: %s failed rc=%d\n",
62776d03 BH	112	__func__, enable ? "enable" : "disable", rc);
afd4aea0 BH	113	return rc;
	114	}
	115
710b208d	116	int efx_mcdi_mac_reconfigure(struct efx_nic *efx)
afd4aea0 BH	117	{
	118	int rc;
	119
30b81cda BH	120	WARN_ON(!mutex_is_locked(&efx->mac_lock));
30b81cda BH	121
afd4aea0 BH	122	rc = efx_mcdi_set_mac(efx);
	123	if (rc != 0)
	124	return rc;
	125
30b81cda BH	126	return efx_mcdi_rpc(efx, MC_CMD_SET_MCAST_HASH,
	127	efx->multicast_hash.byte,
	128	sizeof(efx->multicast_hash),
	129	NULL, 0, NULL);
afd4aea0	130	}