From 39a0d9019076a29a57a38a817b1830aef0708c11 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 28 Apr 2024 14:26:09 +0200 Subject: Adding upstream version 20230210. Signed-off-by: Daniel Baumann --- carl9170fw/tools/carlu/src/cmd.c | 189 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 189 insertions(+) create mode 100644 carl9170fw/tools/carlu/src/cmd.c (limited to 'carl9170fw/tools/carlu/src/cmd.c') diff --git a/carl9170fw/tools/carlu/src/cmd.c b/carl9170fw/tools/carlu/src/cmd.c new file mode 100644 index 0000000..bb87399 --- /dev/null +++ b/carl9170fw/tools/carlu/src/cmd.c @@ -0,0 +1,189 @@ +/* + * carlu - userspace testing utility for ar9170 devices + * + * Abstraction Layer for FW/HW command interface + * + * Copyright 2009-2011 Christian Lamparter + * + * 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 +#endif + +#include +#include +#include +#include +#include +#include +#include "libusb.h" +#include +#include +#include + +#include "carlu.h" +#include "usb.h" +#include "debug.h" +#include "fwcmd.h" +#include "eeprom.h" +#include "cmd.h" + +int carlu_cmd_echo(struct carlu *ar, const uint32_t message) +{ + uint32_t _message; + int ret; + + ret = carlusb_cmd(ar, CARL9170_CMD_ECHO, + (uint8_t *)&message, sizeof(message), + (uint8_t *)&_message, sizeof(_message)); + + if (ret == 0) + ret = (message == _message) ? 0 : -EIO; + + return ret; +} + +struct carl9170_cmd *carlu_cmd_buf(struct carlu *ar, + const enum carl9170_cmd_oids cmd, const unsigned int len) +{ + struct carl9170_cmd *tmp; + + if (len % 4 || (sizeof(struct carl9170_cmd_head) + len > 64)) + return ERR_PTR(-EINVAL); + + tmp = malloc(sizeof(struct carl9170_cmd_head) + len); + if (tmp) { + tmp->hdr.cmd = cmd; + tmp->hdr.len = len; + } + return tmp; +} + +int carlu_cmd_reboot(struct carlu *ar) +{ + struct carl9170_cmd *reboot; + int err; + + /* sure, we could put the struct on the stack too. */ + reboot = carlu_cmd_buf(ar, CARL9170_CMD_REBOOT_ASYNC, 0); + if (IS_ERR_OR_NULL(reboot)) + return reboot ? PTR_ERR(reboot) : -ENOMEM; + + err = carlusb_cmd_async(ar, reboot, true); + return err; +} + +int carlu_cmd_mem_dump(struct carlu *ar, const uint32_t start, + const unsigned int len, void *_buf) +{ +#define RW 8 /* number of words to read at once */ +#define RB (sizeof(uint32_t) * RW) + uint8_t *buf = _buf; + unsigned int i, j, block; + int err; + __le32 offsets[RW]; + + for (i = 0; i < (len + RB - 1) / RB; i++) { + block = min_t(unsigned int, (len - RB * i) / sizeof(uint32_t), RW); + for (j = 0; j < block; j++) + offsets[j] = cpu_to_le32(start + RB * i + 4 * j); + + err = carlusb_cmd(ar, CARL9170_CMD_RREG, + (void *) &offsets, block * sizeof(uint32_t), + (void *) buf + RB * i, RB); + + if (err) + return err; + } + +#undef RW +#undef RB + + return 0; +} + +int carlu_cmd_mem_watch(struct carlu *ar, const uint32_t mem, + const unsigned int len, void *_buf) +{ +#define RW 8 /* number of words to read at once */ +#define RB (sizeof(uint32_t) * RW) + uint8_t *buf = _buf; + unsigned int i, j, block; + int err; + __le32 offsets[RW]; + + for (i = 0; i < (len + RB - 1) / RB; i++) { + block = min_t(unsigned int, (len - RB * i) / sizeof(uint32_t), RW); + for (j = 0; j < block; j++) + offsets[j] = cpu_to_le32(mem); + + err = carlusb_cmd(ar, CARL9170_CMD_RREG, + (void *) &offsets, block * sizeof(uint32_t), + (void *) buf + RB * i, RB); + + if (err) + return err; + } + +#undef RW +#undef RB + + return 0; +} + +int carlu_cmd_write_mem(struct carlu *ar, const uint32_t addr, + const uint32_t val) +{ + int err; + __le32 msg, block[2] = { cpu_to_le32(addr), cpu_to_le32(val) }; + + err = carlusb_cmd(ar, CARL9170_CMD_WREG, + (void *) &block, sizeof(block), + (void *) &msg, sizeof(msg)); + return err; +} + +int carlu_cmd_read_mem(struct carlu *ar, const uint32_t _addr, + uint32_t *val) +{ + int err; + __le32 msg, addr = { cpu_to_le32(_addr) }; + err = carlusb_cmd(ar, CARL9170_CMD_RREG, (void *) &addr, sizeof(addr), + (void *) &msg, sizeof(msg)); + + *val = le32_to_cpu(msg); + return err; +} + +int carlu_cmd_read_eeprom(struct carlu *ar) +{ + + int err; + + err = carlu_cmd_mem_dump(ar, AR9170_EEPROM_START, sizeof(ar->eeprom), + &ar->eeprom); + +#ifndef __CHECKER__ + /* don't want to handle trailing remains */ + BUILD_BUG_ON(sizeof(ar->eeprom) % 8); +#endif + + if (ar->eeprom.length == cpu_to_le16(0xffff)) + return -ENODATA; + + return 0; +} -- cgit v1.2.3