[net-next-2.6.git] / net / caif / cffrml.c

/*
 * CAIF Framing Layer.
 *
 * Copyright (C) ST-Ericsson AB 2010
 * Author:	Sjur Brendeland/sjur.brandeland@stericsson.com
 * License terms: GNU General Public License (GPL) version 2
 */

#include <linux/stddef.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/crc-ccitt.h>
#include <net/caif/caif_layer.h>
#include <net/caif/cfpkt.h>
#include <net/caif/cffrml.h>

#define container_obj(layr) container_of(layr, struct cffrml, layer)

struct cffrml {
	struct cflayer layer;
	bool dofcs;		/* !< FCS active */
};

static int cffrml_receive(struct cflayer *layr, struct cfpkt *pkt);
static int cffrml_transmit(struct cflayer *layr, struct cfpkt *pkt);
static void cffrml_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
				int phyid);

static u32 cffrml_rcv_error;
static u32 cffrml_rcv_checsum_error;
struct cflayer *cffrml_create(u16 phyid, bool use_fcs)
{
	struct cffrml *this = kmalloc(sizeof(struct cffrml), GFP_ATOMIC);
	if (!this) {
		pr_warning("CAIF: %s(): Out of memory\n", __func__);
		return NULL;
	}
	caif_assert(offsetof(struct cffrml, layer) == 0);

	memset(this, 0, sizeof(struct cflayer));
	this->layer.receive = cffrml_receive;
	this->layer.transmit = cffrml_transmit;
	this->layer.ctrlcmd = cffrml_ctrlcmd;
	snprintf(this->layer.name, CAIF_LAYER_NAME_SZ, "frm%d", phyid);
	this->dofcs = use_fcs;
	this->layer.id = phyid;
	return (struct cflayer *) this;
}

void cffrml_set_uplayer(struct cflayer *this, struct cflayer *up)
{
	this->up = up;
}

void cffrml_set_dnlayer(struct cflayer *this, struct cflayer *dn)
{
	this->dn = dn;
}

static u16 cffrml_checksum(u16 chks, void *buf, u16 len)
{
	/* FIXME: FCS should be moved to glue in order to use OS-Specific
	 * solutions
	 */
	return crc_ccitt(chks, buf, len);
}

static int cffrml_receive(struct cflayer *layr, struct cfpkt *pkt)
{
	u16 tmp;
	u16 len;
	u16 hdrchks;
	u16 pktchks;
	struct cffrml *this;
	this = container_obj(layr);

	cfpkt_extr_head(pkt, &tmp, 2);
	len = le16_to_cpu(tmp);

	/* Subtract for FCS on length if FCS is not used. */
	if (!this->dofcs)
		len -= 2;

	if (cfpkt_setlen(pkt, len) < 0) {
		++cffrml_rcv_error;
		pr_err("CAIF: %s():Framing length error (%d)\n", __func__, len);
		cfpkt_destroy(pkt);
		return -EPROTO;
	}
	/*
	 * Don't do extract if FCS is false, rather do setlen - then we don't
	 * get a cache-miss.
	 */
	if (this->dofcs) {
		cfpkt_extr_trail(pkt, &tmp, 2);
		hdrchks = le16_to_cpu(tmp);
		pktchks = cfpkt_iterate(pkt, cffrml_checksum, 0xffff);
		if (pktchks != hdrchks) {
			cfpkt_add_trail(pkt, &tmp, 2);
			++cffrml_rcv_error;
			++cffrml_rcv_checsum_error;
			pr_info("CAIF: %s(): Frame checksum error "
				"(0x%x != 0x%x)\n", __func__, hdrchks, pktchks);
			return -EILSEQ;
		}
	}
	if (cfpkt_erroneous(pkt)) {
		++cffrml_rcv_error;
		pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
		cfpkt_destroy(pkt);
		return -EPROTO;
	}
	return layr->up->receive(layr->up, pkt);
}

static int cffrml_transmit(struct cflayer *layr, struct cfpkt *pkt)
{
	int tmp;
	u16 chks;
	u16 len;
	int ret;
	struct cffrml *this = container_obj(layr);
	if (this->dofcs) {
		chks = cfpkt_iterate(pkt, cffrml_checksum, 0xffff);
		tmp = cpu_to_le16(chks);
		cfpkt_add_trail(pkt, &tmp, 2);
	} else {
		cfpkt_pad_trail(pkt, 2);
	}
	len = cfpkt_getlen(pkt);
	tmp = cpu_to_le16(len);
	cfpkt_add_head(pkt, &tmp, 2);
	cfpkt_info(pkt)->hdr_len += 2;
	if (cfpkt_erroneous(pkt)) {
		pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
		return -EPROTO;
	}
	ret = layr->dn->transmit(layr->dn, pkt);
	if (ret < 0) {
		/* Remove header on faulty packet. */
		cfpkt_extr_head(pkt, &tmp, 2);
	}
	return ret;
}

static void cffrml_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
					int phyid)
{
	if (layr->up->ctrlcmd)
		layr->up->ctrlcmd(layr->up, ctrl, layr->id);
}
Commit	Line	Data
b482cd20 SB	1	/*
	2	* CAIF Framing Layer.
	3	*
	4	* Copyright (C) ST-Ericsson AB 2010
	5	* Author: Sjur Brendeland/sjur.brandeland@stericsson.com
	6	* License terms: GNU General Public License (GPL) version 2
	7	*/
	8
	9	#include <linux/stddef.h>
	10	#include <linux/spinlock.h>
	11	#include <linux/slab.h>
	12	#include <linux/crc-ccitt.h>
	13	#include <net/caif/caif_layer.h>
	14	#include <net/caif/cfpkt.h>
	15	#include <net/caif/cffrml.h>
	16
	17	#define container_obj(layr) container_of(layr, struct cffrml, layer)
	18
	19	struct cffrml {
	20	struct cflayer layer;
	21	bool dofcs; /* !< FCS active */
	22	};
	23
	24	static int cffrml_receive(struct cflayer layr, struct cfpkt pkt);
	25	static int cffrml_transmit(struct cflayer layr, struct cfpkt pkt);
	26	static void cffrml_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
	27	int phyid);
	28
	29	static u32 cffrml_rcv_error;
	30	static u32 cffrml_rcv_checsum_error;
	31	struct cflayer *cffrml_create(u16 phyid, bool use_fcs)
	32	{
	33	struct cffrml *this = kmalloc(sizeof(struct cffrml), GFP_ATOMIC);
	34	if (!this) {
	35	pr_warning("CAIF: %s(): Out of memory\n", __func__);
	36	return NULL;
	37	}
	38	caif_assert(offsetof(struct cffrml, layer) == 0);
	39
	40	memset(this, 0, sizeof(struct cflayer));
	41	this->layer.receive = cffrml_receive;
	42	this->layer.transmit = cffrml_transmit;
	43	this->layer.ctrlcmd = cffrml_ctrlcmd;
	44	snprintf(this->layer.name, CAIF_LAYER_NAME_SZ, "frm%d", phyid);
	45	this->dofcs = use_fcs;
	46	this->layer.id = phyid;
	47	return (struct cflayer *) this;
	48	}
	49
	50	void cffrml_set_uplayer(struct cflayer this, struct cflayer up)
	51	{
	52	this->up = up;
	53	}
	54
	55	void cffrml_set_dnlayer(struct cflayer this, struct cflayer dn)
	56	{
	57	this->dn = dn;
	58	}
	59
	60	static u16 cffrml_checksum(u16 chks, void *buf, u16 len)
	61	{
	62	/* FIXME: FCS should be moved to glue in order to use OS-Specific
	63	* solutions
	64	*/
65	return crc_ccitt(chks, buf, len);
66	}
67
68	static int cffrml_receive(struct cflayer layr, struct cfpkt pkt)
69	{
70	u16 tmp;
71	u16 len;
72	u16 hdrchks;
73	u16 pktchks;
74	struct cffrml *this;
75	this = container_obj(layr);
76
77	cfpkt_extr_head(pkt, &tmp, 2);
78	len = le16_to_cpu(tmp);
79
80	/* Subtract for FCS on length if FCS is not used. */
81	if (!this->dofcs)
82	len -= 2;
83
84	if (cfpkt_setlen(pkt, len) < 0) {
85	++cffrml_rcv_error;
86	pr_err("CAIF: %s():Framing length error (%d)\n", __func__, len);
87	cfpkt_destroy(pkt);
88	return -EPROTO;
89	}
90	/*
91	* Don't do extract if FCS is false, rather do setlen - then we don't
92	* get a cache-miss.
93	*/
94	if (this->dofcs) {
95	cfpkt_extr_trail(pkt, &tmp, 2);
96	hdrchks = le16_to_cpu(tmp);
97	pktchks = cfpkt_iterate(pkt, cffrml_checksum, 0xffff);
98	if (pktchks != hdrchks) {
99	cfpkt_add_trail(pkt, &tmp, 2);
100	++cffrml_rcv_error;
101	++cffrml_rcv_checsum_error;
102	pr_info("CAIF: %s(): Frame checksum error "
103	"(0x%x != 0x%x)\n", __func__, hdrchks, pktchks);
104	return -EILSEQ;
105	}
106	}
107	if (cfpkt_erroneous(pkt)) {
108	++cffrml_rcv_error;
109	pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
110	cfpkt_destroy(pkt);
111	return -EPROTO;
112	}
113	return layr->up->receive(layr->up, pkt);
114	}
115
116	static int cffrml_transmit(struct cflayer layr, struct cfpkt pkt)
117	{
118	int tmp;
119	u16 chks;
120	u16 len;
121	int ret;
122	struct cffrml *this = container_obj(layr);
123	if (this->dofcs) {
124	chks = cfpkt_iterate(pkt, cffrml_checksum, 0xffff);
125	tmp = cpu_to_le16(chks);
126	cfpkt_add_trail(pkt, &tmp, 2);
127	} else {
128	cfpkt_pad_trail(pkt, 2);
129	}
130	len = cfpkt_getlen(pkt);
131	tmp = cpu_to_le16(len);
132	cfpkt_add_head(pkt, &tmp, 2);
133	cfpkt_info(pkt)->hdr_len += 2;
134	if (cfpkt_erroneous(pkt)) {
135	pr_err("CAIF: %s(): Packet is erroneous!\n", __func__);
136	return -EPROTO;
137	}
138	ret = layr->dn->transmit(layr->dn, pkt);
139	if (ret < 0) {
140	/* Remove header on faulty packet. */
141	cfpkt_extr_head(pkt, &tmp, 2);
142	}
143	return ret;
144	}
145
146	static void cffrml_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
147	int phyid)
148	{
149	if (layr->up->ctrlcmd)
150	layr->up->ctrlcmd(layr->up, ctrl, layr->id);
151	}