tools/tools/ath/athspectral/athspectral.c

   1 /*
   2  * Copyright (c) 2013 Adrian Chadd <adrian@FreeBSD.org>
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  *
  25  * $FreeBSD$
  26  */
  27
  28 #include "diag.h"
  29
  30 #include "ah.h"
  31 #include "ah_internal.h"
  32
  33 #include <getopt.h>
  34 #include <errno.h>
  35 #include <err.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <ctype.h>
  39 #include <unistd.h>
  40
  41 struct spectralhandler {
  42         struct          ath_diag atd;
  43         int             s;
  44         struct ifreq    ifr;
  45         int             ah_devid;
  46 };
  47
  48 int
  49 spectral_opendev(struct spectralhandler *spectral, const char *devid)
  50 {
  51         HAL_REVS revs;
  52
  53         spectral->s = socket(AF_INET, SOCK_DGRAM, 0);
  54         if (spectral->s < 0) {
  55                 warn("socket");
  56                 return 0;
  57         }
  58
  59         strncpy(spectral->atd.ad_name, devid, sizeof (spectral->atd.ad_name));
  60
  61         /* Get the hardware revision, just to verify things are working */
  62         spectral->atd.ad_id = HAL_DIAG_REVS;
  63         spectral->atd.ad_out_data = (caddr_t) &revs;
  64         spectral->atd.ad_out_size = sizeof(revs);
  65         if (ioctl(spectral->s, SIOCGATHDIAG, &spectral->atd) < 0) {
  66                 warn("%s", spectral->atd.ad_name);
  67                 return 0;
  68         }
  69         spectral->ah_devid = revs.ah_devid;
  70         return 1;
  71 }
  72
  73 void
  74 spectral_closedev(struct spectralhandler *spectral)
  75 {
  76         close(spectral->s);
  77         spectral->s = -1;
  78 }
  79
  80 void
  81 spectralset(struct spectralhandler *spectral, int op, u_int32_t param)
  82 {
  83         HAL_SPECTRAL_PARAM pe;
  84
  85         pe.ss_fft_period = HAL_SPECTRAL_PARAM_NOVAL;
  86         pe.ss_period = HAL_SPECTRAL_PARAM_NOVAL;
  87         pe.ss_count = HAL_SPECTRAL_PARAM_NOVAL;
  88         pe.ss_short_report = HAL_SPECTRAL_PARAM_NOVAL;
  89         pe.ss_spectral_pri = HAL_SPECTRAL_PARAM_NOVAL;
  90         pe.ss_fft_period = HAL_SPECTRAL_PARAM_NOVAL;
  91         pe.ss_enabled = HAL_SPECTRAL_PARAM_NOVAL;
  92         pe.ss_active = HAL_SPECTRAL_PARAM_NOVAL;
  93
  94         switch (op) {
  95         case SPECTRAL_PARAM_FFT_PERIOD:
  96                 pe.ss_fft_period = param;
  97                 break;
  98         case SPECTRAL_PARAM_SS_PERIOD:
  99                 pe.ss_period = param;
 100                 break;
 101         case SPECTRAL_PARAM_SS_COUNT:
 102                 pe.ss_count = param;
 103                 break;
 104         case SPECTRAL_PARAM_SS_SHORT_RPT:
 105                 pe.ss_short_report = param;
 106                 break;
 107         case SPECTRAL_PARAM_SS_SPECTRAL_PRI:
 108                 pe.ss_spectral_pri = param;
 109                 break;
 110         }
 111
 112         spectral->atd.ad_id = SPECTRAL_CONTROL_SET_PARAMS | ATH_DIAG_IN;
 113         spectral->atd.ad_out_data = NULL;
 114         spectral->atd.ad_out_size = 0;
 115         spectral->atd.ad_in_data = (caddr_t) &pe;
 116         spectral->atd.ad_in_size = sizeof(HAL_SPECTRAL_PARAM);
 117         if (ioctl(spectral->s, SIOCGATHSPECTRAL, &spectral->atd) < 0)
 118                 err(1, "%s", spectral->atd.ad_name);
 119 }
 120
 121 static void
 122 spectral_get(struct spectralhandler *spectral)
 123 {
 124         HAL_SPECTRAL_PARAM pe;
 125
 126         spectral->atd.ad_id = SPECTRAL_CONTROL_GET_PARAMS | ATH_DIAG_DYN;
 127         memset(&pe, 0, sizeof(pe));
 128
 129         spectral->atd.ad_in_data = NULL;
 130         spectral->atd.ad_in_size = 0;
 131         spectral->atd.ad_out_data = (caddr_t) &pe;
 132         spectral->atd.ad_out_size = sizeof(pe);
 133
 134         if (ioctl(spectral->s, SIOCGATHSPECTRAL, &spectral->atd) < 0)
 135                 err(1, "%s", spectral->atd.ad_name);
 136
 137         printf("Spectral parameters (raw):\n");
 138         printf("   ss_enabled: %d\n", pe.ss_enabled);
 139         printf("   ss_active: %d\n", pe.ss_active);
 140         printf("   ss_count: %d\n", pe.ss_count);
 141         printf("   ss_fft_period: %d\n", pe.ss_fft_period);
 142         printf("   ss_period: %d\n", pe.ss_period);
 143         printf("   ss_short_report: %d\n", pe.ss_short_report);
 144         printf("   ss_spectral_pri: %d\n", pe.ss_spectral_pri);
 145         printf("   radar_bin_thresh_sel: %d\n", pe.radar_bin_thresh_sel);
 146 }
 147
 148 static void
 149 spectral_start(struct spectralhandler *spectral)
 150 {
 151         HAL_SPECTRAL_PARAM pe;
 152
 153         spectral->atd.ad_id = SPECTRAL_CONTROL_START | ATH_DIAG_DYN;
 154         memset(&pe, 0, sizeof(pe));
 155
 156         /*
 157          * XXX don't need these, but need to eliminate the ATH_DIAG_DYN flag
 158          * and debug
 159          */
 160         spectral->atd.ad_in_data = NULL;
 161         spectral->atd.ad_in_size = 0;
 162         spectral->atd.ad_out_data = (caddr_t) &pe;
 163         spectral->atd.ad_out_size = sizeof(pe);
 164
 165         if (ioctl(spectral->s, SIOCGATHSPECTRAL, &spectral->atd) < 0)
 166                 err(1, "%s", spectral->atd.ad_name);
 167 }
 168
 169 static void
 170 spectral_stop(struct spectralhandler *spectral)
 171 {
 172         HAL_SPECTRAL_PARAM pe;
 173
 174         spectral->atd.ad_id = SPECTRAL_CONTROL_STOP | ATH_DIAG_DYN;
 175         memset(&pe, 0, sizeof(pe));
 176
 177         /*
 178          * XXX don't need these, but need to eliminate the ATH_DIAG_DYN flag
 179          * and debug
 180          */
 181         spectral->atd.ad_in_data = NULL;
 182         spectral->atd.ad_in_size = 0;
 183         spectral->atd.ad_out_data = (caddr_t) &pe;
 184         spectral->atd.ad_out_size = sizeof(pe);
 185
 186         if (ioctl(spectral->s, SIOCGATHSPECTRAL, &spectral->atd) < 0)
 187                 err(1, "%s", spectral->atd.ad_name);
 188 }
 189
 190 static void
 191 spectral_enable_at_reset(struct spectralhandler *spectral, int val)
 192 {
 193         int v = val;
 194
 195         spectral->atd.ad_id = SPECTRAL_CONTROL_ENABLE_AT_RESET
 196             | ATH_DIAG_IN;
 197
 198         /*
 199          * XXX don't need these, but need to eliminate the ATH_DIAG_DYN flag
 200          * and debug
 201          */
 202         spectral->atd.ad_out_data = NULL;
 203         spectral->atd.ad_out_size = 0;
 204         spectral->atd.ad_in_data = (caddr_t) &v;
 205         spectral->atd.ad_in_size = sizeof(v);
 206
 207         printf("%s: val=%d\n", __func__, v);
 208
 209         if (ioctl(spectral->s, SIOCGATHSPECTRAL, &spectral->atd) < 0)
 210                 err(1, "%s", spectral->atd.ad_name);
 211 }
 212
 213 static int
 214 spectral_set_param(struct spectralhandler *spectral, const char *param,
 215     const char *val)
 216 {
 217         int v;
 218
 219         v = atoi(val);
 220
 221         if (strcmp(param, "ss_short_report") == 0) {
 222                 spectralset(spectral, SPECTRAL_PARAM_SS_SHORT_RPT, v);
 223         } else if (strcmp(param, "ss_fft_period") == 0) {
 224                 spectralset(spectral, SPECTRAL_PARAM_FFT_PERIOD, v);
 225         } else if (strcmp(param, "ss_period") == 0) {
 226                 spectralset(spectral, SPECTRAL_PARAM_SS_PERIOD, v);
 227         } else if (strcmp(param, "ss_count") == 0) {
 228                 spectralset(spectral, SPECTRAL_PARAM_SS_COUNT, v);
 229         } else if (strcmp(param, "ss_spectral_pri") == 0) {
 230                 spectralset(spectral, SPECTRAL_PARAM_SS_SPECTRAL_PRI, v);
 231         } else {
 232                 return (0);
 233         }
 234
 235 #if 0
 236         if (strcmp(param, "enabled") == 0) {
 237                 spectralset(spectral, DFS_PARAM_ENABLE, v);
 238         } else if (strcmp(param, "firpwr") == 0) {
 239                 spectralset(spectral, DFS_PARAM_FIRPWR, v);
 240         } else if (strcmp(param, "rrssi") == 0) {
 241                 spectralset(spectral, DFS_PARAM_RRSSI, v);
 242         } else if (strcmp(param, "height") == 0) {
 243                 spectralset(spectral, DFS_PARAM_HEIGHT, v);
 244         } else if (strcmp(param, "prssi") == 0) {
 245                 spectralset(spectral, DFS_PARAM_PRSSI, v);
 246         } else if (strcmp(param, "inband") == 0) {
 247                 spectralset(spectral, DFS_PARAM_INBAND, v);
 248         } else if (strcmp(param, "relpwr") == 0) {
 249                 spectralset(spectral, DFS_PARAM_RELPWR, v);
 250         } else if (strcmp(param, "relstep") == 0) {
 251                 spectralset(spectral, DFS_PARAM_RELSTEP, v);
 252         } else if (strcmp(param, "maxlen") == 0) {
 253                 spectralset(spectral, DFS_PARAM_MAXLEN, v);
 254         } else if (strcmp(param, "usefir128") == 0) {
 255                 spectralset(spectral, DFS_PARAM_USEFIR128, v);
 256         } else if (strcmp(param, "blockspectral") == 0) {
 257                 spectralset(spectral, DFS_PARAM_BLOCKRADAR, v);
 258         } else if (strcmp(param, "enmaxrssi") == 0) {
 259                 spectralset(spectral, DFS_PARAM_MAXRSSI_EN, v);
 260         } else if (strcmp(param, "extchannel") == 0) {
 261                 spectralset(spectral, DFS_PARAM_EN_EXTCH, v);
 262         } else if (strcmp(param, "enrelpwr") == 0) {
 263                 spectralset(spectral, DFS_PARAM_RELPWR_EN, v);
 264         } else if (strcmp(param, "en_relstep_check") == 0) {
 265                 spectralset(spectral, DFS_PARAM_RELSTEP_EN, v);
 266         } else {
 267                 return 0;
 268         }
 269 #endif
 270
 271         return 1;
 272 }
 273
 274 void
 275 usage(const char *progname)
 276 {
 277         printf("Usage:\n");
 278         printf("\t%s: [-i <interface>] <cmd> (<arg>)\n", progname);
 279         printf("\t%s: [-h]\n", progname);
 280         printf("\n");
 281         printf("Valid commands:\n");
 282         printf("\tget:\t\tGet current spectral parameters\n");
 283         printf("\tset <param> <value>:\t\tSet spectral parameter\n");
 284         printf("\tstart: Start spectral scan\n");
 285         printf("\tstop: Stop spectral scan\n");
 286         printf("\tenable_at_reset <0|1>: enable reporting upon channel reset\n");
 287 }
 288
 289 int
 290 main(int argc, char *argv[])
 291 {
 292         struct spectralhandler spectral;
 293         const char *devname = ATH_DEFAULT;
 294         const char *progname = argv[0];
 295
 296         memset(&spectral, 0, sizeof(spectral));
 297
 298         /* Parse command line options */
 299         if (argc >= 2 && strcmp(argv[1], "-h") == 0) {
 300                 usage(progname);
 301                 exit(0);
 302         }
 303         if (argc >= 2 && strcmp(argv[1], "-?") == 0) {
 304                 usage(progname);
 305                 exit(0);
 306         }
 307
 308         if (argc >= 2 && strcmp(argv[1], "-i") == 0) {
 309                 if (argc == 2) {
 310                         usage(progname);
 311                         exit(127);
 312                 }
 313                 devname = argv[2];
 314                 argc -= 2; argv += 2;
 315         }
 316
 317         /* At this point we require at least one command */
 318         if (argc == 1) {
 319                 usage(progname);
 320                 exit(127);
 321         }
 322
 323         if (spectral_opendev(&spectral, devname) == 0)
 324                 exit(127);
 325
 326         if (strcasecmp(argv[1], "get") == 0) {
 327                 spectral_get(&spectral);
 328         } else if (strcasecmp(argv[1], "set") == 0) {
 329                 if (argc < 4) {
 330                         usage(progname);
 331                         exit(127);
 332                 }
 333                 if (spectral_set_param(&spectral, argv[2], argv[3]) == 0) {
 334                         usage(progname);
 335                         exit(127);
 336                 }
 337         } else if (strcasecmp(argv[1], "start") == 0) {
 338                 spectral_start(&spectral);
 339         } else if (strcasecmp(argv[1], "stop") == 0) {
 340                 spectral_stop(&spectral);
 341         } else if (strcasecmp(argv[1], "enable_at_reset") == 0) {
 342                 if (argc < 3) {
 343                         usage(progname);
 344                         exit(127);
 345                 }
 346                 spectral_enable_at_reset(&spectral, atoi(argv[2]));
 347         } else {
 348                 usage(progname);
 349                 exit(127);
 350         }
 351
 352         /* wrap up */
 353         spectral_closedev(&spectral);
 354         exit(0);
 355 }