| /* |
| * carlu - userspace testing utility for ar9170 devices |
| * |
| * Abstraction Layer for FW/HW command interface |
| * |
| * 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 <sys/types.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| |
| #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; |
| } |