usr/src/cmd/audio/audioctl/audioctl.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <errno.h>
  29 #include <string.h>
  30 #include <strings.h>
  31 #include <locale.h>
  32 #include <libintl.h>
  33 #include <stdarg.h>
  34 #include <stddef.h>
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <sys/mkdev.h>
  38 #include <fcntl.h>
  39 #include <unistd.h>
  40 #include <ctype.h>
  41 #include <sys/param.h>
  42 #include <sys/soundcard.h>
  43 #include <libdevinfo.h>
  44
  45 #if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
  46 #define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
  47 #endif
  48
  49 #define _(s)    gettext(s)
  50
  51 #define MAXLINE 1024
  52
  53 #define AUDIO_CTRL_STEREO_LEFT(v)       ((uint8_t)((v) & 0xff))
  54 #define AUDIO_CTRL_STEREO_RIGHT(v)      ((uint8_t)(((v) >> 8) & 0xff))
  55 #define AUDIO_CTRL_STEREO_VAL(l, r)     (((l) & 0xff) | (((r) & 0xff) << 8))
  56
  57 /*
  58  * These are borrowed from sys/audio/audio_common.h, where the values
  59  * are protected by _KERNEL.
  60  */
  61 #define AUDIO_MN_TYPE_NBITS     (4)
  62 #define AUDIO_MN_TYPE_MASK      ((1U << AUDIO_MN_TYPE_NBITS) - 1)
  63 #define AUDIO_MINOR_MIXER       (0)
  64
  65
  66 /*
  67  * Column display information
  68  * All are related to the types enumerated in col_t and any change should be
  69  * reflected in the corresponding indices and offsets for all the variables
  70  * accordingly.  Most tweaks to the display can be done by adjusting the
  71  * values here.
  72  */
  73
  74 /* types of columns displayed */
  75 typedef enum { COL_DV = 0, COL_NM, COL_VAL, COL_SEL} col_t;
  76
  77 /* corresponding sizes of columns; does not include trailing null */
  78 #define COL_DV_SZ       16
  79 #define COL_NM_SZ       24
  80 #define COL_VAL_SZ      10
  81 #define COL_SEL_SZ      20
  82 #define COL_MAX_SZ      64
  83
  84 /* corresponding sizes of columns, indexed by col_t value */
  85 static int col_sz[] = {
  86         COL_DV_SZ, COL_NM_SZ, COL_VAL_SZ, COL_SEL_SZ
  87 };
  88
  89 /* used by callers of the printing function */
  90 typedef struct col_prt {
  91         char *col_dv;
  92         char *col_nm;
  93         char *col_val;
  94         char *col_sel;
  95 } col_prt_t;
  96
  97 /* columns displayed in order with vopt = 0 */
  98 static int col_dpy[] = {COL_NM, COL_VAL};
  99 static int col_dpy_len = sizeof (col_dpy) / sizeof (*col_dpy);
 100
 101 /* tells the printing function what members to use; follows col_dpy[] */
 102 static size_t col_dpy_prt[] = {
 103         offsetof(col_prt_t, col_nm),
 104         offsetof(col_prt_t, col_val),
 105 };
 106
 107 /* columns displayed in order with vopt = 1 */
 108 static int col_dpy_vopt[] = { COL_DV, COL_NM, COL_VAL, COL_SEL};
 109 static int col_dpy_vopt_len = sizeof (col_dpy_vopt) / sizeof (*col_dpy_vopt);
 110
 111 /* tells the printing function what members to use; follows col_dpy_vopt[] */
 112 static size_t col_dpy_prt_vopt[] = {
 113         offsetof(col_prt_t, col_dv),
 114         offsetof(col_prt_t, col_nm),
 115         offsetof(col_prt_t, col_val),
 116         offsetof(col_prt_t, col_sel)
 117 };
 118
 119 /* columns displayed in order with tofile = 1 */
 120 static int col_dpy_tofile[] = { COL_NM, COL_VAL};
 121 static int col_dpy_tofile_len = sizeof (col_dpy_tofile) /
 122     sizeof (*col_dpy_tofile);
 123
 124 /* tells the printing function what members to use; follows col_dpy_tofile[] */
 125 static size_t col_dpy_prt_tofile[] = {
 126         offsetof(col_prt_t, col_nm),
 127         offsetof(col_prt_t, col_val)
 128 };
 129
 130
 131 /*
 132  * mixer and control accounting
 133  */
 134
 135 typedef struct cinfo {
 136         oss_mixext ci;
 137         oss_mixer_enuminfo *enump;
 138 } cinfo_t;
 139
 140 typedef struct device {
 141         oss_card_info   card;
 142         oss_mixerinfo   mixer;
 143
 144         int             cmax;
 145         cinfo_t         *controls;
 146
 147         int             mfd;
 148         dev_t           devt;
 149
 150         struct device   *nextp;
 151 } device_t;
 152
 153 static device_t *devices = NULL;
 154
 155 /*PRINTFLIKE1*/
 156 static void
 157 msg(char *fmt, ...)
 158 {
 159         va_list ap;
 160
 161         va_start(ap, fmt);
 162         (void) vprintf(fmt, ap);
 163         va_end(ap);
 164 }
 165
 166 /*PRINTFLIKE1*/
 167 static void
 168 warn(char *fmt, ...)
 169 {
 170         va_list ap;
 171
 172         va_start(ap, fmt);
 173         (void) vfprintf(stderr, fmt, ap);
 174         va_end(ap);
 175 }
 176
 177 static void
 178 free_device(device_t *d)
 179 {
 180         int             i;
 181         device_t        **dpp;
 182
 183         dpp = &devices;
 184         while ((*dpp) && ((*dpp) != d)) {
 185                 dpp = &((*dpp)->nextp);
 186         }
 187         if (*dpp) {
 188                 *dpp = d->nextp;
 189         }
 190         for (i = 0; i < d->cmax; i++) {
 191                 free(d->controls[i].enump);
 192         }
 193
 194         if (d->mfd >= 0)
 195                 (void) close(d->mfd);
 196
 197         free(d);
 198 }
 199
 200 static void
 201 free_devices(void)
 202 {
 203         device_t *d = devices;
 204
 205         while ((d = devices) != NULL) {
 206                 free_device(d);
 207         }
 208
 209         devices = NULL;
 210 }
 211
 212
 213 /*
 214  * adds to the end of global devices and returns a pointer to the new entry
 215  */
 216 static device_t *
 217 alloc_device(void)
 218 {
 219         device_t *p;
 220         device_t *d = calloc(1, sizeof (*d));
 221
 222         d->card.card = -1;
 223         d->mixer.dev = -1;
 224         d->mfd = -1;
 225
 226         if (devices == NULL) {
 227                 devices = d;
 228         } else {
 229                 for (p = devices; p->nextp != NULL; p = p->nextp) {}
 230
 231                 p->nextp = d;
 232         }
 233         return (d);
 234 }
 235
 236
 237 /*
 238  * cinfop->enump needs to be present
 239  * idx should be: >= 0 to < cinfop->ci.maxvalue
 240  */
 241 static char *
 242 get_enum_str(cinfo_t *cinfop, int idx)
 243 {
 244         int sz = sizeof (*cinfop->ci.enum_present) * 8;
 245
 246         if (cinfop->ci.enum_present[idx / sz] & (1 << (idx % sz)))
 247                 return (cinfop->enump->strings + cinfop->enump->strindex[idx]);
 248
 249         return (NULL);
 250 }
 251
 252
 253 /*
 254  * caller fills in d->mixer.devnode; func fills in the rest
 255  */
 256 static int
 257 get_device_info(device_t *d)
 258 {
 259         int fd = -1;
 260         int i;
 261         cinfo_t *ci;
 262
 263         if ((fd = open(d->mixer.devnode, O_RDWR)) < 0) {
 264                 perror(_("Error opening device"));
 265                 return (errno);
 266         }
 267         d->mfd = fd;
 268
 269         d->cmax = -1;
 270         if (ioctl(fd, SNDCTL_MIX_NREXT, &d->cmax) < 0) {
 271                 perror(_("Error getting control count"));
 272                 return (errno);
 273         }
 274
 275         d->controls = calloc(d->cmax, sizeof (*d->controls));
 276
 277         for (i = 0; i < d->cmax; i++) {
 278                 ci = &d->controls[i];
 279
 280                 ci->ci.dev = -1;
 281                 ci->ci.ctrl = i;
 282
 283                 if (ioctl(fd, SNDCTL_MIX_EXTINFO, &ci->ci) < 0) {
 284                         perror(_("Error getting control info"));
 285                         return (errno);
 286                 }
 287
 288                 if (ci->ci.type == MIXT_ENUM) {
 289                         ci->enump = calloc(1, sizeof (*ci->enump));
 290                         ci->enump->dev = -1;
 291                         ci->enump->ctrl = ci->ci.ctrl;
 292
 293                         if (ioctl(fd, SNDCTL_MIX_ENUMINFO, ci->enump) < 0) {
 294                                 perror(_("Error getting enum info"));
 295                                 return (errno);
 296                         }
 297                 }
 298         }
 299
 300         return (0);
 301 }
 302
 303
 304 static int
 305 load_devices(void)
 306 {
 307         int rv = -1;
 308         int fd = -1;
 309         int i;
 310         oss_sysinfo si;
 311         device_t *d;
 312
 313         if (devices != NULL) {
 314                 /* already loaded */
 315                 return (0);
 316         }
 317
 318         if ((fd = open("/dev/mixer", O_RDWR)) < 0) {
 319                 rv = errno;
 320                 warn(_("Error opening mixer\n"));
 321                 goto OUT;
 322         }
 323
 324         if (ioctl(fd, SNDCTL_SYSINFO, &si) < 0) {
 325                 rv = errno;
 326                 perror(_("Error getting system information"));
 327                 goto OUT;
 328         }
 329
 330         for (i = 0; i < si.nummixers; i++) {
 331
 332                 struct stat sbuf;
 333
 334                 d = alloc_device();
 335                 d->mixer.dev = i;
 336
 337                 if (ioctl(fd, SNDCTL_MIXERINFO, &d->mixer) != 0) {
 338                         continue;
 339                 }
 340
 341                 d->card.card = d->mixer.card_number;
 342
 343                 if ((ioctl(fd, SNDCTL_CARDINFO, &d->card) != 0) ||
 344                     (stat(d->mixer.devnode, &sbuf) != 0) ||
 345                     ((sbuf.st_mode & S_IFCHR) == 0)) {
 346                         warn(_("Device present: %s\n"), d->mixer.devnode);
 347                         free_device(d);
 348                         continue;
 349                 }
 350                 d->devt = makedev(major(sbuf.st_rdev),
 351                     minor(sbuf.st_rdev) & ~(AUDIO_MN_TYPE_MASK));
 352
 353                 if ((rv = get_device_info(d)) != 0) {
 354                         free_device(d);
 355                         goto OUT;
 356                 }
 357         }
 358
 359         rv = 0;
 360
 361 OUT:
 362         if (fd >= 0)
 363                 (void) close(fd);
 364         return (rv);
 365 }
 366
 367
 368 static int
 369 ctype_valid(int type)
 370 {
 371         switch (type) {
 372         case MIXT_ONOFF:
 373         case MIXT_ENUM:
 374         case MIXT_MONOSLIDER:
 375         case MIXT_STEREOSLIDER:
 376                 return (1);
 377         default:
 378                 return (0);
 379         }
 380 }
 381
 382
 383 static void
 384 print_control_line(FILE *sfp, col_prt_t *colp, int vopt)
 385 {
 386         int i;
 387         size_t *col_prtp;
 388         int *col_dpyp;
 389         int col_cnt;
 390         int col_type;
 391         int width;
 392         char *colstr;
 393         char cbuf[COL_MAX_SZ + 1];
 394         char line[128];
 395         char *colsep =  " ";
 396
 397         if (sfp != NULL) {
 398                 col_prtp = col_dpy_prt_tofile;
 399                 col_dpyp = col_dpy_tofile;
 400                 col_cnt = col_dpy_tofile_len;
 401         } else if (vopt) {
 402                 col_prtp = col_dpy_prt_vopt;
 403                 col_dpyp = col_dpy_vopt;
 404                 col_cnt = col_dpy_vopt_len;
 405         } else {
 406                 col_prtp = col_dpy_prt;
 407                 col_dpyp = col_dpy;
 408                 col_cnt = col_dpy_len;
 409         }
 410
 411         line[0] = '\0';
 412
 413         for (i = 0; i < col_cnt; i++) {
 414                 col_type = col_dpyp[i];
 415                 width = col_sz[col_type];
 416                 colstr = *(char **)(((size_t)colp) + col_prtp[i]);
 417
 418                 (void) snprintf(cbuf, sizeof (cbuf), "%- *s",
 419                     width > 0 ? width : 1,
 420                     (colstr == NULL) ? "" : colstr);
 421
 422                 (void) strlcat(line, cbuf, sizeof (line));
 423                 if (i < col_cnt - 1)
 424                         (void) strlcat(line, colsep, sizeof (line));
 425         }
 426
 427         (void) fprintf(sfp ? sfp : stdout, "%s\n", line);
 428 }
 429
 430
 431 static void
 432 print_header(FILE *sfp, int vopt)
 433 {
 434         col_prt_t col;
 435
 436         if (sfp) {
 437                 col.col_nm = _("#CONTROL");
 438                 col.col_val = _("VALUE");
 439         } else {
 440                 col.col_dv = _("DEVICE");
 441                 col.col_nm = _("CONTROL");
 442                 col.col_val = _("VALUE");
 443                 col.col_sel = _("POSSIBLE");
 444         }
 445         print_control_line(sfp, &col, vopt);
 446 }
 447
 448
 449 static int
 450 print_control(FILE *sfp, device_t *d, cinfo_t *cinfop, int vopt)
 451 {
 452         int mfd = d->mfd;
 453         char *devnm = d->card.shortname;
 454         oss_mixer_value cval;
 455         char *str;
 456         int i;
 457         int idx = -1;
 458         int rv = -1;
 459         char valbuf[COL_VAL_SZ + 1];
 460         char selbuf[COL_SEL_SZ + 1];
 461         col_prt_t col;
 462
 463         cval.dev = -1;
 464         cval.ctrl = cinfop->ci.ctrl;
 465
 466         if (ctype_valid(cinfop->ci.type)) {
 467                 if (ioctl(mfd, SNDCTL_MIX_READ, &cval) < 0) {
 468                         rv = errno;
 469                         perror(_("Error reading control\n"));
 470                         return (rv);
 471                 }
 472         } else {
 473                 return (0);
 474         }
 475
 476         /*
 477          * convert the control value into a string
 478          */
 479         switch (cinfop->ci.type) {
 480         case MIXT_ONOFF:
 481                 (void) snprintf(valbuf, sizeof (valbuf), "%s",
 482                     cval.value ? _("on") : _("off"));
 483                 break;
 484
 485         case MIXT_MONOSLIDER:
 486                 (void) snprintf(valbuf, sizeof (valbuf), "%d",
 487                     cval.value & 0xff);
 488                 break;
 489
 490         case MIXT_STEREOSLIDER:
 491                 (void) snprintf(valbuf, sizeof (valbuf), "%d:%d",
 492                     (int)AUDIO_CTRL_STEREO_LEFT(cval.value),
 493                     (int)AUDIO_CTRL_STEREO_RIGHT(cval.value));
 494                 break;
 495
 496         case MIXT_ENUM:
 497                 str = get_enum_str(cinfop, cval.value);
 498                 if (str == NULL) {
 499                         warn(_("Bad enum index %d for control '%s'\n"),
 500                             cval.value, cinfop->ci.extname);
 501                         return (EINVAL);
 502                 }
 503
 504                 (void) snprintf(valbuf, sizeof (valbuf), "%s", str);
 505                 break;
 506
 507         default:
 508                 return (0);
 509         }
 510
 511         /*
 512          * possible control values (range/selection)
 513          */
 514         switch (cinfop->ci.type) {
 515         case MIXT_ONOFF:
 516                 (void) snprintf(selbuf, sizeof (selbuf), _("on,off"));
 517                 break;
 518
 519         case MIXT_MONOSLIDER:
 520                 (void) snprintf(selbuf, sizeof (selbuf), "%d-%d",
 521                     cinfop->ci.minvalue, cinfop->ci.maxvalue);
 522                 break;
 523         case MIXT_STEREOSLIDER:
 524                 (void) snprintf(selbuf, sizeof (selbuf), "%d-%d:%d-%d",
 525                     cinfop->ci.minvalue, cinfop->ci.maxvalue,
 526                     cinfop->ci.minvalue, cinfop->ci.maxvalue);
 527                 break;
 528
 529         case MIXT_ENUM:
 530                 /*
 531                  * display the first choice on the same line, then display
 532                  * the rest on multiple lines
 533                  */
 534                 selbuf[0] = 0;
 535                 for (i = 0; i < cinfop->ci.maxvalue; i++) {
 536                         str = get_enum_str(cinfop, i);
 537                         if (str == NULL)
 538                                 continue;
 539
 540                         if ((strlen(str) + 1 + strlen(selbuf)) >=
 541                             sizeof (selbuf)) {
 542                                 break;
 543                         }
 544                         if (strlen(selbuf)) {
 545                                 (void) strlcat(selbuf, ",", sizeof (selbuf));
 546                         }
 547
 548                         (void) strlcat(selbuf, str, sizeof (selbuf));
 549                 }
 550                 idx = i;
 551                 break;
 552
 553         default:
 554                 (void) snprintf(selbuf, sizeof (selbuf), "-");
 555         }
 556
 557         col.col_dv = devnm;
 558         col.col_nm = strlen(cinfop->ci.extname) ?
 559             cinfop->ci.extname : cinfop->ci.id;
 560         while (strchr(col.col_nm, '_') != NULL) {
 561                 col.col_nm = strchr(col.col_nm, '_') + 1;
 562         }
 563         col.col_val = valbuf;
 564         col.col_sel = selbuf;
 565         print_control_line(sfp, &col, vopt);
 566
 567         /* non-verbose mode prints don't display the enum values */
 568         if ((!vopt) || (sfp != NULL)) {
 569                 return (0);
 570         }
 571
 572         /* print leftover enum value selections */
 573         while ((idx >= 0) && (idx < cinfop->ci.maxvalue)) {
 574                 selbuf[0] = 0;
 575                 for (i = idx; i < cinfop->ci.maxvalue; i++) {
 576                         str = get_enum_str(cinfop, i);
 577                         if (str == NULL)
 578                                 continue;
 579
 580                         if ((strlen(str) + 1 + strlen(selbuf)) >=
 581                             sizeof (selbuf)) {
 582                                 break;
 583                         }
 584                         if (strlen(selbuf)) {
 585                                 (void) strlcat(selbuf, ",", sizeof (selbuf));
 586                         }
 587
 588                         (void) strlcat(selbuf, str, sizeof (selbuf));
 589                 }
 590                 idx = i;
 591                 col.col_dv = NULL;
 592                 col.col_nm = NULL;
 593                 col.col_val = NULL;
 594                 col.col_sel = selbuf;
 595                 print_control_line(sfp, &col, vopt);
 596         }
 597
 598         return (0);
 599 }
 600
 601
 602 static int
 603 set_device_control(device_t *d, cinfo_t *cinfop, char *wstr, int vopt)
 604 {
 605         int mfd = d->mfd;
 606         oss_mixer_value cval;
 607         int wlen = strlen(wstr);
 608         int lval, rval;
 609         char *lstr, *rstr;
 610         char *str;
 611         int i;
 612         int rv = -1;
 613
 614         cval.dev = -1;
 615         cval.ctrl = cinfop->ci.ctrl;
 616         cval.value = 0;
 617
 618         switch (cinfop->ci.type) {
 619         case MIXT_ONOFF:
 620                 cval.value = (strncmp(_("on"), wstr, wlen) == 0) ? 1 : 0;
 621                 break;
 622
 623         case MIXT_MONOSLIDER:
 624                 cval.value = atoi(wstr);
 625                 break;
 626
 627         case MIXT_STEREOSLIDER:
 628                 lstr = wstr;
 629                 rstr = strchr(wstr, ':');
 630                 if (rstr != NULL) {
 631                         *rstr = '\0';
 632                         rstr++;
 633
 634                         rval = atoi(rstr);
 635                         lval = atoi(lstr);
 636
 637                         rstr--;
 638                         *rstr = ':';
 639                 } else {
 640                         lval = atoi(lstr);
 641                         rval = lval;
 642                 }
 643
 644                 cval.value = AUDIO_CTRL_STEREO_VAL(lval, rval);
 645                 break;
 646
 647         case MIXT_ENUM:
 648                 for (i = 0; i < cinfop->ci.maxvalue; i++) {
 649                         str = get_enum_str(cinfop, i);
 650                         if (str == NULL)
 651                                 continue;
 652
 653                         if (strncmp(wstr, str, wlen) == 0) {
 654                                 cval.value = i;
 655                                 break;
 656                         }
 657                 }
 658
 659                 if (i >= cinfop->ci.maxvalue) {
 660                         warn(_("Invalid enumeration value\n"));
 661                         return (EINVAL);
 662                 }
 663                 break;
 664
 665         default:
 666                 warn(_("Unsupported control type: %d\n"), cinfop->ci.type);
 667                 return (EINVAL);
 668         }
 669
 670         if (vopt) {
 671                 msg(_("%s: '%s' set to '%s'\n"), d->card.shortname,
 672                     cinfop->ci.extname, wstr);
 673         }
 674
 675         if (ioctl(mfd, SNDCTL_MIX_WRITE, &cval) < 0) {
 676                 rv = errno;
 677                 perror(_("Error writing control"));
 678                 return (rv);
 679         }
 680
 681         rv = 0;
 682         return (rv);
 683 }
 684
 685
 686 static void
 687 help(void)
 688 {
 689 #define HELP_STR        _(                                              \
 690 "audioctl list-devices\n"                                               \
 691 "       list all audio devices\n"                                       \
 692 "\n"                                                                    \
 693 "audioctl show-device [ -v ] [ -d <device> ]\n"                         \
 694 "       display information about an audio device\n"                    \
 695 "\n"                                                                    \
 696 "audioctl show-control [ -v ] [ -d <device> ] [ <control> ... ]\n"      \
 697 "       get the value of a specific control (all if not specified)\n"   \
 698 "\n"                                                                    \
 699 "audioctl set-control [ -v ] [ -d <device> ] <control> <value>\n"       \
 700 "       set the value of a specific control\n"                          \
 701 "\n"                                                                    \
 702 "audioctl save-controls [ -d <device> ] [ -f ] <file>\n"                \
 703 "       save all control settings for the device to a file\n"           \
 704 "\n"                                                                    \
 705 "audioctl load-controls [ -d <device> ] <file>\n"                       \
 706 "       restore previously saved control settings to device\n"          \
 707 "\n"                                                                    \
 708 "audioctl help\n"                                                       \
 709 "       show this message.\n")
 710
 711         (void) fprintf(stderr, HELP_STR);
 712 }
 713
 714 dev_t
 715 device_devt(char *name)
 716 {
 717         struct stat     sbuf;
 718
 719         if ((stat(name, &sbuf) != 0) ||
 720             ((sbuf.st_mode & S_IFCHR) == 0)) {
 721                 /* Not a device node! */
 722                 return (0);
 723         }
 724
 725         return (makedev(major(sbuf.st_rdev),
 726             minor(sbuf.st_rdev) & ~(AUDIO_MN_TYPE_MASK)));
 727 }
 728
 729 static device_t *
 730 find_device(char *name)
 731 {
 732         dev_t           devt;
 733         device_t        *d;
 734
 735         /*
 736          * User may have specified:
 737          *
 738          * /dev/dsp[<num>]
 739          * /dev/mixer[<num>]
 740          * /dev/audio[<num>9]
 741          * /dev/audioctl[<num>]
 742          * /dev/sound/<num>{,ctl,dsp,mixer}
 743          * /dev/sound/<driver>:<num>{,ctl,dsp,mixer}
 744          *
 745          * We can canonicalize these by looking at the dev_t though.
 746          */
 747
 748         if (load_devices() != 0) {
 749                 return (NULL);
 750         }
 751
 752         if (name == NULL)
 753                 name = getenv("AUDIODEV");
 754
 755         if ((name == NULL) ||
 756             (strcmp(name, "/dev/mixer") == 0)) {
 757                 /* /dev/mixer node doesn't point to real hw */
 758                 name = "/dev/dsp";
 759         }
 760
 761         if (*name == '/') {
 762                 /* if we have a full path, convert to the devt */
 763                 if ((devt = device_devt(name)) == 0) {
 764                         warn(_("No such audio device.\n"));
 765                         return (NULL);
 766                 }
 767                 name = NULL;
 768         }
 769
 770         for (d = devices; d != NULL; d = d->nextp) {
 771                 oss_card_info *card = &d->card;
 772
 773                 if ((name) && (strcmp(name, card->shortname) == 0)) {
 774                         return (d);
 775                 }
 776                 if (devt == d->devt) {
 777                         return (d);
 778                 }
 779         }
 780
 781         warn(_("No such audio device.\n"));
 782         return (NULL);
 783 }
 784
 785 int
 786 do_list_devices(int argc, char **argv)
 787 {
 788         int             optc;
 789         int             verbose = 0;
 790         device_t        *d;
 791
 792         while ((optc = getopt(argc, argv, "v")) != EOF) {
 793                 switch (optc) {
 794                 case 'v':
 795                         verbose++;
 796                         break;
 797                 default:
 798                         help();
 799                         return (-1);
 800                 }
 801         }
 802         argc -= optind;
 803         argv += optind;
 804         if (argc != 0) {
 805                 help();
 806                 return (-1);
 807         }
 808
 809         if (load_devices() != 0) {
 810                 return (-1);
 811         }
 812
 813         for (d = devices; d != NULL; d = d->nextp) {
 814
 815                 if ((d->mixer.enabled == 0) && (!verbose))
 816                         continue;
 817
 818                 if (verbose) {
 819                         msg(_("%s (%s)\n"), d->card.shortname,
 820                             d->mixer.devnode);
 821                 } else {
 822                         msg(_("%s\n"), d->card.shortname);
 823                 }
 824         }
 825
 826         return (0);
 827 }
 828
 829 int
 830 do_show_device(int argc, char **argv)
 831 {
 832         int             optc;
 833         char            *devname = NULL;
 834         device_t        *d;
 835
 836         while ((optc = getopt(argc, argv, "d:v")) != EOF) {
 837                 switch (optc) {
 838                 case 'd':
 839                         devname = optarg;
 840                         break;
 841                 case 'v':
 842                         break;
 843                 default:
 844                         help();
 845                         return (-1);
 846                 }
 847         }
 848         argc -= optind;
 849         argv += optind;
 850         if (argc != 0) {
 851                 help();
 852                 return (-1);
 853         }
 854
 855         if ((d = find_device(devname)) == NULL) {
 856                 return (ENODEV);
 857         }
 858
 859         msg(_("Device: %s\n"), d->mixer.devnode);
 860         msg(_("  Name    = %s\n"), d->card.shortname);
 861         msg(_("  Config  = %s\n"), d->card.longname);
 862
 863         if (strlen(d->card.hw_info)) {
 864                 msg(_("  HW Info = %s"), d->card.hw_info);
 865         }
 866
 867         return (0);
 868 }
 869
 870 int
 871 do_show_control(int argc, char **argv)
 872 {
 873         int             optc;
 874         int             rval = 0;
 875         int             verbose = 0;
 876         device_t        *d;
 877         char            *devname = NULL;
 878         int             i;
 879         int             j;
 880         int             rv;
 881         char            *n;
 882         cinfo_t         *cinfop;
 883
 884         while ((optc = getopt(argc, argv, "d:v")) != EOF) {
 885                 switch (optc) {
 886                 case 'd':
 887                         devname = optarg;
 888                         break;
 889                 case 'v':
 890                         verbose++;
 891                         break;
 892                 default:
 893                         help();
 894                         return (-1);
 895                 }
 896         }
 897         argc -= optind;
 898         argv += optind;
 899
 900         if ((d = find_device(devname)) == NULL) {
 901                 return (ENODEV);
 902         }
 903
 904         print_header(NULL, verbose);
 905         if (argc == 0) {
 906                 /* do them all! */
 907                 for (i = 0; i < d->cmax; i++) {
 908
 909                         cinfop = &d->controls[i];
 910                         rv = print_control(NULL, d, cinfop, verbose);
 911                         rval = rval ? rval : rv;
 912                 }
 913                 return (rval);
 914         }
 915
 916         for (i = 0; i < argc; i++) {
 917                 for (j = 0; j < d->cmax; j++) {
 918                         cinfop = &d->controls[j];
 919                         n = strrchr(cinfop->ci.extname, '_');
 920                         n = n ? n + 1 : cinfop->ci.extname;
 921                         if (strcmp(argv[i], n) == 0) {
 922                                 rv = print_control(NULL, d, cinfop, verbose);
 923                                 rval = rval ? rval : rv;
 924                                 break;
 925                         }
 926                 }
 927                 /* Didn't find requested control */
 928                 if (j == d->cmax) {
 929                         warn(_("No such control: %s\n"), argv[i]);
 930                         rval = rval ? rval : ENODEV;
 931                 }
 932         }
 933
 934         return (rval);
 935 }
 936
 937 int
 938 do_set_control(int argc, char **argv)
 939 {
 940         int             optc;
 941         int             rval = 0;
 942         int             verbose = 0;
 943         device_t        *d;
 944         char            *devname = NULL;
 945         char            *cname;
 946         char            *value;
 947         int             i;
 948         int             found;
 949         int             rv;
 950         char            *n;
 951         cinfo_t         *cinfop;
 952
 953         while ((optc = getopt(argc, argv, "d:v")) != EOF) {
 954                 switch (optc) {
 955                 case 'd':
 956                         devname = optarg;
 957                         break;
 958                 case 'v':
 959                         verbose = 1;
 960                         break;
 961                 default:
 962                         help();
 963                         return (-1);
 964                 }
 965         }
 966         argc -= optind;
 967         argv += optind;
 968
 969         if (argc != 2) {
 970                 help();
 971                 return (-1);
 972         }
 973         cname = argv[0];
 974         value = argv[1];
 975
 976         if ((d = find_device(devname)) == NULL) {
 977                 return (ENODEV);
 978         }
 979
 980         for (i = 0, found = 0; i < d->cmax; i++) {
 981                 cinfop = &d->controls[i];
 982                 n = strrchr(cinfop->ci.extname, '_');
 983                 n = n ? n + 1 : cinfop->ci.extname;
 984                 if (strcmp(cname, n) != 0) {
 985                         continue;
 986                 }
 987                 found = 1;
 988                 rv = set_device_control(d, cinfop, value, verbose);
 989                 rval = rval ? rval : rv;
 990         }
 991         if (!found) {
 992                 warn(_("No such control: %s\n"), cname);
 993         }
 994
 995         return (rval);
 996 }
 997
 998 int
 999 do_save_controls(int argc, char **argv)
1000 {
1001         int             optc;
1002         int             rval = 0;
1003         device_t        *d;
1004         char            *devname = NULL;
1005         char            *fname;
1006         int             i;
1007         int             rv;
1008         cinfo_t         *cinfop;
1009         FILE            *fp;
1010         int             fd;
1011         int             mode;
1012
1013         mode = O_WRONLY | O_CREAT | O_EXCL;
1014
1015         while ((optc = getopt(argc, argv, "d:f")) != EOF) {
1016                 switch (optc) {
1017                 case 'd':
1018                         devname = optarg;
1019                         break;
1020                 case 'f':
1021                         mode &= ~O_EXCL;
1022                         mode |= O_TRUNC;
1023                         break;
1024                 default:
1025                         help();
1026                         return (-1);
1027                 }
1028         }
1029         argc -= optind;
1030         argv += optind;
1031
1032         if (argc != 1) {
1033                 help();
1034                 return (-1);
1035         }
1036         fname = argv[0];
1037
1038         if ((d = find_device(devname)) == NULL) {
1039                 return (ENODEV);
1040         }
1041
1042         if ((fd = open(fname, mode, 0666)) < 0) {
1043                 perror(_("Failed to create file"));
1044                 return (errno);
1045         }
1046
1047         if ((fp = fdopen(fd, "w")) == NULL) {
1048                 perror(_("Unable to open file\n"));
1049                 (void) close(fd);
1050                 (void) unlink(fname);
1051                 return (errno);
1052         }
1053
1054         (void) fprintf(fp, "# Device: %s\n", d->mixer.devnode);
1055         (void) fprintf(fp, "# Name    = %s\n", d->card.shortname);
1056         (void) fprintf(fp, "# Config  = %s\n", d->card.longname);
1057
1058         if (strlen(d->card.hw_info)) {
1059                 (void) fprintf(fp, "# HW Info = %s", d->card.hw_info);
1060         }
1061         (void) fprintf(fp, "#\n");
1062
1063         print_header(fp, 0);
1064
1065         for (i = 0; i < d->cmax; i++) {
1066                 cinfop = &d->controls[i];
1067                 rv = print_control(fp, d, cinfop, 0);
1068                 rval = rval ? rval : rv;
1069         }
1070
1071         (void) fclose(fp);
1072
1073         return (rval);
1074 }
1075
1076 int
1077 do_load_controls(int argc, char **argv)
1078 {
1079         int     optc;
1080         int     rval = 0;
1081         device_t        *d;
1082         char            *devname = NULL;
1083         char    *fname;
1084         char    *cname;
1085         char    *value;
1086         int     i;
1087         int     rv;
1088         cinfo_t *cinfop;
1089         FILE    *fp;
1090         char    linebuf[MAXLINE];
1091         int     lineno = 0;
1092         int     found;
1093
1094         while ((optc = getopt(argc, argv, "d:")) != EOF) {
1095                 switch (optc) {
1096                 case 'd':
1097                         devname = optarg;
1098                         break;
1099                 default:
1100                         help();
1101                         return (-1);
1102                 }
1103         }
1104         argc -= optind;
1105         argv += optind;
1106
1107         if (argc != 1) {
1108                 help();
1109                 return (-1);
1110         }
1111         fname = argv[0];
1112
1113         if ((d = find_device(devname)) == NULL) {
1114                 return (ENODEV);
1115         }
1116
1117         if ((fp = fopen(fname, "r")) == NULL) {
1118                 perror(_("Unable to open file"));
1119                 return (errno);
1120         }
1121
1122         while (fgets(linebuf, sizeof (linebuf), fp) != NULL) {
1123                 lineno++;
1124                 if (linebuf[strlen(linebuf) - 1] != '\n') {
1125                         warn(_("Warning: line too long at line %d\n"), lineno);
1126                         /* read in the rest of the line and discard it */
1127                         while (fgets(linebuf, sizeof (linebuf), fp) != NULL &&
1128                             (linebuf[strlen(linebuf) - 1] != '\n')) {
1129                                 continue;
1130                         }
1131                         continue;
1132                 }
1133
1134                 /* we have a good line ... */
1135                 cname = strtok(linebuf, " \t\n");
1136                 /* skip comments and blank lines */
1137                 if ((cname == NULL) || (cname[0] == '#')) {
1138                         continue;
1139                 }
1140                 value = strtok(NULL, " \t\n");
1141                 if ((value == NULL) || (*cname == 0)) {
1142                         warn(_("Warning: missing value at line %d\n"), lineno);
1143                         continue;
1144                 }
1145
1146                 for (i = 0, found = 0; i < d->cmax; i++) {
1147                         /* save and restore requires an exact match */
1148                         cinfop = &d->controls[i];
1149                         if (strcmp(cinfop->ci.extname, cname) != 0) {
1150                                 continue;
1151                         }
1152                         found = 1;
1153                         rv = set_device_control(d, cinfop, value, 0);
1154                         rval = rval ? rval : rv;
1155                 }
1156                 if (!found) {
1157                         warn(_("No such control: %s\n"), cname);
1158                 }
1159         }
1160         (void) fclose(fp);
1161
1162         return (rval);
1163 }
1164
1165 int
1166 mixer_walker(di_devlink_t dlink, void *arg)
1167 {
1168         const char      *link;
1169         int             num;
1170         int             fd;
1171         int             verbose = *(int *)arg;
1172         int             num_offset;
1173
1174         num_offset = sizeof ("/dev/mixer") - 1;
1175
1176         link = di_devlink_path(dlink);
1177
1178         if ((link == NULL) ||
1179             (strncmp(link, "/dev/mixer", num_offset) != 0) ||
1180             (!isdigit(link[num_offset]))) {
1181                 return (DI_WALK_CONTINUE);
1182         }
1183
1184         num = atoi(link + num_offset);
1185         if ((fd = open(link, O_RDWR)) < 0) {
1186                 if (verbose) {
1187                         if (errno == ENOENT) {
1188                                 msg(_("Device %s not present.\n"), link);
1189                         } else {
1190                                 msg(_("Unable to open device %s: %s\n"),
1191                                     link, strerror(errno));
1192                         }
1193                 }
1194                 return (DI_WALK_CONTINUE);
1195         }
1196
1197         if (verbose) {
1198                 msg(_("Initializing link %s: "), link);
1199         }
1200         if (ioctl(fd, SNDCTL_SUN_SEND_NUMBER, &num) != 0) {
1201                 if (verbose) {
1202                         msg(_("failed: %s\n"), strerror(errno));
1203                 }
1204         } else {
1205                 if (verbose) {
1206                         msg(_("done.\n"));
1207                 }
1208         }
1209         (void) close(fd);
1210         return (DI_WALK_CONTINUE);
1211 }
1212
1213 int
1214 do_init_devices(int argc, char **argv)
1215 {
1216         int                     optc;
1217         di_devlink_handle_t     dlh;
1218         int                     verbose = 0;
1219
1220         while ((optc = getopt(argc, argv, "v")) != EOF) {
1221                 switch (optc) {
1222                 case 'v':
1223                         verbose = 1;
1224                         break;
1225                 default:
1226                         help();
1227                         return (-1);
1228                 }
1229         }
1230         argc -= optind;
1231         argv += optind;
1232
1233         if (argc != 0) {
1234                 help();
1235                 return (-1);
1236         }
1237
1238         dlh = di_devlink_init(NULL, 0);
1239         if (dlh == NULL) {
1240                 perror(_("Unable to initialize devlink handle"));
1241                 return (-1);
1242         }
1243
1244         if (di_devlink_walk(dlh, "^mixer", NULL, 0, &verbose,
1245             mixer_walker) != 0) {
1246                 perror(_("Unable to walk devlinks"));
1247                 return (-1);
1248         }
1249         return (0);
1250 }
1251
1252 int
1253 main(int argc, char **argv)
1254 {
1255         int rv = 0;
1256         int opt;
1257
1258         (void) setlocale(LC_ALL, "");
1259         (void) textdomain(TEXT_DOMAIN);
1260
1261         while ((opt = getopt(argc, argv, "h")) != EOF) {
1262                 switch (opt) {
1263                 case 'h':
1264                         help();
1265                         rv = 0;
1266                         goto OUT;
1267                 default:
1268                         rv = EINVAL;
1269                         break;
1270                 }
1271         }
1272
1273         if (rv) {
1274                 goto OUT;
1275         }
1276
1277         argc -= optind;
1278         argv += optind;
1279
1280         if (argc < 1) {
1281                 help();
1282                 rv = EINVAL;
1283         } else if (strcmp(argv[0], "help") == 0) {
1284                 help();
1285                 rv = 0;
1286         } else if (strcmp(argv[0], "list-devices") == 0) {
1287                 rv = do_list_devices(argc, argv);
1288         } else if (strcmp(argv[0], "show-device") == 0) {
1289                 rv = do_show_device(argc, argv);
1290         } else if (strcmp(argv[0], "show-control") == 0) {
1291                 rv = do_show_control(argc, argv);
1292         } else if (strcmp(argv[0], "set-control") == 0) {
1293                 rv = do_set_control(argc, argv);
1294         } else if (strcmp(argv[0], "load-controls") == 0) {
1295                 rv = do_load_controls(argc, argv);
1296         } else if (strcmp(argv[0], "save-controls") == 0) {
1297                 rv = do_save_controls(argc, argv);
1298         } else if (strcmp(argv[0], "init-devices") == 0) {
1299                 rv = do_init_devices(argc, argv);
1300         } else {
1301                 help();
1302                 rv = EINVAL;
1303         }
1304
1305 OUT:
1306         free_devices();
1307         return (rv);
1308 }