cffrml.c 4.47 KB
Newer Older
1 2 3 4
/*
 * CAIF Framing Layer.
 *
 * Copyright (C) ST-Ericsson AB 2010
5
 * Author:	Sjur Brendeland
6 7 8
 * License terms: GNU General Public License (GPL) version 2
 */

Joe Perches's avatar
Joe Perches committed
9 10
#define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__

11 12 13 14
#include <linux/stddef.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/crc-ccitt.h>
15
#include <linux/netdevice.h>
16 17 18 19 20 21 22 23 24
#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 */
25
	int __percpu		*pcpu_refcnt;
26 27 28 29 30
};

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,
31
			   int phyid);
32 33 34 35 36

static u32 cffrml_rcv_error;
static u32 cffrml_rcv_checsum_error;
struct cflayer *cffrml_create(u16 phyid, bool use_fcs)
{
37 38
	struct cffrml *this = kzalloc(sizeof(struct cffrml), GFP_ATOMIC);
	if (!this)
39
		return NULL;
40 41 42 43 44 45
	this->pcpu_refcnt = alloc_percpu(int);
	if (this->pcpu_refcnt == NULL) {
		kfree(this);
		return NULL;
	}

46 47 48 49 50 51 52 53 54 55 56
	caif_assert(offsetof(struct cffrml, layer) == 0);

	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;
}

57 58 59 60 61 62 63
void cffrml_free(struct cflayer *layer)
{
	struct cffrml *this = container_obj(layer);
	free_percpu(this->pcpu_refcnt);
	kfree(layer);
}

64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
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;
Joe Perches's avatar
Joe Perches committed
100
		pr_err("Framing length error (%d)\n", len);
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
		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;
Joe Perches's avatar
Joe Perches committed
116 117
			pr_info("Frame checksum error (0x%x != 0x%x)\n",
				hdrchks, pktchks);
118 119 120 121 122
			return -EILSEQ;
		}
	}
	if (cfpkt_erroneous(pkt)) {
		++cffrml_rcv_error;
Joe Perches's avatar
Joe Perches committed
123
		pr_err("Packet is erroneous!\n");
124 125 126
		cfpkt_destroy(pkt);
		return -EPROTO;
	}
127 128 129 130 131 132 133

	if (layr->up == NULL) {
		pr_err("Layr up is missing!\n");
		cfpkt_destroy(pkt);
		return -EINVAL;
	}

134 135 136 137 138 139 140
	return layr->up->receive(layr->up, pkt);
}

static int cffrml_transmit(struct cflayer *layr, struct cfpkt *pkt)
{
	u16 chks;
	u16 len;
141 142
	__le16 data;

143 144 145
	struct cffrml *this = container_obj(layr);
	if (this->dofcs) {
		chks = cfpkt_iterate(pkt, cffrml_checksum, 0xffff);
146 147
		data = cpu_to_le16(chks);
		cfpkt_add_trail(pkt, &data, 2);
148 149 150 151
	} else {
		cfpkt_pad_trail(pkt, 2);
	}
	len = cfpkt_getlen(pkt);
152 153
	data = cpu_to_le16(len);
	cfpkt_add_head(pkt, &data, 2);
154 155
	cfpkt_info(pkt)->hdr_len += 2;
	if (cfpkt_erroneous(pkt)) {
Joe Perches's avatar
Joe Perches committed
156
		pr_err("Packet is erroneous!\n");
157
		cfpkt_destroy(pkt);
158 159
		return -EPROTO;
	}
160 161 162 163 164 165

	if (layr->dn == NULL) {
		cfpkt_destroy(pkt);
		return -ENODEV;

	}
166
	return layr->dn->transmit(layr->dn, pkt);
167 168 169
}

static void cffrml_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl,
170
			   int phyid)
171
{
172
	if (layr->up && layr->up->ctrlcmd)
173 174
		layr->up->ctrlcmd(layr->up, ctrl, layr->id);
}
175 176 177

void cffrml_put(struct cflayer *layr)
{
178 179
	struct cffrml *this = container_obj(layr);
	if (layr != NULL && this->pcpu_refcnt != NULL)
180
		this_cpu_dec(*this->pcpu_refcnt);
181 182 183 184
}

void cffrml_hold(struct cflayer *layr)
{
185 186
	struct cffrml *this = container_obj(layr);
	if (layr != NULL && this->pcpu_refcnt != NULL)
187
		this_cpu_inc(*this->pcpu_refcnt);
188 189 190 191 192 193 194 195 196
}

int cffrml_refcnt_read(struct cflayer *layr)
{
	int i, refcnt = 0;
	struct cffrml *this = container_obj(layr);
	for_each_possible_cpu(i)
		refcnt += *per_cpu_ptr(this->pcpu_refcnt, i);
	return refcnt;
197
}