Gecko [ 167.86.127.34 ]

Name	Size	Permission
carlu.h	3.4 KB	-rw-r--r--
cmd.c	4.41 KB	-rw-r--r--
cmd.h	4.1 KB	-rw-r--r--
debug.c	2.27 KB	-rw-r--r--
debug.h	2.1 KB	-rw-r--r--
fw.c	3.56 KB	-rw-r--r--
main.c	6.02 KB	-rw-r--r--
rx.c	4.11 KB	-rw-r--r--
test.c	5.46 KB	-rw-r--r--
test.h	1.21 KB	-rw-r--r--
tx.c	5.17 KB	-rw-r--r--
usb.c	16.75 KB	-rw-r--r--
usb.h	2.01 KB	-rw-r--r--

Code Editor : rx.c

/*
 * carlu - userspace testing utility for ar9170 devices
 *
 * RX data processing
 *
 * Copyright 2009-2011 Christian Lamparter <chunkeey@googlemail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include "libusb.h"

#include "carlu.h"
#include "debug.h"
#include "frame.h"
#include "ieee80211.h"
#include "wlan.h"

static void carlu_handle_data(struct carlu *ar, void *buf,
			       unsigned int len)
{
	if (ar->rx_cb) {
		ar->rx_cb(ar, buf, len);
	} else {
		dbg("unhandled data:\n");
		print_hex_dump_bytes(VERBOSE, "DATA:", buf, len);
	}
}

void carlu_handle_command(struct carlu *ar, void *buf,
			  unsigned int len)
{
	struct carl9170_rsp *cmd;
	int ret = 0;

cmd = (void *) buf;

if ((cmd->hdr.cmd & CARL9170_RSP_FLAG) != CARL9170_RSP_FLAG) {
		if ((cmd->hdr.cmd & CARL9170_CMD_ASYNC_FLAG))
			return;

SDL_mutexP(ar->resp_lock);
		if (ar->resp_buf && ar->resp_len && ar->resp_len >= (len - 4)) {
			memcpy(ar->resp_buf, buf + 4, len - 4);
			ar->resp_buf = NULL;
		} else {
			warn("spurious command response (%d / %d)\n",
			     (int) len - 4, (int) ar->resp_len);
			print_hex_dump_bytes(WARNING, "RSP:", buf, len);
		}
		SDL_mutexV(ar->resp_lock);

SDL_CondSignal(ar->resp_pend);
		return;
	}

if (ar->cmd_cb)
		ret = ar->cmd_cb(ar, cmd, buf, len);

if (ret) {
		switch (cmd->hdr.cmd) {
		case CARL9170_RSP_TXCOMP:
			carlu_tx_feedback(ar, cmd);
			break;

case CARL9170_RSP_TEXT:
			info("carl9170 FW: %.*s\n", (int)len - 4, (char *)buf + 4);
			break;

case CARL9170_RSP_HEXDUMP:
			info("carl9170 FW: hexdump\n");
			print_hex_dump_bytes(INFO, "HEX:", (char *)buf + 4, len - 4);
			break;

case CARL9170_RSP_WATCHDOG:
			err("Woof Woof! Watchdog notification.\n");
			break;

case CARL9170_RSP_GPIO:
			info("GPIO Interrupt => GPIO state %.8x\n",
			    le32_to_cpu(cmd->gpio.gpio));
			break;

case CARL9170_RSP_RADAR:
			info("RADAR Interrupt");
			break;

default:
			warn("received unhandled event 0x%x\n", cmd->hdr.cmd);
			print_hex_dump_bytes(WARNING, "RSP:", (char *)buf + 4, len - 4);
			break;
		}
	}
}

static void __carlu_rx(struct carlu *ar, uint8_t *buf, unsigned int len)
{
	unsigned int i;

i = 0;

/* weird thing, but this is the same in the original driver */
	while (len > 2 && i < 12 && buf[0] == 0xff && buf[1] == 0xff) {
		i += 2;
		len -= 2;
		buf += 2;
	}

if (i == 12) {
		struct carl9170_rsp *cmd;
		i = 0;

while (i < len) {
			cmd = (void *) &buf[i];

carlu_handle_command(ar, cmd, cmd->hdr.len + 4);
			i += cmd->hdr.len + 4;
		}
	} else {
		carlu_handle_data(ar, buf, len);
	}
}

static void carlu_rx_stream(struct carlu *ar, struct frame *frame)
{
	void *buf = frame->data;
	unsigned int len = frame->len;

while (len >= 4) {
		struct ar9170_stream *rx_stream;
		unsigned int resplen, elen;

rx_stream = (void *) buf;
		resplen = le16_to_cpu(rx_stream->length);
		elen = roundup(resplen + 4, 4);

if (rx_stream->tag != cpu_to_le16(0x4e00)) {
			warn("frame has no tag %p %u %x.\n",
			      buf, (int) len, rx_stream->tag);
			print_hex_dump_bytes(WARNING, "FRAME:", frame->data, frame->len);

__carlu_rx(ar, buf, len);
			return;
		}

__carlu_rx(ar, rx_stream->payload, resplen);

len -= elen;
		buf += elen;
	}
}

void carlu_rx(struct carlu *ar, struct frame *frame)
{
	if (ar->rx_stream)
		carlu_rx_stream(ar, frame);
	else
		__carlu_rx(ar, frame->data, frame->len);
}

${this.title}

Code Editor : rx.c