| /* |
| * 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); |
| } |