usr.bin/radioctl/radioctl.c

   1 /* $NetBSD: radioctl.c,v 1.7 2006/05/11 01:24:14 mrg Exp $ */
   2 /* $OpenBSD: radioctl.c,v 1.5 2001/12/18 18:42:19 mickey Exp $ */
   3 /* $RuOBSD: radioctl.c,v 1.4 2001/10/20 18:09:10 pva Exp $ */
   4
   5 /*
   6  * Copyright (c) 2001 Vladimir Popov <jumbo@narod.ru>
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  24  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  25  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  27  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29 #include <sys/cdefs.h>
  30
  31 #ifndef lint
  32 __RCSID("$NetBSD: radioctl.c,v 1.7 2006/05/11 01:24:14 mrg Exp $");
  33 #endif
  34
  35 #include <sys/ioctl.h>
  36 #include <sys/radioio.h>
  37
  38 #include <err.h>
  39 #include <fcntl.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <unistd.h>
  44
  45 #define RADIO_ENV       "RADIODEVICE"
  46 #define RADIODEVICE     "/dev/radio"
  47
  48 const char *varname[] = {
  49         "search",
  50 #define OPTION_SEARCH           0x00
  51         "volume",
  52 #define OPTION_VOLUME           0x01
  53         "frequency",
  54 #define OPTION_FREQUENCY        0x02
  55         "mute",
  56 #define OPTION_MUTE             0x03
  57         "reference",
  58 #define OPTION_REFERENCE        0x04
  59         "mono",
  60 #define OPTION_MONO             0x05
  61         "stereo",
  62 #define OPTION_STEREO           0x06
  63         "sensitivity"
  64 #define OPTION_SENSITIVITY      0x07
  65 };
  66
  67 #define OPTION_NONE             ~0u
  68 #define VALUE_NONE              ~0u
  69
  70 struct opt_t {
  71         char *string;
  72         int option;
  73         int sign;
  74 #define SIGN_NONE       0
  75 #define SIGN_PLUS       1
  76 #define SIGN_MINUS      -1
  77         u_int32_t value;
  78 };
  79
  80 const char *onchar = "on";
  81 #define ONCHAR_LEN      2
  82 const char *offchar = "off";
  83 #define OFFCHAR_LEN     3
  84
  85 static struct radio_info ri;
  86
  87 static int      parse_opt(char *, struct opt_t *);
  88
  89 static void     print_vars(int);
  90 static void     do_ioctls(int, struct opt_t *, int);
  91
  92 static void     print_value(int);
  93 static void     change_value(const struct opt_t);
  94 static void     update_value(int, u_int *, u_int);
  95
  96 static void     warn_unsupported(int);
  97 static void     usage(void);
  98
  99 static void     show_verbose(const char *, int);
 100 static void     show_int_val(u_long, const char *, const char *, int);
 101 static void     show_float_val(float, const char *, const char *, int);
 102 static void     show_char_val(const char *, const char *, int);
 103 static int      str_to_opt(const char *);
 104 static u_long   str_to_long(char *, int);
 105
 106 /*
 107  * Control behavior of a FM tuner - set frequency, volume etc
 108  */
 109 int
 110 main(int argc, char **argv)
 111 {
 112         struct opt_t opt;
 113         const char *radiodev = NULL;
 114         int rd = -1;
 115         int optchar;
 116         char *param = NULL;
 117         int show_vars = 0;
 118         int set_param = 0;
 119         int silent = 0;
 120
 121         if (argc < 2) {
 122                 usage();
 123                 exit(1);
 124         }
 125
 126         radiodev = getenv(RADIO_ENV);
 127         if (radiodev == NULL)
 128                 radiodev = RADIODEVICE;
 129
 130         while ((optchar = getopt(argc, argv, "af:nw:")) != -1) {
 131                 switch (optchar) {
 132                 case 'a':
 133                         show_vars = 1;
 134                         break;
 135                 case 'f':
 136                         radiodev = optarg;
 137                         break;
 138                 case 'n':
 139                         silent = 1;
 140                         break;
 141                 case 'w':
 142                         set_param = 1;
 143                         param = optarg;
 144                         break;
 145                 default:
 146                         usage();
 147                         /* NOTREACHED */
 148                 }
 149         }
 150         argc -= optind;
 151         argv += optind;
 152
 153         rd = open(radiodev, O_RDONLY);
 154         if (rd < 0)
 155                 err(1, "%s open error", radiodev);
 156
 157         if (ioctl(rd, RIOCGINFO, &ri) < 0)
 158                 err(1, "RIOCGINFO");
 159
 160         if (argc > 1)
 161                 if (parse_opt(*(argv + 1), &opt)) {
 162                         show_verbose(varname[opt.option], silent);
 163                         print_value(opt.option);
 164                         free(opt.string);
 165                         putchar('\n');
 166                 }
 167
 168         if (set_param)
 169                 if (parse_opt(param, &opt))
 170                         do_ioctls(rd, &opt, silent);
 171
 172         if (show_vars)
 173                 print_vars(silent);
 174
 175         if (close(rd) < 0)
 176                 warn("%s close error", radiodev);
 177
 178         return 0;
 179 }
 180
 181 static void
 182 usage(void)
 183 {
 184         const char *progname = getprogname();
 185
 186         fprintf(stderr, "usage:\t%s %s\n\t%s %s\n\t%s %s\n\t%s %s\n",
 187                 progname, "[-n] variable ...",
 188                 progname, "[-n] -w name=value ...",
 189                 progname, "[-n] -a",
 190                 progname, "[-n] -f file");
 191         exit(1);
 192 }
 193
 194 static void
 195 show_verbose(const char *nick, int silent)
 196 {
 197         if (!silent)
 198                 printf("%s=", nick);
 199 }
 200
 201 static void
 202 warn_unsupported(int optval)
 203 {
 204         warnx("driver does not support `%s'", varname[optval]);
 205 }
 206
 207 static void
 208 do_ioctls(int fd, struct opt_t *o, int silent)
 209 {
 210         int oval;
 211
 212         if (fd < 0 || o == NULL)
 213                 return;
 214
 215         if (o->option == OPTION_SEARCH && !(ri.caps & RADIO_CAPS_HW_SEARCH)) {
 216                 warn_unsupported(o->option);
 217                 return;
 218         }
 219
 220         oval = o->option == OPTION_SEARCH ? OPTION_FREQUENCY : o->option;
 221         if (!silent)
 222                 printf("%s: ", varname[oval]);
 223
 224         print_value(o->option);
 225         printf(" -> ");
 226
 227         if (o->option == OPTION_SEARCH) {
 228
 229                 if (ioctl(fd, RIOCSSRCH, &o->value) < 0) {
 230                         warn("RIOCSSRCH");
 231                         return;
 232                 }
 233
 234         } else {
 235
 236                 change_value(*o);
 237                 if (ioctl(fd, RIOCSINFO, &ri) < 0) {
 238                         warn("RIOCSINFO");
 239                         return;
 240                 }
 241
 242         }
 243
 244         if (ioctl(fd, RIOCGINFO, &ri) < 0) {
 245                 warn("RIOCGINFO");
 246                 return;
 247         }
 248
 249         print_value(o->option);
 250         putchar('\n');
 251 }
 252
 253 static void
 254 change_value(const struct opt_t o)
 255 {
 256         int unsupported = 0;
 257
 258         if (o.value == VALUE_NONE)
 259                 return;
 260
 261         switch (o.option) {
 262         case OPTION_VOLUME:
 263                 update_value(o.sign, (u_int *)&ri.volume, o.value);
 264                 break;
 265         case OPTION_FREQUENCY:
 266                 update_value(o.sign, (u_int *)&ri.freq, o.value);
 267                 break;
 268         case OPTION_REFERENCE:
 269                 if (ri.caps & RADIO_CAPS_REFERENCE_FREQ)
 270                         update_value(o.sign, (u_int *)&ri.rfreq, o.value);
 271                 else
 272                         unsupported++;
 273                 break;
 274         case OPTION_MONO:
 275                 /* FALLTHROUGH */
 276         case OPTION_STEREO:
 277                 if (ri.caps & RADIO_CAPS_SET_MONO)
 278                         ri.stereo = o.option == OPTION_MONO ? !o.value : o.value;
 279                 else
 280                         unsupported++;
 281                 break;
 282         case OPTION_SENSITIVITY:
 283                 if (ri.caps & RADIO_CAPS_LOCK_SENSITIVITY)
 284                         update_value(o.sign, (u_int *)&ri.lock, o.value);
 285                 else
 286                         unsupported++;
 287                 break;
 288         case OPTION_MUTE:
 289                 ri.mute = o.value;
 290                 break;
 291         }
 292
 293         if ( unsupported )
 294                 warn_unsupported(o.option);
 295 }
 296
 297 /*
 298  * Convert string to integer representation of a parameter
 299  */
 300 static int
 301 str_to_opt(const char *topt)
 302 {
 303         int res, toptlen, varlen, len, varsize;
 304
 305         if (topt == NULL || *topt == '\0')
 306                 return OPTION_NONE;
 307
 308         varsize = sizeof(varname) / sizeof(varname[0]);
 309         toptlen = strlen(topt);
 310
 311         for (res = 0; res < varsize; res++) {
 312                 varlen = strlen(varname[res]);
 313                 len = toptlen > varlen ? toptlen : varlen;
 314                 if (strncmp(topt, varname[res], len) == 0)
 315                         return res;
 316         }
 317
 318         warnx("name not found `%s'", topt);
 319         return OPTION_NONE;
 320 }
 321
 322 static void
 323 update_value(int sign, u_int *value, u_int update)
 324 {
 325         switch (sign) {
 326         case SIGN_NONE:
 327                 *value  = update;
 328                 break;
 329         case SIGN_PLUS:
 330                 *value += update;
 331                 break;
 332         case SIGN_MINUS:
 333                 *value -= update;
 334                 break;
 335         }
 336 }
 337
 338 /*
 339  * Convert string to unsigned integer
 340  */
 341 static u_long
 342 str_to_long(char *str, int optval)
 343 {
 344         u_long val;
 345
 346         if (str == NULL || *str == '\0')
 347                 return VALUE_NONE;
 348
 349         if (optval == OPTION_FREQUENCY)
 350                 val = (u_long)1000 * atof(str);
 351         else
 352                 val = (u_long)strtol(str, (char **)NULL, 10);
 353
 354         return val;
 355 }
 356
 357 /*
 358  * parse string s into struct opt_t
 359  * return true on success, false on failure
 360  */
 361 static int
 362 parse_opt(char *s, struct opt_t *o) {
 363         const char *badvalue = "bad value `%s'";
 364         char *topt = NULL;
 365         int slen, optlen;
 366
 367         if (s == NULL || *s == '\0' || o == NULL)
 368                 return 0;
 369
 370         o->string = NULL;
 371         o->option = OPTION_NONE;
 372         o->value = VALUE_NONE;
 373         o->sign = SIGN_NONE;
 374
 375         slen = strlen(s);
 376         optlen = strcspn(s, "=");
 377
 378         /* Set only o->optval, the rest is missing */
 379         if (slen == optlen) {
 380                 o->option = str_to_opt(s);
 381                 return o->option == (int)OPTION_NONE ? 0 : 1;
 382         }
 383
 384         if (optlen > slen - 2) {
 385                 warnx(badvalue, s);
 386                 return 0;
 387         }
 388
 389         slen -= ++optlen;
 390
 391         if ((topt = (char *)malloc(optlen)) == NULL) {
 392                 warn("memory allocation error");
 393                 return 0;
 394         }
 395         strlcpy(topt, s, optlen);
 396
 397         if ((o->option = str_to_opt(topt)) == (int)OPTION_NONE) {
 398                 free(topt);
 399                 return 0;
 400         }
 401         o->string = topt;
 402
 403         topt = &s[optlen];
 404         switch (*topt) {
 405         case '+':
 406         case '-':
 407                 o->sign = (*topt == '+') ? SIGN_PLUS : SIGN_MINUS;
 408                 o->value = str_to_long(&topt[1], o->option);
 409                 break;
 410         case 'o':
 411                 if (strncmp(topt, offchar,
 412                         slen > OFFCHAR_LEN ? slen : OFFCHAR_LEN) == 0)
 413                         o->value = 0;
 414                 else if (strncmp(topt, onchar,
 415                                 slen > ONCHAR_LEN ? slen : ONCHAR_LEN) == 0)
 416                                 o->value = 1;
 417                 break;
 418         case 'u':
 419                 if (strncmp(topt, "up", slen > 2 ? slen : 2) == 0)
 420                         o->value = 1;
 421                 break;
 422         case 'd':
 423                 if (strncmp(topt, "down", slen > 4 ? slen : 4) == 0)
 424                         o->value = 0;
 425                 break;
 426         default:
 427                 if (*topt > 47 && *topt < 58)
 428                         o->value = str_to_long(topt, o->option);
 429                 break;
 430         }
 431
 432         if (o->value == VALUE_NONE) {
 433                 warnx(badvalue, topt);
 434                 return 0;
 435         }
 436
 437         return 1;
 438 }
 439
 440 /*
 441  * Print current value of the parameter.
 442  */
 443 static void
 444 print_value(int optval)
 445 {
 446         if (optval == (int)OPTION_NONE)
 447                 return;
 448
 449         switch (optval) {
 450         case OPTION_SEARCH:
 451                 /* FALLTHROUGH */
 452         case OPTION_FREQUENCY:
 453                 printf("%.2fMHz", (float)ri.freq / 1000.);
 454                 break;
 455         case OPTION_REFERENCE:
 456                 printf("%ukHz", ri.rfreq);
 457                 break;
 458         case OPTION_SENSITIVITY:
 459                 printf("%umkV", ri.lock);
 460                 break;
 461         case OPTION_MUTE:
 462                 printf(ri.mute ? onchar : offchar);
 463                 break;
 464         case OPTION_MONO:
 465                 printf(ri.stereo ? offchar : onchar);
 466                 break;
 467         case OPTION_STEREO:
 468                 printf(ri.stereo ? onchar : offchar);
 469                 break;
 470         case OPTION_VOLUME:
 471         default:
 472                 printf("%u", ri.volume);
 473                 break;
 474         }
 475 }
 476
 477 static void
 478 show_int_val(u_long val, const char *nick, const char *append, int silent)
 479 {
 480         show_verbose(nick, silent);
 481         printf("%lu%s\n", val, append);
 482 }
 483
 484 static void
 485 show_float_val(float val, const char *nick, const char *append, int silent)
 486 {
 487         show_verbose(nick, silent);
 488         printf("%.2f%s\n", val, append);
 489 }
 490
 491 static void
 492 show_char_val(const char *val, const char *nick, int silent)
 493 {
 494         show_verbose(nick, silent);
 495         printf("%s\n", val);
 496 }
 497
 498 /*
 499  * Print all available parameters
 500  */
 501 static void
 502 print_vars(int silent)
 503 {
 504         const char *delim;
 505
 506         show_int_val(ri.volume, varname[OPTION_VOLUME], "", silent);
 507         show_float_val((float)ri.freq / 1000., varname[OPTION_FREQUENCY],
 508                         "MHz", silent);
 509         show_char_val(ri.mute ? onchar : offchar, varname[OPTION_MUTE], silent);
 510
 511         if (ri.caps & RADIO_CAPS_REFERENCE_FREQ)
 512                 show_int_val(ri.rfreq, varname[OPTION_REFERENCE], "kHz", silent);
 513         if (ri.caps & RADIO_CAPS_LOCK_SENSITIVITY)
 514                 show_int_val(ri.lock, varname[OPTION_SENSITIVITY], "mkV", silent);
 515
 516         if (ri.caps & RADIO_CAPS_DETECT_SIGNAL) {
 517                 show_verbose("signal", silent);
 518                 printf("%s\n", ri.info & RADIO_INFO_SIGNAL ? onchar : offchar);
 519         }
 520         if (ri.caps & RADIO_CAPS_DETECT_STEREO) {
 521                 show_verbose(varname[OPTION_STEREO], silent);
 522                 printf("%s\n", ri.info & RADIO_INFO_STEREO ? onchar : offchar);
 523         }
 524
 525         if (!silent)
 526                 printf("card capabilities:");
 527         delim = "";
 528         if (ri.caps & RADIO_CAPS_DETECT_STEREO)
 529                 printf("%s stereo detect", delim), delim=",";
 530         if (ri.caps & RADIO_CAPS_DETECT_SIGNAL)
 531                 printf("%s signal detect", delim), delim=",";
 532         if (ri.caps & RADIO_CAPS_SET_MONO)
 533                 printf("%s manageable mono/stereo", delim), delim=",";
 534         if (ri.caps & RADIO_CAPS_HW_SEARCH)
 535                 printf("%s hardware search", delim), delim=",";
 536         if (ri.caps & RADIO_CAPS_HW_AFC)
 537                 printf("%s hardware AFC", delim), delim=",";
 538         printf("\n");
 539 }