caif_hsi.c 34.2 KB
Newer Older
1 2 3 4 5 6 7 8
/*
 * Copyright (C) ST-Ericsson AB 2010
 * Contact: Sjur Brendeland / sjur.brandeland@stericsson.com
 * Author:  Daniel Martensson / daniel.martensson@stericsson.com
 *	    Dmitry.Tarnyagin  / dmitry.tarnyagin@stericsson.com
 * License terms: GNU General Public License (GPL) version 2.
 */

9 10
#define pr_fmt(fmt) KBUILD_MODNAME fmt

11 12 13 14 15 16 17 18 19 20 21 22
#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/netdevice.h>
#include <linux/string.h>
#include <linux/list.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/if_arp.h>
#include <linux/timer.h>
23
#include <linux/rtnetlink.h>
24
#include <linux/pkt_sched.h>
25 26 27 28 29 30 31 32 33 34 35
#include <net/caif/caif_layer.h>
#include <net/caif/caif_hsi.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Daniel Martensson<daniel.martensson@stericsson.com>");
MODULE_DESCRIPTION("CAIF HSI driver");

/* Returns the number of padding bytes for alignment. */
#define PAD_POW2(x, pow) ((((x)&((pow)-1)) == 0) ? 0 :\
				(((pow)-((x)&((pow)-1)))))

36 37 38 39
static int inactivity_timeout = 1000;
module_param(inactivity_timeout, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(inactivity_timeout, "Inactivity timeout on HSI, ms.");

40 41 42 43
static int aggregation_timeout = 1;
module_param(aggregation_timeout, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(aggregation_timeout, "Aggregation timeout on HSI, ms.");

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
/*
 * HSI padding options.
 * Warning: must be a base of 2 (& operation used) and can not be zero !
 */
static int hsi_head_align = 4;
module_param(hsi_head_align, int, S_IRUGO);
MODULE_PARM_DESC(hsi_head_align, "HSI head alignment.");

static int hsi_tail_align = 4;
module_param(hsi_tail_align, int, S_IRUGO);
MODULE_PARM_DESC(hsi_tail_align, "HSI tail alignment.");

/*
 * HSI link layer flowcontrol thresholds.
 * Warning: A high threshold value migth increase throughput but it will at
 * the same time prevent channel prioritization and increase the risk of
 * flooding the modem. The high threshold should be above the low.
 */
static int hsi_high_threshold = 100;
module_param(hsi_high_threshold, int, S_IRUGO);
MODULE_PARM_DESC(hsi_high_threshold, "HSI high threshold (FLOW OFF).");

static int hsi_low_threshold = 50;
module_param(hsi_low_threshold, int, S_IRUGO);
MODULE_PARM_DESC(hsi_low_threshold, "HSI high threshold (FLOW ON).");

#define ON 1
#define OFF 0

/*
 * Threshold values for the HSI packet queue. Flowcontrol will be asserted
 * when the number of packets exceeds HIGH_WATER_MARK. It will not be
 * de-asserted before the number of packets drops below LOW_WATER_MARK.
 */
#define LOW_WATER_MARK   hsi_low_threshold
#define HIGH_WATER_MARK  hsi_high_threshold

static LIST_HEAD(cfhsi_list);
static spinlock_t cfhsi_list_lock;

static void cfhsi_inactivity_tout(unsigned long arg)
{
	struct cfhsi *cfhsi = (struct cfhsi *)arg;

88
	netdev_dbg(cfhsi->ndev, "%s.\n",
89 90 91 92 93 94 95
		__func__);

	/* Schedule power down work queue. */
	if (!test_bit(CFHSI_SHUTDOWN, &cfhsi->bits))
		queue_work(cfhsi->wq, &cfhsi->wake_down_work);
}

96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
static void cfhsi_update_aggregation_stats(struct cfhsi *cfhsi,
					   const struct sk_buff *skb,
					   int direction)
{
	struct caif_payload_info *info;
	int hpad, tpad, len;

	info = (struct caif_payload_info *)&skb->cb;
	hpad = 1 + PAD_POW2((info->hdr_len + 1), hsi_head_align);
	tpad = PAD_POW2((skb->len + hpad), hsi_tail_align);
	len = skb->len + hpad + tpad;

	if (direction > 0)
		cfhsi->aggregation_len += len;
	else if (direction < 0)
		cfhsi->aggregation_len -= len;
}

static bool cfhsi_can_send_aggregate(struct cfhsi *cfhsi)
{
	int i;

118
	if (cfhsi->aggregation_timeout == 0)
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
		return true;

	for (i = 0; i < CFHSI_PRIO_BEBK; ++i) {
		if (cfhsi->qhead[i].qlen)
			return true;
	}

	/* TODO: Use aggregation_len instead */
	if (cfhsi->qhead[CFHSI_PRIO_BEBK].qlen >= CFHSI_MAX_PKTS)
		return true;

	return false;
}

static struct sk_buff *cfhsi_dequeue(struct cfhsi *cfhsi)
{
	struct sk_buff *skb;
	int i;

	for (i = 0; i < CFHSI_PRIO_LAST; ++i) {
		skb = skb_dequeue(&cfhsi->qhead[i]);
		if (skb)
			break;
	}

	return skb;
}

static int cfhsi_tx_queue_len(struct cfhsi *cfhsi)
{
	int i, len = 0;
	for (i = 0; i < CFHSI_PRIO_LAST; ++i)
		len += skb_queue_len(&cfhsi->qhead[i]);
	return len;
}

155 156 157 158 159 160
static void cfhsi_abort_tx(struct cfhsi *cfhsi)
{
	struct sk_buff *skb;

	for (;;) {
		spin_lock_bh(&cfhsi->lock);
161
		skb = cfhsi_dequeue(cfhsi);
162 163 164 165 166
		if (!skb)
			break;

		cfhsi->ndev->stats.tx_errors++;
		cfhsi->ndev->stats.tx_dropped++;
167
		cfhsi_update_aggregation_stats(cfhsi, skb, -1);
168 169 170 171 172
		spin_unlock_bh(&cfhsi->lock);
		kfree_skb(skb);
	}
	cfhsi->tx_state = CFHSI_TX_STATE_IDLE;
	if (!test_bit(CFHSI_SHUTDOWN, &cfhsi->bits))
173
		mod_timer(&cfhsi->inactivity_timer,
174
			jiffies + cfhsi->inactivity_timeout);
175 176 177 178 179 180 181 182 183
	spin_unlock_bh(&cfhsi->lock);
}

static int cfhsi_flush_fifo(struct cfhsi *cfhsi)
{
	char buffer[32]; /* Any reasonable value */
	size_t fifo_occupancy;
	int ret;

184
	netdev_dbg(cfhsi->ndev, "%s.\n",
185 186 187 188 189 190
		__func__);

	do {
		ret = cfhsi->dev->cfhsi_fifo_occupancy(cfhsi->dev,
				&fifo_occupancy);
		if (ret) {
191
			netdev_warn(cfhsi->ndev,
192 193 194 195 196 197 198 199 200 201 202 203 204
				"%s: can't get FIFO occupancy: %d.\n",
				__func__, ret);
			break;
		} else if (!fifo_occupancy)
			/* No more data, exitting normally */
			break;

		fifo_occupancy = min(sizeof(buffer), fifo_occupancy);
		set_bit(CFHSI_FLUSH_FIFO, &cfhsi->bits);
		ret = cfhsi->dev->cfhsi_rx(buffer, fifo_occupancy,
				cfhsi->dev);
		if (ret) {
			clear_bit(CFHSI_FLUSH_FIFO, &cfhsi->bits);
205
			netdev_warn(cfhsi->ndev,
206 207 208 209 210 211
				"%s: can't read data: %d.\n",
				__func__, ret);
			break;
		}

		ret = 5 * HZ;
212
		ret = wait_event_interruptible_timeout(cfhsi->flush_fifo_wait,
213 214 215
			 !test_bit(CFHSI_FLUSH_FIFO, &cfhsi->bits), ret);

		if (ret < 0) {
216
			netdev_warn(cfhsi->ndev,
217 218 219 220 221
				"%s: can't wait for flush complete: %d.\n",
				__func__, ret);
			break;
		} else if (!ret) {
			ret = -ETIMEDOUT;
222
			netdev_warn(cfhsi->ndev,
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
				"%s: timeout waiting for flush complete.\n",
				__func__);
			break;
		}
	} while (1);

	return ret;
}

static int cfhsi_tx_frm(struct cfhsi_desc *desc, struct cfhsi *cfhsi)
{
	int nfrms = 0;
	int pld_len = 0;
	struct sk_buff *skb;
	u8 *pfrm = desc->emb_frm + CFHSI_MAX_EMB_FRM_SZ;

239
	skb = cfhsi_dequeue(cfhsi);
240 241 242
	if (!skb)
		return 0;

243 244 245
	/* Clear offset. */
	desc->offset = 0;

246 247 248
	/* Check if we can embed a CAIF frame. */
	if (skb->len < CFHSI_MAX_EMB_FRM_SZ) {
		struct caif_payload_info *info;
249 250
		int hpad;
		int tpad;
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265

		/* Calculate needed head alignment and tail alignment. */
		info = (struct caif_payload_info *)&skb->cb;

		hpad = 1 + PAD_POW2((info->hdr_len + 1), hsi_head_align);
		tpad = PAD_POW2((skb->len + hpad), hsi_tail_align);

		/* Check if frame still fits with added alignment. */
		if ((skb->len + hpad + tpad) <= CFHSI_MAX_EMB_FRM_SZ) {
			u8 *pemb = desc->emb_frm;
			desc->offset = CFHSI_DESC_SHORT_SZ;
			*pemb = (u8)(hpad - 1);
			pemb += hpad;

			/* Update network statistics. */
266
			spin_lock_bh(&cfhsi->lock);
267 268
			cfhsi->ndev->stats.tx_packets++;
			cfhsi->ndev->stats.tx_bytes += skb->len;
269 270
			cfhsi_update_aggregation_stats(cfhsi, skb, -1);
			spin_unlock_bh(&cfhsi->lock);
271 272 273

			/* Copy in embedded CAIF frame. */
			skb_copy_bits(skb, 0, pemb, skb->len);
274 275

			/* Consume the SKB */
276 277 278
			consume_skb(skb);
			skb = NULL;
		}
279
	}
280 281 282 283 284

	/* Create payload CAIF frames. */
	pfrm = desc->emb_frm + CFHSI_MAX_EMB_FRM_SZ;
	while (nfrms < CFHSI_MAX_PKTS) {
		struct caif_payload_info *info;
285 286
		int hpad;
		int tpad;
287 288

		if (!skb)
289
			skb = cfhsi_dequeue(cfhsi);
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307

		if (!skb)
			break;

		/* Calculate needed head alignment and tail alignment. */
		info = (struct caif_payload_info *)&skb->cb;

		hpad = 1 + PAD_POW2((info->hdr_len + 1), hsi_head_align);
		tpad = PAD_POW2((skb->len + hpad), hsi_tail_align);

		/* Fill in CAIF frame length in descriptor. */
		desc->cffrm_len[nfrms] = hpad + skb->len + tpad;

		/* Fill head padding information. */
		*pfrm = (u8)(hpad - 1);
		pfrm += hpad;

		/* Update network statistics. */
308
		spin_lock_bh(&cfhsi->lock);
309 310
		cfhsi->ndev->stats.tx_packets++;
		cfhsi->ndev->stats.tx_bytes += skb->len;
311 312
		cfhsi_update_aggregation_stats(cfhsi, skb, -1);
		spin_unlock_bh(&cfhsi->lock);
313 314 315 316 317 318 319 320 321

		/* Copy in CAIF frame. */
		skb_copy_bits(skb, 0, pfrm, skb->len);

		/* Update payload length. */
		pld_len += desc->cffrm_len[nfrms];

		/* Update frame pointer. */
		pfrm += skb->len + tpad;
322 323

		/* Consume the SKB */
324 325 326 327 328 329 330 331 332 333 334 335 336 337
		consume_skb(skb);
		skb = NULL;

		/* Update number of frames. */
		nfrms++;
	}

	/* Unused length fields should be zero-filled (according to SPEC). */
	while (nfrms < CFHSI_MAX_PKTS) {
		desc->cffrm_len[nfrms] = 0x0000;
		nfrms++;
	}

	/* Check if we can piggy-back another descriptor. */
338
	if (cfhsi_can_send_aggregate(cfhsi))
339 340 341 342 343 344 345
		desc->header |= CFHSI_PIGGY_DESC;
	else
		desc->header &= ~CFHSI_PIGGY_DESC;

	return CFHSI_DESC_SZ + pld_len;
}

346
static void cfhsi_start_tx(struct cfhsi *cfhsi)
347
{
348 349
	struct cfhsi_desc *desc = (struct cfhsi_desc *)cfhsi->tx_buf;
	int len, res;
350

351
	netdev_dbg(cfhsi->ndev, "%s.\n", __func__);
352 353 354 355 356 357

	if (test_bit(CFHSI_SHUTDOWN, &cfhsi->bits))
		return;

	do {
		/* Create HSI frame. */
358 359 360 361
		len = cfhsi_tx_frm(desc, cfhsi);
		if (!len) {
			spin_lock_bh(&cfhsi->lock);
			if (unlikely(cfhsi_tx_queue_len(cfhsi))) {
362
				spin_unlock_bh(&cfhsi->lock);
363 364
				res = -EAGAIN;
				continue;
365
			}
366 367 368 369 370 371 372
			cfhsi->tx_state = CFHSI_TX_STATE_IDLE;
			/* Start inactivity timer. */
			mod_timer(&cfhsi->inactivity_timer,
				jiffies + cfhsi->inactivity_timeout);
			spin_unlock_bh(&cfhsi->lock);
			break;
		}
373 374 375

		/* Set up new transfer. */
		res = cfhsi->dev->cfhsi_tx(cfhsi->tx_buf, len, cfhsi->dev);
376
		if (WARN_ON(res < 0))
377
			netdev_err(cfhsi->ndev, "%s: TX error %d.\n",
378 379
				__func__, res);
	} while (res < 0);
380 381 382 383
}

static void cfhsi_tx_done(struct cfhsi *cfhsi)
{
384
	netdev_dbg(cfhsi->ndev, "%s.\n", __func__);
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409

	if (test_bit(CFHSI_SHUTDOWN, &cfhsi->bits))
		return;

	/*
	 * Send flow on if flow off has been previously signalled
	 * and number of packets is below low water mark.
	 */
	spin_lock_bh(&cfhsi->lock);
	if (cfhsi->flow_off_sent &&
			cfhsi_tx_queue_len(cfhsi) <= cfhsi->q_low_mark &&
			cfhsi->cfdev.flowctrl) {

		cfhsi->flow_off_sent = 0;
		cfhsi->cfdev.flowctrl(cfhsi->ndev, ON);
	}

	if (cfhsi_can_send_aggregate(cfhsi)) {
		spin_unlock_bh(&cfhsi->lock);
		cfhsi_start_tx(cfhsi);
	} else {
		mod_timer(&cfhsi->aggregation_timer,
			jiffies + cfhsi->aggregation_timeout);
		spin_unlock_bh(&cfhsi->lock);
	}
410 411

	return;
412 413 414 415 416 417 418
}

static void cfhsi_tx_done_cb(struct cfhsi_drv *drv)
{
	struct cfhsi *cfhsi;

	cfhsi = container_of(drv, struct cfhsi, drv);
419
	netdev_dbg(cfhsi->ndev, "%s.\n",
420 421 422 423
		__func__);

	if (test_bit(CFHSI_SHUTDOWN, &cfhsi->bits))
		return;
424
	cfhsi_tx_done(cfhsi);
425 426
}

427
static int cfhsi_rx_desc(struct cfhsi_desc *desc, struct cfhsi *cfhsi)
428 429 430 431 432 433 434 435
{
	int xfer_sz = 0;
	int nfrms = 0;
	u16 *plen = NULL;
	u8 *pfrm = NULL;

	if ((desc->header & ~CFHSI_PIGGY_DESC) ||
			(desc->offset > CFHSI_MAX_EMB_FRM_SZ)) {
436
		netdev_err(cfhsi->ndev, "%s: Invalid descriptor.\n",
437
			__func__);
438
		return -EPROTO;
439 440 441 442 443 444
	}

	/* Check for embedded CAIF frame. */
	if (desc->offset) {
		struct sk_buff *skb;
		u8 *dst = NULL;
445
		int len = 0;
446 447 448 449 450 451 452 453 454 455
		pfrm = ((u8 *)desc) + desc->offset;

		/* Remove offset padding. */
		pfrm += *pfrm + 1;

		/* Read length of CAIF frame (little endian). */
		len = *pfrm;
		len |= ((*(pfrm+1)) << 8) & 0xFF00;
		len += 2;	/* Add FCS fields. */

456 457
		/* Sanity check length of CAIF frame. */
		if (unlikely(len > CFHSI_MAX_CAIF_FRAME_SZ)) {
458
			netdev_err(cfhsi->ndev, "%s: Invalid length.\n",
459 460 461
				__func__);
			return -EPROTO;
		}
462 463

		/* Allocate SKB (OK even in IRQ context). */
464 465
		skb = alloc_skb(len + 1, GFP_ATOMIC);
		if (!skb) {
466
			netdev_err(cfhsi->ndev, "%s: Out of memory !\n",
467 468
				__func__);
			return -ENOMEM;
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
		}
		caif_assert(skb != NULL);

		dst = skb_put(skb, len);
		memcpy(dst, pfrm, len);

		skb->protocol = htons(ETH_P_CAIF);
		skb_reset_mac_header(skb);
		skb->dev = cfhsi->ndev;

		/*
		 * We are called from a arch specific platform device.
		 * Unfortunately we don't know what context we're
		 * running in.
		 */
		if (in_interrupt())
			netif_rx(skb);
		else
			netif_rx_ni(skb);

		/* Update network statistics. */
		cfhsi->ndev->stats.rx_packets++;
		cfhsi->ndev->stats.rx_bytes += len;
	}

	/* Calculate transfer length. */
	plen = desc->cffrm_len;
	while (nfrms < CFHSI_MAX_PKTS && *plen) {
		xfer_sz += *plen;
		plen++;
		nfrms++;
	}

	/* Check for piggy-backed descriptor. */
	if (desc->header & CFHSI_PIGGY_DESC)
		xfer_sz += CFHSI_DESC_SZ;

506
	if ((xfer_sz % 4) || (xfer_sz > (CFHSI_BUF_SZ_RX - CFHSI_DESC_SZ))) {
507
		netdev_err(cfhsi->ndev,
508 509
				"%s: Invalid payload len: %d, ignored.\n",
			__func__, xfer_sz);
510
		return -EPROTO;
511 512 513 514
	}
	return xfer_sz;
}

515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
static int cfhsi_rx_desc_len(struct cfhsi_desc *desc)
{
	int xfer_sz = 0;
	int nfrms = 0;
	u16 *plen;

	if ((desc->header & ~CFHSI_PIGGY_DESC) ||
			(desc->offset > CFHSI_MAX_EMB_FRM_SZ)) {

		pr_err("Invalid descriptor. %x %x\n", desc->header,
				desc->offset);
		return -EPROTO;
	}

	/* Calculate transfer length. */
	plen = desc->cffrm_len;
	while (nfrms < CFHSI_MAX_PKTS && *plen) {
		xfer_sz += *plen;
		plen++;
		nfrms++;
	}

	if (xfer_sz % 4) {
		pr_err("Invalid payload len: %d, ignored.\n", xfer_sz);
		return -EPROTO;
	}
	return xfer_sz;
}

544
static int cfhsi_rx_pld(struct cfhsi_desc *desc, struct cfhsi *cfhsi)
545 546 547 548 549 550 551 552 553
{
	int rx_sz = 0;
	int nfrms = 0;
	u16 *plen = NULL;
	u8 *pfrm = NULL;

	/* Sanity check header and offset. */
	if (WARN_ON((desc->header & ~CFHSI_PIGGY_DESC) ||
			(desc->offset > CFHSI_MAX_EMB_FRM_SZ))) {
554
		netdev_err(cfhsi->ndev, "%s: Invalid descriptor.\n",
555
			__func__);
556
		return -EPROTO;
557 558 559 560 561
	}

	/* Set frame pointer to start of payload. */
	pfrm = desc->emb_frm + CFHSI_MAX_EMB_FRM_SZ;
	plen = desc->cffrm_len;
562 563 564 565 566 567 568 569 570 571

	/* Skip already processed frames. */
	while (nfrms < cfhsi->rx_state.nfrms) {
		pfrm += *plen;
		rx_sz += *plen;
		plen++;
		nfrms++;
	}

	/* Parse payload. */
572 573 574 575
	while (nfrms < CFHSI_MAX_PKTS && *plen) {
		struct sk_buff *skb;
		u8 *dst = NULL;
		u8 *pcffrm = NULL;
576
		int len;
577 578 579 580 581 582 583 584 585

		/* CAIF frame starts after head padding. */
		pcffrm = pfrm + *pfrm + 1;

		/* Read length of CAIF frame (little endian). */
		len = *pcffrm;
		len |= ((*(pcffrm + 1)) << 8) & 0xFF00;
		len += 2;	/* Add FCS fields. */

586 587
		/* Sanity check length of CAIF frames. */
		if (unlikely(len > CFHSI_MAX_CAIF_FRAME_SZ)) {
588
			netdev_err(cfhsi->ndev, "%s: Invalid length.\n",
589 590 591 592
				__func__);
			return -EPROTO;
		}

593
		/* Allocate SKB (OK even in IRQ context). */
594 595
		skb = alloc_skb(len + 1, GFP_ATOMIC);
		if (!skb) {
596
			netdev_err(cfhsi->ndev, "%s: Out of memory !\n",
597 598 599
				__func__);
			cfhsi->rx_state.nfrms = nfrms;
			return -ENOMEM;
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
		}
		caif_assert(skb != NULL);

		dst = skb_put(skb, len);
		memcpy(dst, pcffrm, len);

		skb->protocol = htons(ETH_P_CAIF);
		skb_reset_mac_header(skb);
		skb->dev = cfhsi->ndev;

		/*
		 * We're called from a platform device,
		 * and don't know the context we're running in.
		 */
		if (in_interrupt())
			netif_rx(skb);
		else
			netif_rx_ni(skb);

		/* Update network statistics. */
		cfhsi->ndev->stats.rx_packets++;
		cfhsi->ndev->stats.rx_bytes += len;

		pfrm += *plen;
		rx_sz += *plen;
		plen++;
		nfrms++;
	}

	return rx_sz;
}

632
static void cfhsi_rx_done(struct cfhsi *cfhsi)
633 634
{
	int res;
635
	int desc_pld_len = 0, rx_len, rx_state;
636
	struct cfhsi_desc *desc = NULL;
637 638
	u8 *rx_ptr, *rx_buf;
	struct cfhsi_desc *piggy_desc = NULL;
639 640 641

	desc = (struct cfhsi_desc *)cfhsi->rx_buf;

642
	netdev_dbg(cfhsi->ndev, "%s\n", __func__);
643 644 645 646 647

	if (test_bit(CFHSI_SHUTDOWN, &cfhsi->bits))
		return;

	/* Update inactivity timer if pending. */
648
	spin_lock_bh(&cfhsi->lock);
649
	mod_timer_pending(&cfhsi->inactivity_timer,
650
			jiffies + cfhsi->inactivity_timeout);
651
	spin_unlock_bh(&cfhsi->lock);
652

653
	if (cfhsi->rx_state.state == CFHSI_RX_STATE_DESC) {
654 655 656
		desc_pld_len = cfhsi_rx_desc_len(desc);

		if (desc_pld_len < 0)
657
			goto out_of_sync;
658 659 660 661 662 663 664

		rx_buf = cfhsi->rx_buf;
		rx_len = desc_pld_len;
		if (desc_pld_len > 0 && (desc->header & CFHSI_PIGGY_DESC))
			rx_len += CFHSI_DESC_SZ;
		if (desc_pld_len == 0)
			rx_buf = cfhsi->rx_flip_buf;
665
	} else {
666
		rx_buf = cfhsi->rx_flip_buf;
667

668 669 670
		rx_len = CFHSI_DESC_SZ;
		if (cfhsi->rx_state.pld_len > 0 &&
				(desc->header & CFHSI_PIGGY_DESC)) {
671 672 673

			piggy_desc = (struct cfhsi_desc *)
				(desc->emb_frm + CFHSI_MAX_EMB_FRM_SZ +
674 675
						cfhsi->rx_state.pld_len);

676
			cfhsi->rx_state.piggy_desc = true;
677

678 679 680 681 682
			/* Extract payload len from piggy-backed descriptor. */
			desc_pld_len = cfhsi_rx_desc_len(piggy_desc);
			if (desc_pld_len < 0)
				goto out_of_sync;

683
			if (desc_pld_len > 0) {
684
				rx_len = desc_pld_len;
685 686 687
				if (piggy_desc->header & CFHSI_PIGGY_DESC)
					rx_len += CFHSI_DESC_SZ;
			}
688 689 690 691 692

			/*
			 * Copy needed information from the piggy-backed
			 * descriptor to the descriptor in the start.
			 */
693
			memcpy(rx_buf, (u8 *)piggy_desc,
694
					CFHSI_DESC_SHORT_SZ);
695 696
			/* Mark no embedded frame here */
			piggy_desc->offset = 0;
697
		}
698 699
	}

700
	if (desc_pld_len) {
701 702
		rx_state = CFHSI_RX_STATE_PAYLOAD;
		rx_ptr = rx_buf + CFHSI_DESC_SZ;
703
	} else {
704 705 706
		rx_state = CFHSI_RX_STATE_DESC;
		rx_ptr = rx_buf;
		rx_len = CFHSI_DESC_SZ;
707 708
	}

709
	/* Initiate next read */
710 711
	if (test_bit(CFHSI_AWAKE, &cfhsi->bits)) {
		/* Set up new transfer. */
712
		netdev_dbg(cfhsi->ndev, "%s: Start RX.\n",
713 714 715
				__func__);

		res = cfhsi->dev->cfhsi_rx(rx_ptr, rx_len,
716 717
				cfhsi->dev);
		if (WARN_ON(res < 0)) {
718
			netdev_err(cfhsi->ndev, "%s: RX error %d.\n",
719 720 721 722 723
				__func__, res);
			cfhsi->ndev->stats.rx_errors++;
			cfhsi->ndev->stats.rx_dropped++;
		}
	}
724

725 726 727 728 729 730 731 732 733 734 735 736 737
	if (cfhsi->rx_state.state == CFHSI_RX_STATE_DESC) {
		/* Extract payload from descriptor */
		if (cfhsi_rx_desc(desc, cfhsi) < 0)
			goto out_of_sync;
	} else {
		/* Extract payload */
		if (cfhsi_rx_pld(desc, cfhsi) < 0)
			goto out_of_sync;
		if (piggy_desc) {
			/* Extract any payload in piggyback descriptor. */
			if (cfhsi_rx_desc(piggy_desc, cfhsi) < 0)
				goto out_of_sync;
		}
738
	}
739 740 741 742 743 744 745 746 747 748 749

	/* Update state info */
	memset(&cfhsi->rx_state, 0, sizeof(cfhsi->rx_state));
	cfhsi->rx_state.state = rx_state;
	cfhsi->rx_ptr = rx_ptr;
	cfhsi->rx_len = rx_len;
	cfhsi->rx_state.pld_len = desc_pld_len;
	cfhsi->rx_state.piggy_desc = desc->header & CFHSI_PIGGY_DESC;

	if (rx_buf != cfhsi->rx_buf)
		swap(cfhsi->rx_buf, cfhsi->rx_flip_buf);
750 751 752
	return;

out_of_sync:
753
	netdev_err(cfhsi->ndev, "%s: Out of sync.\n", __func__);
754 755 756
	print_hex_dump_bytes("--> ", DUMP_PREFIX_NONE,
			cfhsi->rx_buf, CFHSI_DESC_SZ);
	schedule_work(&cfhsi->out_of_sync_work);
757 758 759 760 761 762
}

static void cfhsi_rx_slowpath(unsigned long arg)
{
	struct cfhsi *cfhsi = (struct cfhsi *)arg;

763
	netdev_dbg(cfhsi->ndev, "%s.\n",
764 765 766
		__func__);

	cfhsi_rx_done(cfhsi);
767 768 769 770 771 772 773
}

static void cfhsi_rx_done_cb(struct cfhsi_drv *drv)
{
	struct cfhsi *cfhsi;

	cfhsi = container_of(drv, struct cfhsi, drv);
774
	netdev_dbg(cfhsi->ndev, "%s.\n",
775 776 777 778 779 780 781 782
		__func__);

	if (test_bit(CFHSI_SHUTDOWN, &cfhsi->bits))
		return;

	if (test_and_clear_bit(CFHSI_FLUSH_FIFO, &cfhsi->bits))
		wake_up_interruptible(&cfhsi->flush_fifo_wait);
	else
783
		cfhsi_rx_done(cfhsi);
784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
}

static void cfhsi_wake_up(struct work_struct *work)
{
	struct cfhsi *cfhsi = NULL;
	int res;
	int len;
	long ret;

	cfhsi = container_of(work, struct cfhsi, wake_up_work);

	if (test_bit(CFHSI_SHUTDOWN, &cfhsi->bits))
		return;

	if (unlikely(test_bit(CFHSI_AWAKE, &cfhsi->bits))) {
		/* It happenes when wakeup is requested by
		 * both ends at the same time. */
		clear_bit(CFHSI_WAKE_UP, &cfhsi->bits);
802
		clear_bit(CFHSI_WAKE_UP_ACK, &cfhsi->bits);
803 804 805 806 807 808
		return;
	}

	/* Activate wake line. */
	cfhsi->dev->cfhsi_wake_up(cfhsi->dev);

809
	netdev_dbg(cfhsi->ndev, "%s: Start waiting.\n",
810 811 812
		__func__);

	/* Wait for acknowledge. */
813 814 815
	ret = CFHSI_WAKE_TOUT;
	ret = wait_event_interruptible_timeout(cfhsi->wake_up_wait,
					test_and_clear_bit(CFHSI_WAKE_UP_ACK,
816 817 818
							&cfhsi->bits), ret);
	if (unlikely(ret < 0)) {
		/* Interrupted by signal. */
819
		netdev_err(cfhsi->ndev, "%s: Signalled: %ld.\n",
820
			__func__, ret);
821

822 823 824 825
		clear_bit(CFHSI_WAKE_UP, &cfhsi->bits);
		cfhsi->dev->cfhsi_wake_down(cfhsi->dev);
		return;
	} else if (!ret) {
826 827 828
		bool ca_wake = false;
		size_t fifo_occupancy = 0;

829
		/* Wakeup timeout */
830
		netdev_dbg(cfhsi->ndev, "%s: Timeout.\n",
831
			__func__);
832 833 834 835 836

		/* Check FIFO to check if modem has sent something. */
		WARN_ON(cfhsi->dev->cfhsi_fifo_occupancy(cfhsi->dev,
					&fifo_occupancy));

837
		netdev_dbg(cfhsi->ndev, "%s: Bytes in FIFO: %u.\n",
838 839 840 841 842 843 844
				__func__, (unsigned) fifo_occupancy);

		/* Check if we misssed the interrupt. */
		WARN_ON(cfhsi->dev->cfhsi_get_peer_wake(cfhsi->dev,
							&ca_wake));

		if (ca_wake) {
845
			netdev_err(cfhsi->ndev, "%s: CA Wake missed !.\n",
846 847 848 849 850 851 852 853 854
				__func__);

			/* Clear the CFHSI_WAKE_UP_ACK bit to prevent race. */
			clear_bit(CFHSI_WAKE_UP_ACK, &cfhsi->bits);

			/* Continue execution. */
			goto wake_ack;
		}

855 856 857 858
		clear_bit(CFHSI_WAKE_UP, &cfhsi->bits);
		cfhsi->dev->cfhsi_wake_down(cfhsi->dev);
		return;
	}
859
wake_ack:
860
	netdev_dbg(cfhsi->ndev, "%s: Woken.\n",
861 862 863 864 865 866 867
		__func__);

	/* Clear power up bit. */
	set_bit(CFHSI_AWAKE, &cfhsi->bits);
	clear_bit(CFHSI_WAKE_UP, &cfhsi->bits);

	/* Resume read operation. */
868
	netdev_dbg(cfhsi->ndev, "%s: Start RX.\n", __func__);
869 870 871
	res = cfhsi->dev->cfhsi_rx(cfhsi->rx_ptr, cfhsi->rx_len, cfhsi->dev);

	if (WARN_ON(res < 0))
872
		netdev_err(cfhsi->ndev, "%s: RX err %d.\n", __func__, res);
873 874 875 876 877 878

	/* Clear power up acknowledment. */
	clear_bit(CFHSI_WAKE_UP_ACK, &cfhsi->bits);

	spin_lock_bh(&cfhsi->lock);

879 880
	/* Resume transmit if queues are not empty. */
	if (!cfhsi_tx_queue_len(cfhsi)) {
881
		netdev_dbg(cfhsi->ndev, "%s: Peer wake, start timer.\n",
882 883
			__func__);
		/* Start inactivity timer. */
884
		mod_timer(&cfhsi->inactivity_timer,
885
				jiffies + cfhsi->inactivity_timeout);
886 887 888 889
		spin_unlock_bh(&cfhsi->lock);
		return;
	}

890
	netdev_dbg(cfhsi->ndev, "%s: Host wake.\n",
891 892 893 894 895 896 897 898 899 900 901
		__func__);

	spin_unlock_bh(&cfhsi->lock);

	/* Create HSI frame. */
	len = cfhsi_tx_frm((struct cfhsi_desc *)cfhsi->tx_buf, cfhsi);

	if (likely(len > 0)) {
		/* Set up new transfer. */
		res = cfhsi->dev->cfhsi_tx(cfhsi->tx_buf, len, cfhsi->dev);
		if (WARN_ON(res < 0)) {
902
			netdev_err(cfhsi->ndev, "%s: TX error %d.\n",
903 904 905 906
				__func__, res);
			cfhsi_abort_tx(cfhsi);
		}
	} else {
907
		netdev_err(cfhsi->ndev,
908 909 910 911 912 913 914 915 916
				"%s: Failed to create HSI frame: %d.\n",
				__func__, len);
	}
}

static void cfhsi_wake_down(struct work_struct *work)
{
	long ret;
	struct cfhsi *cfhsi = NULL;
917 918
	size_t fifo_occupancy = 0;
	int retry = CFHSI_WAKE_TOUT;
919 920

	cfhsi = container_of(work, struct cfhsi, wake_down_work);
921
	netdev_dbg(cfhsi->ndev, "%s.\n", __func__);
922 923 924 925 926 927 928 929

	if (test_bit(CFHSI_SHUTDOWN, &cfhsi->bits))
		return;

	/* Deactivate wake line. */
	cfhsi->dev->cfhsi_wake_down(cfhsi->dev);

	/* Wait for acknowledge. */
930
	ret = CFHSI_WAKE_TOUT;
931
	ret = wait_event_interruptible_timeout(cfhsi->wake_down_wait,
932 933
					test_and_clear_bit(CFHSI_WAKE_DOWN_ACK,
							&cfhsi->bits), ret);
934 935
	if (ret < 0) {
		/* Interrupted by signal. */
936
		netdev_err(cfhsi->ndev, "%s: Signalled: %ld.\n",
937 938 939
			__func__, ret);
		return;
	} else if (!ret) {
940 941
		bool ca_wake = true;

942
		/* Timeout */
943
		netdev_err(cfhsi->ndev, "%s: Timeout.\n", __func__);
944 945 946 947 948

		/* Check if we misssed the interrupt. */
		WARN_ON(cfhsi->dev->cfhsi_get_peer_wake(cfhsi->dev,
							&ca_wake));
		if (!ca_wake)
949
			netdev_err(cfhsi->ndev, "%s: CA Wake missed !.\n",
950
				__func__);
951 952
	}

953 954 955 956 957 958 959 960 961 962 963 964 965 966
	/* Check FIFO occupancy. */
	while (retry) {
		WARN_ON(cfhsi->dev->cfhsi_fifo_occupancy(cfhsi->dev,
							&fifo_occupancy));

		if (!fifo_occupancy)
			break;

		set_current_state(TASK_INTERRUPTIBLE);
		schedule_timeout(1);
		retry--;
	}

	if (!retry)
967
		netdev_err(cfhsi->ndev, "%s: FIFO Timeout.\n", __func__);
968 969

	/* Clear AWAKE condition. */
970 971
	clear_bit(CFHSI_AWAKE, &cfhsi->bits);

972 973
	/* Cancel pending RX requests. */
	cfhsi->dev->cfhsi_rx_cancel(cfhsi->dev);
974 975 976

}

977 978 979 980 981 982 983 984 985 986 987
static void cfhsi_out_of_sync(struct work_struct *work)
{
	struct cfhsi *cfhsi = NULL;

	cfhsi = container_of(work, struct cfhsi, out_of_sync_work);

	rtnl_lock();
	dev_close(cfhsi->ndev);
	rtnl_unlock();
}

988 989 990 991 992
static void cfhsi_wake_up_cb(struct cfhsi_drv *drv)
{
	struct cfhsi *cfhsi = NULL;

	cfhsi = container_of(drv, struct cfhsi, drv);
993
	netdev_dbg(cfhsi->ndev, "%s.\n",
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
		__func__);

	set_bit(CFHSI_WAKE_UP_ACK, &cfhsi->bits);
	wake_up_interruptible(&cfhsi->wake_up_wait);

	if (test_bit(CFHSI_SHUTDOWN, &cfhsi->bits))
		return;

	/* Schedule wake up work queue if the peer initiates. */
	if (!test_and_set_bit(CFHSI_WAKE_UP, &cfhsi->bits))
		queue_work(cfhsi->wq, &cfhsi->wake_up_work);
}

static void cfhsi_wake_down_cb(struct cfhsi_drv *drv)
{
	struct cfhsi *cfhsi = NULL;

	cfhsi = container_of(drv, struct cfhsi, drv);
1012
	netdev_dbg(cfhsi->ndev, "%s.\n",
1013 1014 1015 1016 1017 1018 1019
		__func__);

	/* Initiating low power is only permitted by the host (us). */
	set_bit(CFHSI_WAKE_DOWN_ACK, &cfhsi->bits);
	wake_up_interruptible(&cfhsi->wake_down_wait);
}

1020 1021 1022 1023
static void cfhsi_aggregation_tout(unsigned long arg)
{
	struct cfhsi *cfhsi = (struct cfhsi *)arg;

1024
	netdev_dbg(cfhsi->ndev, "%s.\n",
1025 1026 1027 1028 1029
		__func__);

	cfhsi_start_tx(cfhsi);
}

1030 1031 1032 1033 1034
static int cfhsi_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct cfhsi *cfhsi = NULL;
	int start_xfer = 0;
	int timer_active;
1035
	int prio;
1036 1037 1038 1039 1040 1041

	if (!dev)
		return -EINVAL;

	cfhsi = netdev_priv(dev);

1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
	switch (skb->priority) {
	case TC_PRIO_BESTEFFORT:
	case TC_PRIO_FILLER:
	case TC_PRIO_BULK:
		prio = CFHSI_PRIO_BEBK;
		break;
	case TC_PRIO_INTERACTIVE_BULK:
		prio = CFHSI_PRIO_VI;
		break;
	case TC_PRIO_INTERACTIVE:
		prio = CFHSI_PRIO_VO;
		break;
	case TC_PRIO_CONTROL:
	default:
		prio = CFHSI_PRIO_CTL;
		break;
	}

1060 1061
	spin_lock_bh(&cfhsi->lock);

1062 1063 1064 1065 1066
	/* Update aggregation statistics  */
	cfhsi_update_aggregation_stats(cfhsi, skb, 1);

	/* Queue the SKB */
	skb_queue_tail(&cfhsi->qhead[prio], skb);
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076

	/* Sanity check; xmit should not be called after unregister_netdev */
	if (WARN_ON(test_bit(CFHSI_SHUTDOWN, &cfhsi->bits))) {
		spin_unlock_bh(&cfhsi->lock);
		cfhsi_abort_tx(cfhsi);
		return -EINVAL;
	}

	/* Send flow off if number of packets is above high water mark. */
	if (!cfhsi->flow_off_sent &&
1077
		cfhsi_tx_queue_len(cfhsi) > cfhsi->q_high_mark &&
1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
		cfhsi->cfdev.flowctrl) {
		cfhsi->flow_off_sent = 1;
		cfhsi->cfdev.flowctrl(cfhsi->ndev, OFF);
	}

	if (cfhsi->tx_state == CFHSI_TX_STATE_IDLE) {
		cfhsi->tx_state = CFHSI_TX_STATE_XFER;
		start_xfer = 1;
	}

1088
	if (!start_xfer) {
1089 1090 1091 1092
		/* Send aggregate if it is possible */
		bool aggregate_ready =
			cfhsi_can_send_aggregate(cfhsi) &&
			del_timer(&cfhsi->aggregation_timer) > 0;
1093
		spin_unlock_bh(&cfhsi->lock);
1094 1095
		if (aggregate_ready)
			cfhsi_start_tx(cfhsi);
1096
		return 0;
1097
	}
1098 1099

	/* Delete inactivity timer if started. */
1100
	timer_active = del_timer_sync(&cfhsi->inactivity_timer);
1101

1102 1103
	spin_unlock_bh(&cfhsi->lock);

1104 1105 1106 1107 1108 1109 1110
	if (timer_active) {
		struct cfhsi_desc *desc = (struct cfhsi_desc *)cfhsi->tx_buf;
		int len;
		int res;

		/* Create HSI frame. */
		len = cfhsi_tx_frm(desc, cfhsi);
1111
		WARN_ON(!len);
1112 1113 1114 1115

		/* Set up new transfer. */
		res = cfhsi->dev->cfhsi_tx(cfhsi->tx_buf, len, cfhsi->dev);
		if (WARN_ON(res < 0)) {
1116
			netdev_err(cfhsi->ndev, "%s: TX error %d.\n",
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
				__func__, res);
			cfhsi_abort_tx(cfhsi);
		}
	} else {
		/* Schedule wake up work queue if the we initiate. */
		if (!test_and_set_bit(CFHSI_WAKE_UP, &cfhsi->bits))
			queue_work(cfhsi->wq, &cfhsi->wake_up_work);
	}

	return 0;
}

1129
static const struct net_device_ops cfhsi_ops;
1130 1131 1132

static void cfhsi_setup(struct net_device *dev)
{
1133
	int i;
1134 1135 1136 1137 1138
	struct cfhsi *cfhsi = netdev_priv(dev);
	dev->features = 0;
	dev->netdev_ops = &cfhsi_ops;
	dev->type = ARPHRD_CAIF;
	dev->flags = IFF_POINTOPOINT | IFF_NOARP;
1139
	dev->mtu = CFHSI_MAX_CAIF_FRAME_SZ;
1140 1141
	dev->tx_queue_len = 0;
	dev->destructor = free_netdev;
1142 1143
	for (i = 0; i < CFHSI_PRIO_LAST; ++i)
		skb_queue_head_init(&cfhsi->qhead[i]);
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
	cfhsi->cfdev.link_select = CAIF_LINK_HIGH_BANDW;
	cfhsi->cfdev.use_frag = false;
	cfhsi->cfdev.use_stx = false;
	cfhsi->cfdev.use_fcs = false;
	cfhsi->ndev = dev;
}

int cfhsi_probe(struct platform_device *pdev)
{
	struct cfhsi *cfhsi = NULL;
	struct net_device *ndev;
1155

1156 1157 1158
	int res;

	ndev = alloc_netdev(sizeof(struct cfhsi), "cfhsi%d", cfhsi_setup);
1159
	if (!ndev)
1160 1161 1162 1163 1164 1165