tools/carlu/src/cmd.c

   1 /*
   2  * carlu - userspace testing utility for ar9170 devices
   3  *
   4  * Abstraction Layer for FW/HW command interface
   5  *
   6  * Copyright 2009-2011 Christian Lamparter <chunkeey@googlemail.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <stdbool.h>
  29 #include <stdlib.h>
  30 #include <errno.h>
  31 #include <string.h>
  32 #include <stdlib.h>
  33 #include "libusb.h"
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <unistd.h>
  37
  38 #include "carlu.h"
  39 #include "usb.h"
  40 #include "debug.h"
  41 #include "fwcmd.h"
  42 #include "eeprom.h"
  43 #include "cmd.h"
  44
  45 int carlu_cmd_echo(struct carlu *ar, const uint32_t message)
  46 {
  47         uint32_t _message;
  48         int ret;
  49
  50         ret = carlusb_cmd(ar, CARL9170_CMD_ECHO,
  51                              (uint8_t *)&message, sizeof(message),
  52                              (uint8_t *)&_message, sizeof(_message));
  53
  54         if (ret == 0)
  55                 ret = (message == _message) ? 0 : -EIO;
  56
  57         return ret;
  58 }
  59
  60 struct carl9170_cmd *carlu_cmd_buf(struct carlu *ar,
  61         const enum carl9170_cmd_oids cmd, const unsigned int len)
  62 {
  63         struct carl9170_cmd *tmp;
  64
  65         if (len % 4 || (sizeof(struct carl9170_cmd_head) + len > 64))
  66                 return ERR_PTR(-EINVAL);
  67
  68         tmp = malloc(sizeof(struct carl9170_cmd_head) + len);
  69         if (tmp) {
  70                 tmp->hdr.cmd = cmd;
  71                 tmp->hdr.len = len;
  72         }
  73         return tmp;
  74 }
  75
  76 int carlu_cmd_reboot(struct carlu *ar)
  77 {
  78         struct carl9170_cmd *reboot;
  79         int err;
  80
  81         /* sure, we could put the struct on the stack too. */
  82         reboot = carlu_cmd_buf(ar, CARL9170_CMD_REBOOT_ASYNC, 0);
  83         if (IS_ERR_OR_NULL(reboot))
  84                 return reboot ? PTR_ERR(reboot) : -ENOMEM;
  85
  86         err = carlusb_cmd_async(ar, reboot, true);
  87         return err;
  88 }
  89
  90 int carlu_cmd_mem_dump(struct carlu *ar, const uint32_t start,
  91                         const unsigned int len, void *_buf)
  92 {
  93 #define RW      8       /* number of words to read at once */
  94 #define RB      (sizeof(uint32_t) * RW)
  95         uint8_t *buf = _buf;
  96         unsigned int i, j, block;
  97         int err;
  98         __le32 offsets[RW];
  99
 100         for (i = 0; i < (len + RB - 1) / RB; i++) {
 101                 block = min_t(unsigned int, (len - RB * i) / sizeof(uint32_t), RW);
 102                 for (j = 0; j < block; j++)
 103                         offsets[j] = cpu_to_le32(start + RB * i + 4 * j);
 104
 105                 err = carlusb_cmd(ar, CARL9170_CMD_RREG,
 106                                     (void *) &offsets, block * sizeof(uint32_t),
 107                                     (void *) buf + RB * i, RB);
 108
 109                 if (err)
 110                         return err;
 111         }
 112
 113 #undef RW
 114 #undef RB
 115
 116         return 0;
 117 }
 118
 119 int carlu_cmd_mem_watch(struct carlu *ar, const uint32_t mem,
 120                         const unsigned int len, void *_buf)
 121 {
 122 #define RW      8       /* number of words to read at once */
 123 #define RB      (sizeof(uint32_t) * RW)
 124         uint8_t *buf = _buf;
 125         unsigned int i, j, block;
 126         int err;
 127         __le32 offsets[RW];
 128
 129         for (i = 0; i < (len + RB - 1) / RB; i++) {
 130                 block = min_t(unsigned int, (len - RB * i) / sizeof(uint32_t), RW);
 131                 for (j = 0; j < block; j++)
 132                         offsets[j] = cpu_to_le32(mem);
 133
 134                 err = carlusb_cmd(ar, CARL9170_CMD_RREG,
 135                                     (void *) &offsets, block * sizeof(uint32_t),
 136                                     (void *) buf + RB * i, RB);
 137
 138                 if (err)
 139                         return err;
 140         }
 141
 142 #undef RW
 143 #undef RB
 144
 145         return 0;
 146 }
 147
 148 int carlu_cmd_write_mem(struct carlu *ar, const uint32_t addr,
 149                         const uint32_t val)
 150 {
 151         int err;
 152         __le32 msg, block[2] = { cpu_to_le32(addr), cpu_to_le32(val) };
 153
 154         err = carlusb_cmd(ar, CARL9170_CMD_WREG,
 155                           (void *) &block, sizeof(block),
 156                           (void *) &msg, sizeof(msg));
 157         return err;
 158 }
 159
 160 int carlu_cmd_read_mem(struct carlu *ar, const uint32_t _addr,
 161                        uint32_t *val)
 162 {
 163         int err;
 164         __le32 msg, addr = { cpu_to_le32(_addr) };
 165         err = carlusb_cmd(ar, CARL9170_CMD_RREG, (void *) &addr, sizeof(addr),
 166                           (void *) &msg, sizeof(msg));
 167
 168         *val = le32_to_cpu(msg);
 169         return err;
 170 }
 171
 172 int carlu_cmd_read_eeprom(struct carlu *ar)
 173 {
 174
 175         int err;
 176
 177         err = carlu_cmd_mem_dump(ar, AR9170_EEPROM_START, sizeof(ar->eeprom),
 178                                   &ar->eeprom);
 179
 180 #ifndef __CHECKER__
 181         /* don't want to handle trailing remains */
 182         BUILD_BUG_ON(sizeof(ar->eeprom) % 8);
 183 #endif
 184
 185         if (ar->eeprom.length == cpu_to_le16(0xffff))
 186                 return -ENODATA;
 187
 188         return 0;
 189 }