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 #ifndef ATH_DEFAULT
  34 #define ATH_DEFAULT     "ath0"
  35 #endif
  36
  37 #include <getopt.h>
  38 #include <errno.h>
  39 #include <err.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <ctype.h>
  43 #include <unistd.h>
  44
  45 struct spectralhandler {
  46         struct          ath_diag atd;
  47         int             s;
  48         struct ifreq    ifr;
  49         int             ah_devid;
  50 };
  51
  52 int
  53 spectral_opendev(struct spectralhandler *spectral, const char *devid)
  54 {
  55         HAL_REVS revs;
  56
  57         spectral->s = socket(AF_INET, SOCK_DGRAM, 0);
  58         if (spectral->s < 0) {
  59                 warn("socket");
  60                 return 0;
  61         }
  62
  63         strncpy(spectral->atd.ad_name, devid, sizeof (spectral->atd.ad_name));
  64
  65         /* Get the hardware revision, just to verify things are working */
  66         spectral->atd.ad_id = HAL_DIAG_REVS;
  67         spectral->atd.ad_out_data = (caddr_t) &revs;
  68         spectral->atd.ad_out_size = sizeof(revs);
  69         if (ioctl(spectral->s, SIOCGATHDIAG, &spectral->atd) < 0) {
  70                 warn("%s", spectral->atd.ad_name);
  71                 return 0;
  72         }
  73         spectral->ah_devid = revs.ah_devid;
  74         return 1;
  75 }
  76
  77 void
  78 spectral_closedev(struct spectralhandler *spectral)
  79 {
  80         close(spectral->s);
  81         spectral->s = -1;
  82 }
  83
  84 void
  85 spectralset(struct spectralhandler *spectral, int op, u_int32_t param)
  86 {
  87         HAL_SPECTRAL_PARAM pe;
  88
  89         pe.ss_fft_period = HAL_SPECTRAL_PARAM_NOVAL;
  90         pe.ss_period = HAL_SPECTRAL_PARAM_NOVAL;
  91         pe.ss_count = HAL_SPECTRAL_PARAM_NOVAL;
  92         pe.ss_short_report = HAL_SPECTRAL_PARAM_NOVAL;
  93         pe.ss_spectral_pri = HAL_SPECTRAL_PARAM_NOVAL;
  94         pe.ss_fft_period = HAL_SPECTRAL_PARAM_NOVAL;
  95         pe.ss_enabled = HAL_SPECTRAL_PARAM_NOVAL;
  96         pe.ss_active = HAL_SPECTRAL_PARAM_NOVAL;
  97
  98         switch (op) {
  99         case SPECTRAL_PARAM_FFT_PERIOD:
 100                 pe.ss_fft_period = param;
 101                 break;
 102         case SPECTRAL_PARAM_SS_PERIOD:
 103                 pe.ss_period = param;
 104                 break;
 105         case SPECTRAL_PARAM_SS_COUNT:
 106                 pe.ss_count = param;
 107                 break;
 108         case SPECTRAL_PARAM_SS_SHORT_RPT:
 109                 pe.ss_short_report = param;
 110                 break;
 111         }
 112
 113         spectral->atd.ad_id = SPECTRAL_CONTROL_SET_PARAMS | ATH_DIAG_IN;
 114         spectral->atd.ad_out_data = NULL;
 115         spectral->atd.ad_out_size = 0;
 116         spectral->atd.ad_in_data = (caddr_t) &pe;
 117         spectral->atd.ad_in_size = sizeof(HAL_SPECTRAL_PARAM);
 118         if (ioctl(spectral->s, SIOCGATHSPECTRAL, &spectral->atd) < 0)
 119                 err(1, "%s", spectral->atd.ad_name);
 120 }
 121
 122 static void
 123 spectral_get(struct spectralhandler *spectral)
 124 {
 125         HAL_SPECTRAL_PARAM pe;
 126
 127         spectral->atd.ad_id = SPECTRAL_CONTROL_GET_PARAMS | ATH_DIAG_DYN;
 128         memset(&pe, 0, sizeof(pe));
 129
 130         spectral->atd.ad_in_data = NULL;
 131         spectral->atd.ad_in_size = 0;
 132         spectral->atd.ad_out_data = (caddr_t) &pe;
 133         spectral->atd.ad_out_size = sizeof(pe);
 134
 135         if (ioctl(spectral->s, SIOCGATHSPECTRAL, &spectral->atd) < 0)
 136                 err(1, "%s", spectral->atd.ad_name);
 137
 138         printf("Spectral parameters (raw):\n");
 139         printf("   ss_enabled: %d\n", pe.ss_enabled);
 140         printf("   ss_active: %d\n", pe.ss_active);
 141         printf("   ss_count: %d\n", pe.ss_count);
 142         printf("   ss_fft_period: %d\n", pe.ss_fft_period);
 143         printf("   ss_period: %d\n", pe.ss_period);
 144         printf("   ss_short_report: %d\n", pe.ss_short_report);
 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 {
 230                 return (0);
 231         }
 232
 233 #if 0
 234         if (strcmp(param, "enabled") == 0) {
 235                 spectralset(spectral, DFS_PARAM_ENABLE, v);
 236         } else if (strcmp(param, "firpwr") == 0) {
 237                 spectralset(spectral, DFS_PARAM_FIRPWR, v);
 238         } else if (strcmp(param, "rrssi") == 0) {
 239                 spectralset(spectral, DFS_PARAM_RRSSI, v);
 240         } else if (strcmp(param, "height") == 0) {
 241                 spectralset(spectral, DFS_PARAM_HEIGHT, v);
 242         } else if (strcmp(param, "prssi") == 0) {
 243                 spectralset(spectral, DFS_PARAM_PRSSI, v);
 244         } else if (strcmp(param, "inband") == 0) {
 245                 spectralset(spectral, DFS_PARAM_INBAND, v);
 246         } else if (strcmp(param, "relpwr") == 0) {
 247                 spectralset(spectral, DFS_PARAM_RELPWR, v);
 248         } else if (strcmp(param, "relstep") == 0) {
 249                 spectralset(spectral, DFS_PARAM_RELSTEP, v);
 250         } else if (strcmp(param, "maxlen") == 0) {
 251                 spectralset(spectral, DFS_PARAM_MAXLEN, v);
 252         } else if (strcmp(param, "usefir128") == 0) {
 253                 spectralset(spectral, DFS_PARAM_USEFIR128, v);
 254         } else if (strcmp(param, "blockspectral") == 0) {
 255                 spectralset(spectral, DFS_PARAM_BLOCKRADAR, v);
 256         } else if (strcmp(param, "enmaxrssi") == 0) {
 257                 spectralset(spectral, DFS_PARAM_MAXRSSI_EN, v);
 258         } else if (strcmp(param, "extchannel") == 0) {
 259                 spectralset(spectral, DFS_PARAM_EN_EXTCH, v);
 260         } else if (strcmp(param, "enrelpwr") == 0) {
 261                 spectralset(spectral, DFS_PARAM_RELPWR_EN, v);
 262         } else if (strcmp(param, "en_relstep_check") == 0) {
 263                 spectralset(spectral, DFS_PARAM_RELSTEP_EN, v);
 264         } else {
 265                 return 0;
 266         }
 267 #endif
 268
 269         return 1;
 270 }
 271
 272 void
 273 usage(const char *progname)
 274 {
 275         printf("Usage:\n");
 276         printf("\t%s: [-i <interface>] <cmd> (<arg>)\n", progname);
 277         printf("\t%s: [-h]\n", progname);
 278         printf("\n");
 279         printf("Valid commands:\n");
 280         printf("\tget:\t\tGet current spectral parameters\n");
 281         printf("\tset <param> <value>:\t\tSet spectral parameter\n");
 282         printf("\tstart: Start spectral scan\n");
 283         printf("\tstop: Stop spectral scan\n");
 284         printf("\tenable_at_reset <0|1>: enable reporting upon channel reset\n");
 285 }
 286
 287 int
 288 main(int argc, char *argv[])
 289 {
 290         struct spectralhandler spectral;
 291         const char *devname = ATH_DEFAULT;
 292         const char *progname = argv[0];
 293
 294         memset(&spectral, 0, sizeof(spectral));
 295
 296         /* Parse command line options */
 297         if (argc >= 2 && strcmp(argv[1], "-h") == 0) {
 298                 usage(progname);
 299                 exit(0);
 300         }
 301         if (argc >= 2 && strcmp(argv[1], "-?") == 0) {
 302                 usage(progname);
 303                 exit(0);
 304         }
 305
 306         if (argc >= 2 && strcmp(argv[1], "-i") == 0) {
 307                 if (argc == 2) {
 308                         usage(progname);
 309                         exit(127);
 310                 }
 311                 devname = argv[2];
 312                 argc -= 2; argv += 2;
 313         }
 314
 315         /* At this point we require at least one command */
 316         if (argc == 1) {
 317                 usage(progname);
 318                 exit(127);
 319         }
 320
 321         if (spectral_opendev(&spectral, devname) == 0)
 322                 exit(127);
 323
 324         if (strcasecmp(argv[1], "get") == 0) {
 325                 spectral_get(&spectral);
 326         } else if (strcasecmp(argv[1], "set") == 0) {
 327                 if (argc < 4) {
 328                         usage(progname);
 329                         exit(127);
 330                 }
 331                 if (spectral_set_param(&spectral, argv[2], argv[3]) == 0) {
 332                         usage(progname);
 333                         exit(127);
 334                 }
 335         } else if (strcasecmp(argv[1], "start") == 0) {
 336                 spectral_start(&spectral);
 337         } else if (strcasecmp(argv[1], "stop") == 0) {
 338                 spectral_stop(&spectral);
 339         } else if (strcasecmp(argv[1], "enable_at_reset") == 0) {
 340                 if (argc < 3) {
 341                         usage(progname);
 342                         exit(127);
 343                 }
 344                 spectral_enable_at_reset(&spectral, atoi(argv[2]));
 345         } else {
 346                 usage(progname);
 347                 exit(127);
 348         }
 349
 350         /* wrap up */
 351         spectral_closedev(&spectral);
 352         exit(0);
 353 }