[net-next-2.6.git] / drivers / s390 / net / qeth_tso.h

/*
 * linux/drivers/s390/net/qeth_tso.h
 *
 * Header file for qeth TCP Segmentation Offload support.
 *
 * Copyright 2004 IBM Corporation
 *
 *    Author(s): Frank Pavlic <fpavlic@de.ibm.com>
 *
 */
#ifndef __QETH_TSO_H__
#define __QETH_TSO_H__

#include <linux/skbuff.h>
#include <linux/tcp.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <net/ip6_checksum.h>
#include "qeth.h"
#include "qeth_mpc.h"


static inline struct qeth_hdr_tso *
qeth_tso_prepare_skb(struct qeth_card *card, struct sk_buff **skb)
{
	QETH_DBF_TEXT(trace, 5, "tsoprsk");
	return qeth_push_skb(card, *skb, sizeof(struct qeth_hdr_tso));
}

/**
 * fill header for a TSO packet
 */
static inline void
qeth_tso_fill_header(struct qeth_card *card, struct sk_buff *skb)
{
	struct qeth_hdr_tso *hdr;
	struct tcphdr *tcph;
	struct iphdr *iph;

	QETH_DBF_TEXT(trace, 5, "tsofhdr");

	hdr  = (struct qeth_hdr_tso *) skb->data;
	iph  = ip_hdr(skb);
	tcph = tcp_hdr(skb);
	/*fix header to TSO values ...*/
	hdr->hdr.hdr.l3.id = QETH_HEADER_TYPE_TSO;
	/*set values which are fix for the first approach ...*/
	hdr->ext.hdr_tot_len = (__u16) sizeof(struct qeth_hdr_ext_tso);
	hdr->ext.imb_hdr_no  = 1;
	hdr->ext.hdr_type    = 1;
	hdr->ext.hdr_version = 1;
	hdr->ext.hdr_len     = 28;
	/*insert non-fix values */
	hdr->ext.mss = skb_shinfo(skb)->gso_size;
	hdr->ext.dg_hdr_len = (__u16)(iph->ihl*4 + tcph->doff*4);
	hdr->ext.payload_len = (__u16)(skb->len - hdr->ext.dg_hdr_len -
				       sizeof(struct qeth_hdr_tso));
}

/**
 * change some header values as requested by hardware
 */
static inline void
qeth_tso_set_tcpip_header(struct qeth_card *card, struct sk_buff *skb)
{
	struct iphdr *iph    = ip_hdr(skb);
	struct ipv6hdr *ip6h = ipv6_hdr(skb);
	struct tcphdr *tcph  = tcp_hdr(skb);

	tcph->check = 0;
	if (skb->protocol == ETH_P_IPV6) {
		ip6h->payload_len = 0;
		tcph->check = ~csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
					       0, IPPROTO_TCP, 0);
		return;
	}
	/*OSA want us to set these values ...*/
	tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
					 0, IPPROTO_TCP, 0);
	iph->tot_len = 0;
	iph->check = 0;
}

static inline int
qeth_tso_prepare_packet(struct qeth_card *card, struct sk_buff *skb,
			int ipv, int cast_type)
{
	struct qeth_hdr_tso *hdr;

	QETH_DBF_TEXT(trace, 5, "tsoprep");

	hdr = (struct qeth_hdr_tso *) qeth_tso_prepare_skb(card, &skb);
	if (hdr == NULL) {
		QETH_DBF_TEXT(trace, 4, "tsoperr");
		return -ENOMEM;
	}
	memset(hdr, 0, sizeof(struct qeth_hdr_tso));
	/*fill first 32 bytes of  qdio header as used
	 *FIXME: TSO has two struct members
	 * with different names but same size
	 * */
	qeth_fill_header(card, &hdr->hdr, skb, ipv, cast_type);
	qeth_tso_fill_header(card, skb);
	qeth_tso_set_tcpip_header(card, skb);
	return 0;
}

static inline void
__qeth_fill_buffer_frag(struct sk_buff *skb, struct qdio_buffer *buffer,
			int is_tso, int *next_element_to_fill)
{
	struct skb_frag_struct *frag;
	int fragno;
	unsigned long addr;
	int element, cnt, dlen;

	fragno = skb_shinfo(skb)->nr_frags;
	element = *next_element_to_fill;
	dlen = 0;

	if (is_tso)
		buffer->element[element].flags =
			SBAL_FLAGS_MIDDLE_FRAG;
	else
		buffer->element[element].flags =
			SBAL_FLAGS_FIRST_FRAG;
	if ( (dlen = (skb->len - skb->data_len)) ) {
		buffer->element[element].addr = skb->data;
		buffer->element[element].length = dlen;
		element++;
	}
	for (cnt = 0; cnt < fragno; cnt++) {
		frag = &skb_shinfo(skb)->frags[cnt];
		addr = (page_to_pfn(frag->page) << PAGE_SHIFT) +
			frag->page_offset;
		buffer->element[element].addr = (char *)addr;
		buffer->element[element].length = frag->size;
		if (cnt < (fragno - 1))
			buffer->element[element].flags =
				SBAL_FLAGS_MIDDLE_FRAG;
		else
			buffer->element[element].flags =
				SBAL_FLAGS_LAST_FRAG;
		element++;
	}
	*next_element_to_fill = element;
}
#endif /* __QETH_TSO_H__ */
Commit	Line	Data
1da177e4	1	/*
e018ba1f	2	* linux/drivers/s390/net/qeth_tso.h
1da177e4 LT	3	*
	4	* Header file for qeth TCP Segmentation Offload support.
	5	*
	6	* Copyright 2004 IBM Corporation
	7	*
1387780f	8	* Author(s): Frank Pavlic <fpavlic@de.ibm.com>
1da177e4	9	*
1da177e4 LT	10	*/
	11	#ifndef __QETH_TSO_H__
	12	#define __QETH_TSO_H__
	13
05e08a2a FP	14	#include <linux/skbuff.h>
	15	#include <linux/tcp.h>
	16	#include <linux/ip.h>
	17	#include <linux/ipv6.h>
	18	#include <net/ip6_checksum.h>
	19	#include "qeth.h"
	20	#include "qeth_mpc.h"
1da177e4	21
1da177e4	22
05e08a2a FP	23	static inline struct qeth_hdr_tso *
	24	qeth_tso_prepare_skb(struct qeth_card card, struct sk_buff *skb)
	25	{
	26	QETH_DBF_TEXT(trace, 5, "tsoprsk");
f7b65d70	27	return qeth_push_skb(card, *skb, sizeof(struct qeth_hdr_tso));
05e08a2a FP	28	}
	29
	30	/**
	31	* fill header for a TSO packet
	32	*/
	33	static inline void
	34	qeth_tso_fill_header(struct qeth_card card, struct sk_buff skb)
	35	{
	36	struct qeth_hdr_tso *hdr;
	37	struct tcphdr *tcph;
	38	struct iphdr *iph;
1da177e4	39
05e08a2a FP	40	QETH_DBF_TEXT(trace, 5, "tsofhdr");
	41
	42	hdr = (struct qeth_hdr_tso *) skb->data;
eddc9ec5	43	iph = ip_hdr(skb);
aa8223c7	44	tcph = tcp_hdr(skb);
05e08a2a FP	45	/fix header to TSO values .../
	46	hdr->hdr.hdr.l3.id = QETH_HEADER_TYPE_TSO;
	47	/set values which are fix for the first approach .../
	48	hdr->ext.hdr_tot_len = (__u16) sizeof(struct qeth_hdr_ext_tso);
	49	hdr->ext.imb_hdr_no = 1;
	50	hdr->ext.hdr_type = 1;
	51	hdr->ext.hdr_version = 1;
	52	hdr->ext.hdr_len = 28;
	53	/insert non-fix values /
7967168c	54	hdr->ext.mss = skb_shinfo(skb)->gso_size;
05e08a2a FP	55	hdr->ext.dg_hdr_len = (__u16)(iph->ihl4 + tcph->doff4);
	56	hdr->ext.payload_len = (__u16)(skb->len - hdr->ext.dg_hdr_len -
	57	sizeof(struct qeth_hdr_tso));
	58	}
	59
	60	/**
	61	* change some header values as requested by hardware
	62	*/
	63	static inline void
	64	qeth_tso_set_tcpip_header(struct qeth_card card, struct sk_buff skb)
	65	{
eddc9ec5	66	struct iphdr *iph = ip_hdr(skb);
0660e03f	67	struct ipv6hdr *ip6h = ipv6_hdr(skb);
aa8223c7	68	struct tcphdr *tcph = tcp_hdr(skb);
05e08a2a FP	69
	70	tcph->check = 0;
	71	if (skb->protocol == ETH_P_IPV6) {
	72	ip6h->payload_len = 0;
	73	tcph->check = ~csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
	74	0, IPPROTO_TCP, 0);
	75	return;
	76	}
	77	/OSA want us to set these values .../
	78	tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
	79	0, IPPROTO_TCP, 0);
	80	iph->tot_len = 0;
	81	iph->check = 0;
	82	}
1da177e4	83
1da177e4	84	static inline int
05e08a2a FP	85	qeth_tso_prepare_packet(struct qeth_card card, struct sk_buff skb,
05e08a2a FP	86	int ipv, int cast_type)
1da177e4	87	{
05e08a2a	88	struct qeth_hdr_tso *hdr;
1da177e4	89
05e08a2a FP	90	QETH_DBF_TEXT(trace, 5, "tsoprep");
	91
	92	hdr = (struct qeth_hdr_tso *) qeth_tso_prepare_skb(card, &skb);
	93	if (hdr == NULL) {
	94	QETH_DBF_TEXT(trace, 4, "tsoperr");
	95	return -ENOMEM;
	96	}
	97	memset(hdr, 0, sizeof(struct qeth_hdr_tso));
	98	/*fill first 32 bytes of qdio header as used
	99	*FIXME: TSO has two struct members
	100	* with different names but same size
	101	* */
	102	qeth_fill_header(card, &hdr->hdr, skb, ipv, cast_type);
	103	qeth_tso_fill_header(card, skb);
	104	qeth_tso_set_tcpip_header(card, skb);
	105	return 0;
d801145d FP	106	}
	107
	108	static inline void
	109	__qeth_fill_buffer_frag(struct sk_buff skb, struct qdio_buffer buffer,
	110	int is_tso, int *next_element_to_fill)
	111	{
d801145d FP	112	struct skb_frag_struct *frag;
	113	int fragno;
	114	unsigned long addr;
05e08a2a	115	int element, cnt, dlen;
e82b0f2c	116
05e08a2a FP	117	fragno = skb_shinfo(skb)->nr_frags;
	118	element = *next_element_to_fill;
	119	dlen = 0;
e82b0f2c	120
05e08a2a FP	121	if (is_tso)
	122	buffer->element[element].flags =
	123	SBAL_FLAGS_MIDDLE_FRAG;
	124	else
	125	buffer->element[element].flags =
	126	SBAL_FLAGS_FIRST_FRAG;
	127	if ( (dlen = (skb->len - skb->data_len)) ) {
	128	buffer->element[element].addr = skb->data;
	129	buffer->element[element].length = dlen;
	130	element++;
1da177e4	131	}
05e08a2a FP	132	for (cnt = 0; cnt < fragno; cnt++) {
	133	frag = &skb_shinfo(skb)->frags[cnt];
	134	addr = (page_to_pfn(frag->page) << PAGE_SHIFT) +
	135	frag->page_offset;
	136	buffer->element[element].addr = (char *)addr;
	137	buffer->element[element].length = frag->size;
	138	if (cnt < (fragno - 1))
	139	buffer->element[element].flags =
	140	SBAL_FLAGS_MIDDLE_FRAG;
	141	else
	142	buffer->element[element].flags =
	143	SBAL_FLAGS_LAST_FRAG;
	144	element++;
	145	}
	146	*next_element_to_fill = element;
1da177e4 LT	147	}
1da177e4 LT	148	#endif /* __QETH_TSO_H__ */