cxgb3: manage private iSCSI IP address (a109a5b9) · Commits · e / devices / android_kernel_sony_msm8998

drivers/net/cxgb3/adapter.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -63,6 +63,7 @@ struct port_info {
	struct link_config link_config;		struct link_config link_config;
	struct net_device_stats netstats;		struct net_device_stats netstats;
	int activity;		int activity;
			__be32 iscsi_ipv4addr;
	};		};

	enum { /* adapter flags */		enum { /* adapter flags */

drivers/net/cxgb3/cxgb3_ctl_defs.h

+7 −0

Original line number	Original line	Diff line number	Diff line
	@@ -57,6 +57,7 @@ enum {
	RDMA_GET_MIB = 19,		RDMA_GET_MIB = 19,

	GET_RX_PAGE_INFO = 50,		GET_RX_PAGE_INFO = 50,
			GET_ISCSI_IPV4ADDR = 51,
	};		};

	/*		/*
	@@ -86,6 +87,12 @@ struct iff_mac {
	u16 vlan_tag;		u16 vlan_tag;
	};		};

			/* Structure used to request a port's iSCSI IPv4 address */
			struct iscsi_ipv4addr {
			struct net_device dev; / the net_device */
			__be32 ipv4addr; /* the return iSCSI IPv4 address */
			};

	struct pci_dev;		struct pci_dev;

	/*		/*

drivers/net/cxgb3/cxgb3_offload.c

+49 −18

Original line number	Original line	Diff line number	Diff line
	@@ -182,7 +182,9 @@ static struct net_device get_iff_from_mac(struct adapter adapter,
	static int cxgb_ulp_iscsi_ctl(struct adapter *adapter, unsigned int req,		static int cxgb_ulp_iscsi_ctl(struct adapter *adapter, unsigned int req,
	void *data)		void *data)
	{		{
			int i;
	int ret = 0;		int ret = 0;
			unsigned int val = 0;
	struct ulp_iscsi_info *uiip = data;		struct ulp_iscsi_info *uiip = data;

	switch (req) {		switch (req) {
	@@ -191,31 +193,54 @@ static int cxgb_ulp_iscsi_ctl(struct adapter *adapter, unsigned int req,
	uiip->llimit = t3_read_reg(adapter, A_ULPRX_ISCSI_LLIMIT);		uiip->llimit = t3_read_reg(adapter, A_ULPRX_ISCSI_LLIMIT);
	uiip->ulimit = t3_read_reg(adapter, A_ULPRX_ISCSI_ULIMIT);		uiip->ulimit = t3_read_reg(adapter, A_ULPRX_ISCSI_ULIMIT);
	uiip->tagmask = t3_read_reg(adapter, A_ULPRX_ISCSI_TAGMASK);		uiip->tagmask = t3_read_reg(adapter, A_ULPRX_ISCSI_TAGMASK);

			val = t3_read_reg(adapter, A_ULPRX_ISCSI_PSZ);
			for (i = 0; i < 4; i++, val >>= 8)
			uiip->pgsz_factor[i] = val & 0xFF;

			val = t3_read_reg(adapter, A_TP_PARA_REG7);
			uiip->max_txsz =
			uiip->max_rxsz = min((val >> S_PMMAXXFERLEN0)&M_PMMAXXFERLEN0,
			(val >> S_PMMAXXFERLEN1)&M_PMMAXXFERLEN1);
	/*		/*
	* On tx, the iscsi pdu has to be <= tx page size and has to		* On tx, the iscsi pdu has to be <= tx page size and has to
	* fit into the Tx PM FIFO.		* fit into the Tx PM FIFO.
	*/		*/
	uiip->max_txsz = min(adapter->params.tp.tx_pg_size,		val = min(adapter->params.tp.tx_pg_size,
	t3_read_reg(adapter, A_PM1_TX_CFG) >> 17);		t3_read_reg(adapter, A_PM1_TX_CFG) >> 17);
	/* on rx, the iscsi pdu has to be < rx page size and the		uiip->max_txsz = min(val, uiip->max_txsz);
	whole pdu + cpl headers has to fit into one sge buffer */
	uiip->max_rxsz = min_t(unsigned int,		/* set MaxRxData to 16224 */
	adapter->params.tp.rx_pg_size,		val = t3_read_reg(adapter, A_TP_PARA_REG2);
	(adapter->sge.qs[0].fl[1].buf_size -		if ((val >> S_MAXRXDATA) != 0x3f60) {
	sizeof(struct cpl_rx_data) * 2 -		val &= (M_RXCOALESCESIZE << S_RXCOALESCESIZE);
	sizeof(struct cpl_rx_data_ddp)));		val \|= V_MAXRXDATA(0x3f60);
			printk(KERN_INFO
			"%s, iscsi set MaxRxData to 16224 (0x%x).\n",
			adapter->name, val);
			t3_write_reg(adapter, A_TP_PARA_REG2, val);
			}

			/*
			* on rx, the iscsi pdu has to be < rx page size and the
			* the max rx data length programmed in TP
			*/
			val = min(adapter->params.tp.rx_pg_size,
			((t3_read_reg(adapter, A_TP_PARA_REG2)) >>
			S_MAXRXDATA) & M_MAXRXDATA);
			uiip->max_rxsz = min(val, uiip->max_rxsz);
	break;		break;
	case ULP_ISCSI_SET_PARAMS:		case ULP_ISCSI_SET_PARAMS:
	t3_write_reg(adapter, A_ULPRX_ISCSI_TAGMASK, uiip->tagmask);		t3_write_reg(adapter, A_ULPRX_ISCSI_TAGMASK, uiip->tagmask);
	/* set MaxRxData and MaxCoalesceSize to 16224 */
	t3_write_reg(adapter, A_TP_PARA_REG2, 0x3f603f60);
	/* program the ddp page sizes */		/* program the ddp page sizes */
	{
	int i;
	unsigned int val = 0;
	for (i = 0; i < 4; i++)		for (i = 0; i < 4; i++)
	val \|= (uiip->pgsz_factor[i] & 0xF) << (8 * i);		val \|= (uiip->pgsz_factor[i] & 0xF) << (8 * i);
	if (val)		if (val && (val != t3_read_reg(adapter, A_ULPRX_ISCSI_PSZ))) {
			printk(KERN_INFO
			"%s, setting iscsi pgsz 0x%x, %u,%u,%u,%u.\n",
			adapter->name, val, uiip->pgsz_factor[0],
			uiip->pgsz_factor[1], uiip->pgsz_factor[2],
			uiip->pgsz_factor[3]);
	t3_write_reg(adapter, A_ULPRX_ISCSI_PSZ, val);		t3_write_reg(adapter, A_ULPRX_ISCSI_PSZ, val);
	}		}
	break;		break;
	@@ -407,6 +432,12 @@ static int cxgb_offload_ctl(struct t3cdev tdev, unsigned int req, void data)
	rx_page_info->page_size = tp->rx_pg_size;		rx_page_info->page_size = tp->rx_pg_size;
	rx_page_info->num = tp->rx_num_pgs;		rx_page_info->num = tp->rx_num_pgs;
	break;		break;
			case GET_ISCSI_IPV4ADDR: {
			struct iscsi_ipv4addr *p = data;
			struct port_info *pi = netdev_priv(p->dev);
			p->ipv4addr = pi->iscsi_ipv4addr;
			break;
			}
	default:		default:
	return -EOPNOTSUPP;		return -EOPNOTSUPP;
	}		}

drivers/net/cxgb3/sge.c

+64 −3

Original line number	Original line	Diff line number	Diff line
	@@ -36,6 +36,7 @@
	#include <linux/ip.h>		#include <linux/ip.h>
	#include <linux/tcp.h>		#include <linux/tcp.h>
	#include <linux/dma-mapping.h>		#include <linux/dma-mapping.h>
			#include <net/arp.h>
	#include "common.h"		#include "common.h"
	#include "regs.h"		#include "regs.h"
	#include "sge_defs.h"		#include "sge_defs.h"
	@@ -1862,6 +1863,54 @@ static void restart_tx(struct sge_qset *qs)
	}		}
	}		}

			/**
			* cxgb3_arp_process - process an ARP request probing a private IP address
			* @adapter: the adapter
			* @skb: the skbuff containing the ARP request
			*
			* Check if the ARP request is probing the private IP address
			* dedicated to iSCSI, generate an ARP reply if so.
			*/
			static void cxgb3_arp_process(struct adapter adapter, struct sk_buff skb)
			{
			struct net_device *dev = skb->dev;
			struct port_info *pi;
			struct arphdr *arp;
			unsigned char *arp_ptr;
			unsigned char *sha;
			__be32 sip, tip;

			if (!dev)
			return;

			skb_reset_network_header(skb);
			arp = arp_hdr(skb);

			if (arp->ar_op != htons(ARPOP_REQUEST))
			return;

			arp_ptr = (unsigned char *)(arp + 1);
			sha = arp_ptr;
			arp_ptr += dev->addr_len;
			memcpy(&sip, arp_ptr, sizeof(sip));
			arp_ptr += sizeof(sip);
			arp_ptr += dev->addr_len;
			memcpy(&tip, arp_ptr, sizeof(tip));

			pi = netdev_priv(dev);
			if (tip != pi->iscsi_ipv4addr)
			return;

			arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
			dev->dev_addr, sha);

			}

			static inline int is_arp(struct sk_buff *skb)
			{
			return skb->protocol == htons(ETH_P_ARP);
			}

	/**		/**
	* rx_eth - process an ingress ethernet packet		* rx_eth - process an ingress ethernet packet
	* @adap: the adapter		* @adap: the adapter
	@@ -1885,7 +1934,7 @@ static void rx_eth(struct adapter adap, struct sge_rspq rq,
	pi = netdev_priv(skb->dev);		pi = netdev_priv(skb->dev);
	if (pi->rx_csum_offload && p->csum_valid && p->csum == htons(0xffff) &&		if (pi->rx_csum_offload && p->csum_valid && p->csum == htons(0xffff) &&
	!p->fragment) {		!p->fragment) {
	rspq_to_qset(rq)->port_stats[SGE_PSTAT_RX_CSUM_GOOD]++;		qs->port_stats[SGE_PSTAT_RX_CSUM_GOOD]++;
	skb->ip_summed = CHECKSUM_UNNECESSARY;		skb->ip_summed = CHECKSUM_UNNECESSARY;
	} else		} else
	skb->ip_summed = CHECKSUM_NONE;		skb->ip_summed = CHECKSUM_NONE;
	@@ -1900,16 +1949,28 @@ static void rx_eth(struct adapter adap, struct sge_rspq rq,
	grp,		grp,
	ntohs(p->vlan),		ntohs(p->vlan),
	p);		p);
	else		else {
			if (unlikely(pi->iscsi_ipv4addr &&
			is_arp(skb))) {
			unsigned short vtag = ntohs(p->vlan) &
			VLAN_VID_MASK;
			skb->dev = vlan_group_get_device(grp,
			vtag);
			cxgb3_arp_process(adap, skb);
			}
	__vlan_hwaccel_rx(skb, grp, ntohs(p->vlan),		__vlan_hwaccel_rx(skb, grp, ntohs(p->vlan),
	rq->polling);		rq->polling);
			}
	else		else
	dev_kfree_skb_any(skb);		dev_kfree_skb_any(skb);
	} else if (rq->polling) {		} else if (rq->polling) {
	if (lro)		if (lro)
	lro_receive_skb(&qs->lro_mgr, skb, p);		lro_receive_skb(&qs->lro_mgr, skb, p);
	else		else {
			if (unlikely(pi->iscsi_ipv4addr && is_arp(skb)))
			cxgb3_arp_process(adap, skb);
	netif_receive_skb(skb);		netif_receive_skb(skb);
			}
	} else		} else
	netif_rx(skb);		netif_rx(skb);
	}		}