7377 lines
170 KiB
C
7377 lines
170 KiB
C
/* $NetBSD: audiotest.c,v 1.32 2023/12/11 09:26:08 mlelstv Exp $ */
|
|
|
|
/*
|
|
* Copyright (C) 2019 Tetsuya Isaki. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__RCSID("$NetBSD: audiotest.c,v 1.32 2023/12/11 09:26:08 mlelstv Exp $");
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#define __STDC_FORMAT_MACROS /* for PRIx64 */
|
|
#include <inttypes.h>
|
|
#include <pthread.h>
|
|
#include <stdarg.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <util.h>
|
|
#include <sys/audioio.h>
|
|
#include <sys/event.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/poll.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/time.h>
|
|
#include <sys/wait.h>
|
|
#if !defined(NO_RUMP)
|
|
#include <rump/rump.h>
|
|
#include <rump/rump_syscalls.h>
|
|
#endif
|
|
|
|
/* this internal driver option is not exported to userland */
|
|
#define AUDIO_SUPPORT_LINEAR24
|
|
|
|
#if !defined(AUDIO_ENCODING_SLINEAR_NE)
|
|
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
#define AUDIO_ENCODING_SLINEAR_NE AUDIO_ENCODING_SLINEAR_LE
|
|
#define AUDIO_ENCODING_ULINEAR_NE AUDIO_ENCODING_ULINEAR_LE
|
|
#define AUDIO_ENCODING_SLINEAR_OE AUDIO_ENCODING_SLINEAR_BE
|
|
#define AUDIO_ENCODING_ULINEAR_OE AUDIO_ENCODING_ULINEAR_BE
|
|
#else
|
|
#define AUDIO_ENCODING_SLINEAR_NE AUDIO_ENCODING_SLINEAR_BE
|
|
#define AUDIO_ENCODING_ULINEAR_NE AUDIO_ENCODING_ULINEAR_BE
|
|
#define AUDIO_ENCODING_SLINEAR_OE AUDIO_ENCODING_SLINEAR_LE
|
|
#define AUDIO_ENCODING_ULINEAR_OE AUDIO_ENCODING_ULINEAR_LE
|
|
#endif
|
|
#endif
|
|
|
|
struct testentry {
|
|
const char *name;
|
|
void (*func)(void);
|
|
};
|
|
|
|
void usage(void) __dead;
|
|
void xp_err(int, int, const char *, ...) __printflike(3, 4) __dead;
|
|
void xp_errx(int, int, const char *, ...) __printflike(3, 4) __dead;
|
|
bool match(const char *, const char *);
|
|
void xxx_close_wait(void);
|
|
int mixer_get_outputs_master(int);
|
|
void do_test(int);
|
|
int rump_or_open(const char *, int);
|
|
int rump_or_write(int, const void *, size_t);
|
|
int rump_or_read(int, void *, size_t);
|
|
int rump_or_ioctl(int, u_long, void *);
|
|
int rump_or_close(int);
|
|
int rump_or_fcntl(int, int, ...);
|
|
int rump_or_poll(struct pollfd *, nfds_t, int);
|
|
int rump_or_kqueue(void);
|
|
int rump_or_kevent(int, const struct kevent *, size_t,
|
|
struct kevent *, size_t, const struct timespec *);
|
|
int hw_canplay(void);
|
|
int hw_canrec(void);
|
|
int hw_bidir(void);
|
|
int hw_fulldup(void);
|
|
void init(int);
|
|
void *consumer_thread(void *);
|
|
void cleanup_audiofd(void);
|
|
void TEST(const char *, ...) __printflike(1, 2);
|
|
bool xp_fail(int, const char *, ...) __printflike(2, 3);
|
|
void xp_skip(int, const char *, ...) __printflike(2, 3);
|
|
bool xp_eq(int, int, int, const char *);
|
|
bool xp_eq_str(int, const char *, const char *, const char *);
|
|
bool xp_ne(int, int, int, const char *);
|
|
bool xp_if(int, bool, const char *);
|
|
bool xp_sys_eq(int, int, int, const char *);
|
|
bool xp_sys_ok(int, int, const char *);
|
|
bool xp_sys_ng(int, int, int, const char *);
|
|
bool xp_sys_ptr(int, int, void *, const char *);
|
|
int debug_open(int, const char *, int);
|
|
int debug_write(int, int, const void *, size_t);
|
|
int debug_read(int, int, void *, size_t);
|
|
int debug_ioctl(int, int, u_long, const char *, void *, const char *, ...)
|
|
__printflike(6, 7);
|
|
int debug_fcntl(int, int, int, const char *, ...) __printflike(4, 5);
|
|
int debug_close(int, int);
|
|
void *debug_mmap(int, void *, size_t, int, int, int, off_t);
|
|
int debug_munmap(int, void *, int);
|
|
const char *event_tostr(int);
|
|
int debug_poll(int, struct pollfd *, int, int);
|
|
int debug_kqueue(int);
|
|
int debug_kevent_set(int, int, const struct kevent *, size_t);
|
|
int debug_kevent_poll(int, int, struct kevent *, size_t,
|
|
const struct timespec *);
|
|
void debug_kev(int, const char *, const struct kevent *);
|
|
uid_t debug_getuid(int);
|
|
int debug_seteuid(int, uid_t);
|
|
int debug_sysctlbyname(int, const char *, void *, size_t *, const void *,
|
|
size_t);
|
|
|
|
int openable_mode(void);
|
|
int mode2aumode(int);
|
|
int mode2play(int);
|
|
int mode2rec(int);
|
|
void reset_after_mmap(void);
|
|
|
|
/* from audio.c */
|
|
static const char *encoding_names[] __unused = {
|
|
"none",
|
|
AudioEmulaw,
|
|
AudioEalaw,
|
|
"pcm16",
|
|
"pcm8",
|
|
AudioEadpcm,
|
|
AudioEslinear_le,
|
|
AudioEslinear_be,
|
|
AudioEulinear_le,
|
|
AudioEulinear_be,
|
|
AudioEslinear,
|
|
AudioEulinear,
|
|
AudioEmpeg_l1_stream,
|
|
AudioEmpeg_l1_packets,
|
|
AudioEmpeg_l1_system,
|
|
AudioEmpeg_l2_stream,
|
|
AudioEmpeg_l2_packets,
|
|
AudioEmpeg_l2_system,
|
|
AudioEac3,
|
|
};
|
|
|
|
int debug;
|
|
int props;
|
|
int hwfull;
|
|
int netbsd;
|
|
bool opt_atf;
|
|
char testname[64];
|
|
int testcount;
|
|
int failcount;
|
|
int skipcount;
|
|
int unit;
|
|
bool use_rump;
|
|
bool use_pad;
|
|
bool exact_match;
|
|
int padfd;
|
|
int maxfd;
|
|
pthread_t th;
|
|
char devicename[16]; /* "audioN" */
|
|
char devaudio[16]; /* "/dev/audioN" */
|
|
char devsound[16]; /* "/dev/soundN" */
|
|
char devaudioctl[16]; /* "/dev/audioctlN" */
|
|
char devmixer[16]; /* "/dev/mixerN" */
|
|
extern struct testentry testtable[];
|
|
|
|
void
|
|
usage(void)
|
|
{
|
|
fprintf(stderr, "usage:\t%s [<options>] [<testname>...]\n",
|
|
getprogname());
|
|
fprintf(stderr, "\t-A : make output suitable for ATF\n");
|
|
fprintf(stderr, "\t-a : Test all\n");
|
|
fprintf(stderr, "\t-d : Increase debug level\n");
|
|
fprintf(stderr, "\t-e : Use exact match for testnames "
|
|
"(default is forward match)\n");
|
|
fprintf(stderr, "\t-l : List all tests\n");
|
|
fprintf(stderr, "\t-p : Open pad\n");
|
|
#if !defined(NO_RUMP)
|
|
fprintf(stderr, "\t-R : Use rump (implies -p)\n");
|
|
#endif
|
|
fprintf(stderr, "\t-u <unit> : Use audio<unit> (default:0)\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* Customized err(3) */
|
|
void
|
|
xp_err(int code, int line, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
int backup_errno;
|
|
|
|
backup_errno = errno;
|
|
printf("%s %d: ", (opt_atf ? "Line" : " ERROR:"), line);
|
|
va_start(ap, fmt);
|
|
vprintf(fmt, ap);
|
|
va_end(ap);
|
|
printf(": %s\n", strerror(backup_errno));
|
|
|
|
exit(code);
|
|
}
|
|
|
|
/* Customized errx(3) */
|
|
void
|
|
xp_errx(int code, int line, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
printf("%s %d: ", (opt_atf ? "Line" : " ERROR:"), line);
|
|
va_start(ap, fmt);
|
|
vprintf(fmt, ap);
|
|
va_end(ap);
|
|
printf("\n");
|
|
|
|
exit(code);
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
int i;
|
|
int j;
|
|
int c;
|
|
enum {
|
|
CMD_TEST,
|
|
CMD_ALL,
|
|
CMD_LIST,
|
|
} cmd;
|
|
bool found;
|
|
|
|
props = -1;
|
|
hwfull = 0;
|
|
unit = 0;
|
|
cmd = CMD_TEST;
|
|
use_pad = false;
|
|
padfd = -1;
|
|
exact_match = false;
|
|
|
|
while ((c = getopt(argc, argv, "AadelpRu:")) != -1) {
|
|
switch (c) {
|
|
case 'A':
|
|
opt_atf = true;
|
|
break;
|
|
case 'a':
|
|
cmd = CMD_ALL;
|
|
break;
|
|
case 'd':
|
|
debug++;
|
|
break;
|
|
case 'e':
|
|
exact_match = true;
|
|
break;
|
|
case 'l':
|
|
cmd = CMD_LIST;
|
|
break;
|
|
case 'p':
|
|
use_pad = true;
|
|
break;
|
|
case 'R':
|
|
#if !defined(NO_RUMP)
|
|
use_rump = true;
|
|
use_pad = true;
|
|
#else
|
|
usage();
|
|
#endif
|
|
break;
|
|
case 'u':
|
|
unit = atoi(optarg);
|
|
break;
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (cmd == CMD_LIST) {
|
|
/* List all */
|
|
for (i = 0; testtable[i].name != NULL; i++)
|
|
printf("%s\n", testtable[i].name);
|
|
return 0;
|
|
}
|
|
|
|
init(unit);
|
|
|
|
if (cmd == CMD_ALL) {
|
|
/* Test all */
|
|
if (argc > 0)
|
|
usage();
|
|
for (i = 0; testtable[i].name != NULL; i++)
|
|
do_test(i);
|
|
} else {
|
|
/* Test only matched */
|
|
if (argc == 0)
|
|
usage();
|
|
|
|
found = false;
|
|
for (j = 0; j < argc; j++) {
|
|
for (i = 0; testtable[i].name != NULL; i++) {
|
|
if (match(argv[j], testtable[i].name)) {
|
|
do_test(i);
|
|
found = true;
|
|
}
|
|
}
|
|
}
|
|
if (!found) {
|
|
printf("test not found\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
if (opt_atf == false) {
|
|
printf("Result: %d tests, %d success",
|
|
testcount,
|
|
testcount - failcount - skipcount);
|
|
if (failcount > 0)
|
|
printf(", %d failed", failcount);
|
|
if (skipcount > 0)
|
|
printf(", %d skipped", skipcount);
|
|
printf("\n");
|
|
}
|
|
|
|
if (skipcount > 0)
|
|
return 2;
|
|
if (failcount > 0)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
match(const char *arg, const char *name)
|
|
{
|
|
if (exact_match) {
|
|
/* Exact match */
|
|
if (strcmp(arg, name) == 0)
|
|
return true;
|
|
} else {
|
|
/* Forward match */
|
|
if (strncmp(arg, name, strlen(arg)) == 0)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* XXX
|
|
* Some hardware drivers (e.g. hdafg(4)) require a little "rest" between
|
|
* close(2) and re-open(2).
|
|
* audio(4) uses hw_if->close() to tell the hardware to close. However,
|
|
* there is no agreement to wait for completion between MI and MD layer.
|
|
* audio(4) immediately shifts the "closed" state, and that is, the next
|
|
* open() will be acceptable immediately in audio layer. But the real
|
|
* hardware may not have been closed actually at that point.
|
|
* It's troublesome issue but should be fixed...
|
|
*
|
|
* However, the most frequently used pad(4) (for ATF tests) doesn't have
|
|
* such problem, so avoids it to reduce time.
|
|
*/
|
|
void
|
|
xxx_close_wait(void)
|
|
{
|
|
|
|
if (!use_pad)
|
|
usleep(500 * 1000);
|
|
}
|
|
|
|
void
|
|
do_test(int testnumber)
|
|
{
|
|
/* Sentinel */
|
|
strlcpy(testname, "<NoName>", sizeof(testname));
|
|
/* Do test */
|
|
testtable[testnumber].func();
|
|
|
|
cleanup_audiofd();
|
|
xxx_close_wait();
|
|
}
|
|
|
|
/*
|
|
* system call wrappers for rump.
|
|
*/
|
|
|
|
/* open(2) or rump_sys_open(3) */
|
|
int
|
|
rump_or_open(const char *filename, int flag)
|
|
{
|
|
int r;
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump)
|
|
r = rump_sys_open(filename, flag);
|
|
else
|
|
#endif
|
|
r = open(filename, flag);
|
|
|
|
if (r > maxfd)
|
|
maxfd = r;
|
|
return r;
|
|
}
|
|
|
|
/* write(2) or rump_sys_write(3) */
|
|
int
|
|
rump_or_write(int fd, const void *buf, size_t len)
|
|
{
|
|
int r;
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump)
|
|
r = rump_sys_write(fd, buf, len);
|
|
else
|
|
#endif
|
|
r = write(fd, buf, len);
|
|
return r;
|
|
}
|
|
|
|
/* read(2) or rump_sys_read(3) */
|
|
int
|
|
rump_or_read(int fd, void *buf, size_t len)
|
|
{
|
|
int r;
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump)
|
|
r = rump_sys_read(fd, buf, len);
|
|
else
|
|
#endif
|
|
r = read(fd, buf, len);
|
|
return r;
|
|
}
|
|
|
|
/* ioctl(2) or rump_sys_ioctl(3) */
|
|
int
|
|
rump_or_ioctl(int fd, u_long cmd, void *arg)
|
|
{
|
|
int r;
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump)
|
|
r = rump_sys_ioctl(fd, cmd, arg);
|
|
else
|
|
#endif
|
|
r = ioctl(fd, cmd, arg);
|
|
return r;
|
|
}
|
|
|
|
/* close(2) or rump_sys_close(3) */
|
|
int
|
|
rump_or_close(int fd)
|
|
{
|
|
int r;
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump)
|
|
r = rump_sys_close(fd);
|
|
else
|
|
#endif
|
|
r = close(fd);
|
|
|
|
/* maxfd-1 may not valid fd but no matter */
|
|
if (fd == maxfd)
|
|
maxfd--;
|
|
return r;
|
|
}
|
|
|
|
/* fcntl(2) or rump_sys_fcntl(3) */
|
|
/* XXX Supported only with no arguments for now */
|
|
int
|
|
rump_or_fcntl(int fd, int cmd, ...)
|
|
{
|
|
int r;
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump)
|
|
r = rump_sys_fcntl(fd, cmd);
|
|
else
|
|
#endif
|
|
r = fcntl(fd, cmd);
|
|
return r;
|
|
}
|
|
|
|
/* poll(2) or rump_sys_poll(3) */
|
|
int
|
|
rump_or_poll(struct pollfd *fds, nfds_t nfds, int timeout)
|
|
{
|
|
int r;
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump)
|
|
r = rump_sys_poll(fds, nfds, timeout);
|
|
else
|
|
#endif
|
|
r = poll(fds, nfds, timeout);
|
|
return r;
|
|
}
|
|
|
|
/* kqueue(2) or rump_sys_kqueue(3) */
|
|
int
|
|
rump_or_kqueue(void)
|
|
{
|
|
int r;
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump)
|
|
r = rump_sys_kqueue();
|
|
else
|
|
#endif
|
|
r = kqueue();
|
|
return r;
|
|
}
|
|
|
|
/* kevent(2) or rump_sys_kevent(3) */
|
|
int
|
|
rump_or_kevent(int kq, const struct kevent *chlist, size_t nch,
|
|
struct kevent *evlist, size_t nev,
|
|
const struct timespec *timeout)
|
|
{
|
|
int r;
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump)
|
|
r = rump_sys_kevent(kq, chlist, nch, evlist, nev, timeout);
|
|
else
|
|
#endif
|
|
r = kevent(kq, chlist, nch, evlist, nev, timeout);
|
|
return r;
|
|
}
|
|
|
|
int
|
|
hw_canplay(void)
|
|
{
|
|
return (props & AUDIO_PROP_PLAYBACK) ? 1 : 0;
|
|
}
|
|
|
|
int
|
|
hw_canrec(void)
|
|
{
|
|
return (props & AUDIO_PROP_CAPTURE) ? 1 : 0;
|
|
}
|
|
|
|
int
|
|
hw_bidir(void)
|
|
{
|
|
return hw_canplay() & hw_canrec();
|
|
}
|
|
|
|
int
|
|
hw_fulldup(void)
|
|
{
|
|
return (props & AUDIO_PROP_FULLDUPLEX) ? 1 : 0;
|
|
}
|
|
|
|
#define DPRINTF(fmt...) do { \
|
|
if (debug) \
|
|
printf(fmt); \
|
|
} while (0)
|
|
|
|
#define DPRINTFF(line, fmt...) do { \
|
|
if (debug) { \
|
|
printf(" > %d: ", line); \
|
|
DPRINTF(fmt); \
|
|
fflush(stdout); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define DRESULT(r) do { \
|
|
int backup_errno = errno; \
|
|
if (r == -1) { \
|
|
DPRINTF(" = %d, err#%d %s\n", \
|
|
r, backup_errno, \
|
|
strerror(backup_errno)); \
|
|
} else { \
|
|
DPRINTF(" = %d\n", r); \
|
|
} \
|
|
errno = backup_errno; \
|
|
return r; \
|
|
} while (0)
|
|
|
|
/* pointer variants for mmap */
|
|
#define DRESULT_PTR(r) do { \
|
|
int backup_errno = errno; \
|
|
if (r == (void *)-1) { \
|
|
DPRINTF(" = -1, err#%d %s\n", \
|
|
backup_errno, \
|
|
strerror(backup_errno)); \
|
|
} else { \
|
|
DPRINTF(" = %p\n", r); \
|
|
} \
|
|
errno = backup_errno; \
|
|
return r; \
|
|
} while (0)
|
|
|
|
|
|
/*
|
|
* requnit < 0: Use auto by pad (not implemented).
|
|
* requnit >= 0: Use audio<requnit>.
|
|
*/
|
|
void
|
|
init(int requnit)
|
|
{
|
|
struct audio_device devinfo;
|
|
size_t len;
|
|
int rel;
|
|
int fd;
|
|
int r;
|
|
|
|
/* XXX */
|
|
atexit(cleanup_audiofd);
|
|
|
|
if (requnit < 0) {
|
|
xp_errx(1, __LINE__, "requnit < 0 not implemented.");
|
|
} else {
|
|
unit = requnit;
|
|
}
|
|
|
|
/* Set device name */
|
|
snprintf(devicename, sizeof(devicename), "audio%d", unit);
|
|
snprintf(devaudio, sizeof(devaudio), "/dev/audio%d", unit);
|
|
snprintf(devsound, sizeof(devsound), "/dev/sound%d", unit);
|
|
snprintf(devaudioctl, sizeof(devaudioctl), "/dev/audioctl%d", unit);
|
|
snprintf(devmixer, sizeof(devmixer), "/dev/mixer%d", unit);
|
|
|
|
/*
|
|
* version
|
|
* audio2 is merged in 8.99.39.
|
|
*/
|
|
len = sizeof(rel);
|
|
r = sysctlbyname("kern.osrevision", &rel, &len, NULL, 0);
|
|
if (r == -1)
|
|
xp_err(1, __LINE__, "sysctl kern.osrevision");
|
|
netbsd = rel / 100000000;
|
|
if (rel >= 899003900)
|
|
netbsd = 9;
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump) {
|
|
DPRINTF(" use rump\n");
|
|
rump_init();
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Open pad device before all accesses (including /dev/audioctl).
|
|
*/
|
|
if (use_pad) {
|
|
padfd = rump_or_open("/dev/pad0", O_RDONLY);
|
|
if (padfd == -1)
|
|
xp_err(1, __LINE__, "rump_or_open");
|
|
|
|
/* Create consumer thread */
|
|
pthread_create(&th, NULL, consumer_thread, NULL);
|
|
/* Set this thread's name */
|
|
pthread_setname_np(pthread_self(), "main", NULL);
|
|
}
|
|
|
|
/*
|
|
* Get device properties, etc.
|
|
*/
|
|
fd = rump_or_open(devaudioctl, O_RDONLY);
|
|
if (fd == -1)
|
|
xp_err(1, __LINE__, "open %s", devaudioctl);
|
|
r = rump_or_ioctl(fd, AUDIO_GETPROPS, &props);
|
|
if (r == -1)
|
|
xp_err(1, __LINE__, "AUDIO_GETPROPS");
|
|
r = rump_or_ioctl(fd, AUDIO_GETDEV, &devinfo);
|
|
if (r == -1)
|
|
xp_err(1, __LINE__, "AUDIO_GETDEV");
|
|
rump_or_close(fd);
|
|
|
|
if (debug) {
|
|
printf(" device = %s, %s, %s\n",
|
|
devinfo.name, devinfo.version, devinfo.config);
|
|
printf(" hw props =");
|
|
if (hw_canplay())
|
|
printf(" playback");
|
|
if (hw_canrec())
|
|
printf(" capture");
|
|
if (hw_fulldup())
|
|
printf(" fullduplex");
|
|
printf("\n");
|
|
}
|
|
|
|
}
|
|
|
|
/* Consumer thread used by pad */
|
|
void *
|
|
consumer_thread(void *arg)
|
|
{
|
|
char buf[1024];
|
|
int r;
|
|
|
|
pthread_setname_np(pthread_self(), "consumer", NULL);
|
|
pthread_detach(pthread_self());
|
|
|
|
/* throw away data anyway */
|
|
for (;;) {
|
|
r = read(padfd, buf, sizeof(buf));
|
|
if (r < 1)
|
|
break;
|
|
}
|
|
|
|
pthread_exit(NULL);
|
|
}
|
|
|
|
/*
|
|
* XXX
|
|
* Closing pad descriptor before audio descriptor causes panic (PR kern/54427).
|
|
* To avoid this, close non-pad descriptor first using atexit(3) for now.
|
|
* This is just a workaround and this function should be removed.
|
|
*/
|
|
void cleanup_audiofd()
|
|
{
|
|
int fd;
|
|
|
|
for (fd = 3; fd <= maxfd; fd++) {
|
|
if (fd != padfd)
|
|
close(fd);
|
|
}
|
|
maxfd = 3;
|
|
}
|
|
|
|
/*
|
|
* Support functions
|
|
*/
|
|
|
|
/* Set testname */
|
|
void
|
|
TEST(const char *name, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, name);
|
|
vsnprintf(testname, sizeof(testname), name, ap);
|
|
va_end(ap);
|
|
if (opt_atf == false) {
|
|
printf("%s\n", testname);
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* XP_FAIL() should be called when this test fails.
|
|
* If caller already count up testcount, call xp_fail() instead.
|
|
*/
|
|
#define XP_FAIL(fmt...) do { \
|
|
testcount++; \
|
|
xp_fail(__LINE__, fmt); \
|
|
} while (0)
|
|
bool xp_fail(int line, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
printf("%s %d: ", (opt_atf ? "Line" : " FAIL:"), line);
|
|
va_start(ap, fmt);
|
|
vprintf(fmt, ap);
|
|
va_end(ap);
|
|
printf("\n");
|
|
fflush(stdout);
|
|
failcount++;
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* XP_SKIP() should be called when you want to skip this test.
|
|
* If caller already count up testcount, call xp_skip() instead.
|
|
*/
|
|
#define XP_SKIP(fmt...) do { \
|
|
testcount++; \
|
|
xp_skip(__LINE__, fmt); \
|
|
} while (0)
|
|
void xp_skip(int line, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
printf("%s %d: ", (opt_atf ? "Line" : " SKIP:"), line);
|
|
va_start(ap, fmt);
|
|
vprintf(fmt, ap);
|
|
va_end(ap);
|
|
printf("\n");
|
|
fflush(stdout);
|
|
skipcount++;
|
|
}
|
|
|
|
#define XP_EQ(exp, act) xp_eq(__LINE__, exp, act, #act)
|
|
bool xp_eq(int line, int exp, int act, const char *varname)
|
|
{
|
|
bool r = true;
|
|
|
|
testcount++;
|
|
if (exp != act) {
|
|
r = xp_fail(line, "%s expects %d but %d", varname, exp, act);
|
|
}
|
|
return r;
|
|
}
|
|
#define XP_EQ_STR(exp, act) xp_eq_str(__LINE__, exp, act, #act)
|
|
bool xp_eq_str(int line, const char *exp, const char *act, const char *varname)
|
|
{
|
|
bool r = true;
|
|
|
|
testcount++;
|
|
if (strcmp(exp, act) != 0) {
|
|
r = xp_fail(line, "%s expects \"%s\" but \"%s\"",
|
|
varname, exp, act);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
#define XP_NE(exp, act) xp_ne(__LINE__, exp, act, #act)
|
|
bool xp_ne(int line, int exp, int act, const char *varname)
|
|
{
|
|
bool r = true;
|
|
|
|
testcount++;
|
|
if (exp == act) {
|
|
r = xp_fail(line, "%s expects != %d but %d", varname, exp, act);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/* This expects that result is expressed in expr. */
|
|
/* GCC extension */
|
|
#define XP_IF(expr) xp_if(__LINE__, (expr), #expr)
|
|
bool xp_if(int line, bool expr, const char *exprname)
|
|
{
|
|
bool r = true;
|
|
testcount++;
|
|
if (!expr) {
|
|
r = xp_fail(__LINE__, "(%s) is expected but not met", exprname);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/* This expects that the system call returns 'exp'. */
|
|
#define XP_SYS_EQ(exp, act) xp_sys_eq(__LINE__, exp, act, #act)
|
|
bool xp_sys_eq(int line, int exp, int act, const char *varname)
|
|
{
|
|
bool r = true;
|
|
|
|
testcount++;
|
|
if (act == -1) {
|
|
r = xp_fail(line, "%s expects %d but -1,err#%d(%s)",
|
|
varname, exp, errno, strerror(errno));
|
|
} else {
|
|
r = xp_eq(line, exp, act, varname);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
* This expects that system call succeeds.
|
|
* This is useful when you expect the system call succeeds but don't know
|
|
* the expected return value, such as open(2).
|
|
*/
|
|
#define XP_SYS_OK(act) xp_sys_ok(__LINE__, act, #act)
|
|
bool xp_sys_ok(int line, int act, const char *varname)
|
|
{
|
|
bool r = true;
|
|
|
|
testcount++;
|
|
if (act == -1) {
|
|
r = xp_fail(line, "%s expects success but -1,err#%d(%s)",
|
|
varname, errno, strerror(errno));
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/* This expects that the system call fails with 'experrno'. */
|
|
#define XP_SYS_NG(experrno, act) xp_sys_ng(__LINE__, experrno, act, #act)
|
|
bool xp_sys_ng(int line, int experrno, int act, const char *varname)
|
|
{
|
|
bool r = true;
|
|
|
|
testcount++;
|
|
if (act != -1) {
|
|
r = xp_fail(line, "%s expects -1,err#%d but %d",
|
|
varname, experrno, act);
|
|
} else if (experrno != errno) {
|
|
char acterrbuf[100];
|
|
int acterrno = errno;
|
|
strlcpy(acterrbuf, strerror(acterrno), sizeof(acterrbuf));
|
|
r = xp_fail(line, "%s expects -1,err#%d(%s) but -1,err#%d(%s)",
|
|
varname, experrno, strerror(experrno),
|
|
acterrno, acterrbuf);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
* When exp == 0, this expects that the system call succeeds with returned
|
|
* pointer is not -1.
|
|
* When exp != 0, this expects that the system call fails with returned
|
|
* pointer is -1 and its errno is exp.
|
|
* It's only for mmap().
|
|
*/
|
|
#define XP_SYS_PTR(exp, act) xp_sys_ptr(__LINE__, exp, act, #act)
|
|
bool xp_sys_ptr(int line, int exp, void *act, const char *varname)
|
|
{
|
|
char errbuf[256];
|
|
int actual_errno;
|
|
bool r = true;
|
|
|
|
testcount++;
|
|
if (exp == 0) {
|
|
/* expects to succeed */
|
|
if (act == (void *)-1) {
|
|
r = xp_fail(line,
|
|
"%s expects success but -1,err#%d(%s)",
|
|
varname, errno, strerror(errno));
|
|
}
|
|
} else {
|
|
/* expects to fail */
|
|
if (act != (void *)-1) {
|
|
r = xp_fail(line,
|
|
"%s expects -1,err#%d(%s) but success",
|
|
varname, exp, strerror(exp));
|
|
} else if (exp != errno) {
|
|
actual_errno = errno;
|
|
strerror_r(actual_errno, errbuf, sizeof(errbuf));
|
|
r = xp_fail(line,
|
|
"%s expects -1,err#%d(%s) but -1,err#%d(%s)",
|
|
varname, exp, strerror(exp), actual_errno, errbuf);
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
|
|
/*
|
|
* REQUIRED_* return immediately if condition does not meet.
|
|
*/
|
|
#define REQUIRED_EQ(e, a) do { if (!XP_EQ(e, a)) return; } while (0)
|
|
#define REQUIRED_NE(e, a) do { if (!XP_NE(e, a)) return; } while (0)
|
|
#define REQUIRED_IF(expr) do { if (!XP_IF(expr)) return; } while (0)
|
|
#define REQUIRED_SYS_EQ(e, a) do { if (!XP_SYS_EQ(e, a)) return; } while (0)
|
|
#define REQUIRED_SYS_OK(a) do { if (!XP_SYS_OK(a)) return; } while (0)
|
|
|
|
|
|
static const char *openmode_str[] = {
|
|
"O_RDONLY",
|
|
"O_WRONLY",
|
|
"O_RDWR",
|
|
};
|
|
|
|
|
|
/*
|
|
* All system calls in following tests should be called with these macros.
|
|
*/
|
|
|
|
#define OPEN(name, mode) \
|
|
debug_open(__LINE__, name, mode)
|
|
int debug_open(int line, const char *name, int mode)
|
|
{
|
|
char modestr[32];
|
|
int n;
|
|
|
|
if ((mode & 3) != 3) {
|
|
n = snprintf(modestr, sizeof(modestr), "%s",
|
|
openmode_str[mode & 3]);
|
|
} else {
|
|
n = snprintf(modestr, sizeof(modestr), "%d", mode & 3);
|
|
}
|
|
if ((mode & O_NONBLOCK))
|
|
n += snprintf(modestr + n, sizeof(modestr) - n, "|O_NONBLOCK");
|
|
|
|
DPRINTFF(line, "open(\"%s\", %s)", name, modestr);
|
|
int r = rump_or_open(name, mode);
|
|
DRESULT(r);
|
|
}
|
|
|
|
#define WRITE(fd, addr, len) \
|
|
debug_write(__LINE__, fd, addr, len)
|
|
int debug_write(int line, int fd, const void *addr, size_t len)
|
|
{
|
|
DPRINTFF(line, "write(%d, %p, %zd)", fd, addr, len);
|
|
int r = rump_or_write(fd, addr, len);
|
|
DRESULT(r);
|
|
}
|
|
|
|
#define READ(fd, addr, len) \
|
|
debug_read(__LINE__, fd, addr, len)
|
|
int debug_read(int line, int fd, void *addr, size_t len)
|
|
{
|
|
DPRINTFF(line, "read(%d, %p, %zd)", fd, addr, len);
|
|
int r = rump_or_read(fd, addr, len);
|
|
DRESULT(r);
|
|
}
|
|
|
|
/*
|
|
* addrstr is the comment for debug message.
|
|
* int onoff = 0;
|
|
* ioctl(fd, SWITCH, onoff); -> IOCTL(fd, SWITCH, onoff, "off");
|
|
*/
|
|
#define IOCTL(fd, name, addr, addrfmt...) \
|
|
debug_ioctl(__LINE__, fd, name, #name, addr, addrfmt)
|
|
int debug_ioctl(int line, int fd, u_long name, const char *namestr,
|
|
void *addr, const char *addrfmt, ...)
|
|
{
|
|
char addrbuf[100];
|
|
va_list ap;
|
|
|
|
va_start(ap, addrfmt);
|
|
vsnprintf(addrbuf, sizeof(addrbuf), addrfmt, ap);
|
|
va_end(ap);
|
|
DPRINTFF(line, "ioctl(%d, %s, %s)", fd, namestr, addrbuf);
|
|
int r = rump_or_ioctl(fd, name, addr);
|
|
DRESULT(r);
|
|
}
|
|
|
|
#define FCNTL(fd, name...) \
|
|
debug_fcntl(__LINE__, fd, name, #name)
|
|
int debug_fcntl(int line, int fd, int name, const char *namestr, ...)
|
|
{
|
|
int r;
|
|
|
|
switch (name) {
|
|
case F_GETFL: /* no arguments */
|
|
DPRINTFF(line, "fcntl(%d, %s)", fd, namestr);
|
|
r = rump_or_fcntl(fd, name);
|
|
break;
|
|
default:
|
|
__unreachable();
|
|
}
|
|
DRESULT(r);
|
|
return r;
|
|
}
|
|
|
|
#define CLOSE(fd) \
|
|
debug_close(__LINE__, fd)
|
|
int debug_close(int line, int fd)
|
|
{
|
|
DPRINTFF(line, "close(%d)", fd);
|
|
int r = rump_or_close(fd);
|
|
DRESULT(r);
|
|
}
|
|
|
|
#define MMAP(ptr, len, prot, flags, fd, offset) \
|
|
debug_mmap(__LINE__, ptr, len, prot, flags, fd, offset)
|
|
void *debug_mmap(int line, void *ptr, size_t len, int prot, int flags, int fd,
|
|
off_t offset)
|
|
{
|
|
char protbuf[256];
|
|
char flagbuf[256];
|
|
int n;
|
|
|
|
#define ADDFLAG(buf, var, name) do { \
|
|
if (((var) & (name))) \
|
|
n = strlcat(buf, "|" #name, sizeof(buf)); \
|
|
(var) &= ~(name); \
|
|
} while (0)
|
|
|
|
n = 0;
|
|
protbuf[n] = '\0';
|
|
if (prot == 0) {
|
|
strlcpy(protbuf, "|PROT_NONE", sizeof(protbuf));
|
|
} else {
|
|
ADDFLAG(protbuf, prot, PROT_EXEC);
|
|
ADDFLAG(protbuf, prot, PROT_WRITE);
|
|
ADDFLAG(protbuf, prot, PROT_READ);
|
|
if (prot != 0) {
|
|
snprintf(protbuf + n, sizeof(protbuf) - n,
|
|
"|prot=0x%x", prot);
|
|
}
|
|
}
|
|
|
|
n = 0;
|
|
flagbuf[n] = '\0';
|
|
if (flags == 0) {
|
|
strlcpy(flagbuf, "|MAP_FILE", sizeof(flagbuf));
|
|
} else {
|
|
ADDFLAG(flagbuf, flags, MAP_SHARED);
|
|
ADDFLAG(flagbuf, flags, MAP_PRIVATE);
|
|
ADDFLAG(flagbuf, flags, MAP_FIXED);
|
|
ADDFLAG(flagbuf, flags, MAP_INHERIT);
|
|
ADDFLAG(flagbuf, flags, MAP_HASSEMAPHORE);
|
|
ADDFLAG(flagbuf, flags, MAP_TRYFIXED);
|
|
ADDFLAG(flagbuf, flags, MAP_WIRED);
|
|
ADDFLAG(flagbuf, flags, MAP_ANON);
|
|
if (flags != 0) {
|
|
n += snprintf(flagbuf + n, sizeof(flagbuf) - n,
|
|
"|flag=0x%x", flags);
|
|
}
|
|
}
|
|
|
|
DPRINTFF(line, "mmap(%p, %zd, %s, %s, %d, %jd)",
|
|
ptr, len, protbuf + 1, flagbuf + 1, fd, offset);
|
|
void *r = mmap(ptr, len, prot, flags, fd, offset);
|
|
DRESULT_PTR(r);
|
|
}
|
|
|
|
#define MUNMAP(ptr, len) \
|
|
debug_munmap(__LINE__, ptr, len)
|
|
int debug_munmap(int line, void *ptr, int len)
|
|
{
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump)
|
|
xp_errx(1, __LINE__, "rump doesn't support munmap");
|
|
#endif
|
|
DPRINTFF(line, "munmap(%p, %d)", ptr, len);
|
|
int r = munmap(ptr, len);
|
|
DRESULT(r);
|
|
}
|
|
|
|
const char *
|
|
event_tostr(int events)
|
|
{
|
|
static char buf[64];
|
|
|
|
snprintb(buf, sizeof(buf),
|
|
"\177\020" \
|
|
"b\10WRBAND\0" \
|
|
"b\7RDBAND\0" "b\6RDNORM\0" "b\5NVAL\0" "b\4HUP\0" \
|
|
"b\3ERR\0" "b\2OUT\0" "b\1PRI\0" "b\0IN\0",
|
|
events);
|
|
return buf;
|
|
}
|
|
|
|
#define POLL(pfd, nfd, timeout) \
|
|
debug_poll(__LINE__, pfd, nfd, timeout)
|
|
int debug_poll(int line, struct pollfd *pfd, int nfd, int timeout)
|
|
{
|
|
char buf[256];
|
|
int n = 0;
|
|
buf[n] = '\0';
|
|
for (int i = 0; i < nfd; i++) {
|
|
n += snprintf(buf + n, sizeof(buf) - n, "{fd=%d,events=%s}",
|
|
pfd[i].fd, event_tostr(pfd[i].events));
|
|
}
|
|
DPRINTFF(line, "poll(%s, %d, %d)", buf, nfd, timeout);
|
|
int r = rump_or_poll(pfd, nfd, timeout);
|
|
DRESULT(r);
|
|
}
|
|
|
|
#define KQUEUE() \
|
|
debug_kqueue(__LINE__)
|
|
int debug_kqueue(int line)
|
|
{
|
|
DPRINTFF(line, "kqueue()");
|
|
int r = rump_or_kqueue();
|
|
DRESULT(r);
|
|
}
|
|
|
|
#define KEVENT_SET(kq, kev, nev) \
|
|
debug_kevent_set(__LINE__, kq, kev, nev)
|
|
int debug_kevent_set(int line, int kq, const struct kevent *kev, size_t nev)
|
|
{
|
|
DPRINTFF(line, "kevent_set(%d, %p, %zd)", kq, kev, nev);
|
|
int r = rump_or_kevent(kq, kev, nev, NULL, 0, NULL);
|
|
DRESULT(r);
|
|
}
|
|
|
|
#define KEVENT_POLL(kq, kev, nev, ts) \
|
|
debug_kevent_poll(__LINE__, kq, kev, nev, ts)
|
|
int debug_kevent_poll(int line, int kq, struct kevent *kev, size_t nev,
|
|
const struct timespec *ts)
|
|
{
|
|
char tsbuf[32];
|
|
|
|
if (ts == NULL) {
|
|
snprintf(tsbuf, sizeof(tsbuf), "NULL");
|
|
} else if (ts->tv_sec == 0 && ts->tv_nsec == 0) {
|
|
snprintf(tsbuf, sizeof(tsbuf), "0.0");
|
|
} else {
|
|
snprintf(tsbuf, sizeof(tsbuf), "%d.%09ld",
|
|
(int)ts->tv_sec, ts->tv_nsec);
|
|
}
|
|
DPRINTFF(line, "kevent_poll(%d, %p, %zd, %s)", kq, kev, nev, tsbuf);
|
|
int r = rump_or_kevent(kq, NULL, 0, kev, nev, ts);
|
|
DRESULT(r);
|
|
}
|
|
|
|
#define DEBUG_KEV(name, kev) \
|
|
debug_kev(__LINE__, name, kev)
|
|
void debug_kev(int line, const char *name, const struct kevent *kev)
|
|
{
|
|
char flagbuf[256];
|
|
const char *filterbuf;
|
|
uint32_t v;
|
|
int n;
|
|
|
|
n = 0;
|
|
flagbuf[n] = '\0';
|
|
if (kev->flags == 0) {
|
|
strcpy(flagbuf, "|0?");
|
|
} else {
|
|
v = kev->flags;
|
|
ADDFLAG(flagbuf, v, EV_ADD);
|
|
if (v != 0)
|
|
snprintf(flagbuf + n, sizeof(flagbuf)-n, "|0x%x", v);
|
|
}
|
|
|
|
switch (kev->filter) {
|
|
case EVFILT_READ: filterbuf = "EVFILT_READ"; break;
|
|
case EVFILT_WRITE: filterbuf = "EVFILT_WRITE"; break;
|
|
default: filterbuf = "EVFILT_?"; break;
|
|
}
|
|
|
|
DPRINTFF(line,
|
|
"%s={id:%d,%s,%s,fflags:0x%x,data:0x%" PRIx64 ",udata:0x%x}\n",
|
|
name,
|
|
(int)kev->ident,
|
|
flagbuf + 1,
|
|
filterbuf,
|
|
kev->fflags,
|
|
kev->data,
|
|
(int)(intptr_t)kev->udata);
|
|
}
|
|
|
|
/* XXX rump? */
|
|
#define GETUID() \
|
|
debug_getuid(__LINE__)
|
|
uid_t debug_getuid(int line)
|
|
{
|
|
DPRINTFF(line, "getuid");
|
|
uid_t r = getuid();
|
|
/* getuid() never fails */
|
|
DPRINTF(" = %u\n", r);
|
|
return r;
|
|
}
|
|
|
|
/* XXX rump? */
|
|
#define SETEUID(id) \
|
|
debug_seteuid(__LINE__, id)
|
|
int debug_seteuid(int line, uid_t id)
|
|
{
|
|
DPRINTFF(line, "seteuid(%d)", (int)id);
|
|
int r = seteuid(id);
|
|
DRESULT(r);
|
|
}
|
|
|
|
#define SYSCTLBYNAME(name, oldp, oldlenp, newp, newlen) \
|
|
debug_sysctlbyname(__LINE__, name, oldp, oldlenp, newp, newlen)
|
|
int debug_sysctlbyname(int line, const char *name, void *oldp, size_t *oldlenp,
|
|
const void *newp, size_t newlen)
|
|
{
|
|
DPRINTFF(line, "sysctlbyname(\"%s\")", name);
|
|
int r = sysctlbyname(name, oldp, oldlenp, newp, newlen);
|
|
DRESULT(r);
|
|
}
|
|
|
|
|
|
/* Return openable mode on this hardware property */
|
|
int
|
|
openable_mode(void)
|
|
{
|
|
if (hw_bidir())
|
|
return O_RDWR;
|
|
if (hw_canplay())
|
|
return O_WRONLY;
|
|
else
|
|
return O_RDONLY;
|
|
}
|
|
|
|
int mode2aumode_full[] = {
|
|
AUMODE_RECORD, /* O_RDONLY */
|
|
AUMODE_PLAY | AUMODE_PLAY_ALL, /* O_WRONLY */
|
|
AUMODE_PLAY | AUMODE_PLAY_ALL | AUMODE_RECORD, /* O_RDWR */
|
|
};
|
|
|
|
/* Convert openmode(O_*) to AUMODE_*, with hardware property */
|
|
int
|
|
mode2aumode(int mode)
|
|
{
|
|
int aumode;
|
|
|
|
aumode = mode2aumode_full[mode];
|
|
if (hw_canplay() == 0)
|
|
aumode &= ~(AUMODE_PLAY | AUMODE_PLAY_ALL);
|
|
if (hw_canrec() == 0)
|
|
aumode &= ~AUMODE_RECORD;
|
|
|
|
if (netbsd >= 9) {
|
|
/* half-duplex treats O_RDWR as O_WRONLY */
|
|
if (mode == O_RDWR && hw_bidir() && hw_fulldup() == 0)
|
|
aumode &= ~AUMODE_RECORD;
|
|
}
|
|
|
|
return aumode;
|
|
}
|
|
|
|
/* Is this mode + hardware playable? */
|
|
int
|
|
mode2play(int mode)
|
|
{
|
|
int aumode;
|
|
|
|
aumode = mode2aumode(mode);
|
|
return ((aumode & AUMODE_PLAY)) ? 1 : 0;
|
|
}
|
|
|
|
/* Is this mode + hardware recordable? */
|
|
int
|
|
mode2rec(int mode)
|
|
{
|
|
int aumode;
|
|
|
|
aumode = mode2aumode(mode);
|
|
return ((aumode & AUMODE_RECORD)) ? 1 : 0;
|
|
}
|
|
|
|
/*
|
|
* On NetBSD7, open() after-closing-mmap fails due to a bug.
|
|
* It happens once every two times like flip-flop, so the workaround is
|
|
* to open it again.
|
|
*/
|
|
void
|
|
reset_after_mmap(void)
|
|
{
|
|
int fd;
|
|
|
|
if (netbsd < 8) {
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
if (fd != -1)
|
|
CLOSE(fd);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Lookup "outputs.master" and return its mixer device index.
|
|
* It may not be strict but I'm not sure.
|
|
*/
|
|
int
|
|
mixer_get_outputs_master(int mixerfd)
|
|
{
|
|
const char * const typename[] = { "CLASS", "ENUM", "SET", "VALUE" };
|
|
mixer_devinfo_t di;
|
|
int class_outputs;
|
|
int i;
|
|
int r;
|
|
|
|
class_outputs = -1;
|
|
for (i = 0; ; i++) {
|
|
memset(&di, 0, sizeof(di));
|
|
di.index = i;
|
|
r = IOCTL(mixerfd, AUDIO_MIXER_DEVINFO, &di, "index=%d", i);
|
|
if (r < 0)
|
|
break;
|
|
DPRINTF(" > type=%s(%d) mixer_class=%d name=%s\n",
|
|
(0 <= di.type && di.type <= 3) ? typename[di.type] : "",
|
|
di.type, di.mixer_class, di.label.name);
|
|
if (di.type == AUDIO_MIXER_CLASS &&
|
|
strcmp(di.label.name, "outputs") == 0) {
|
|
class_outputs = di.mixer_class;
|
|
DPRINTF(" > class_output=%d\n", class_outputs);
|
|
continue;
|
|
}
|
|
if (di.type == AUDIO_MIXER_VALUE &&
|
|
di.mixer_class == class_outputs &&
|
|
strcmp(di.label.name, "master") == 0) {
|
|
return i;
|
|
}
|
|
}
|
|
/* Not found */
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Tests
|
|
*/
|
|
|
|
void test_open_mode(int);
|
|
void test_open(const char *, int);
|
|
void test_open_simul(int, int);
|
|
void try_open_multiuser(bool);
|
|
void test_open_multiuser(bool);
|
|
void test_rdwr_fallback(int, bool, bool);
|
|
void test_rdwr_two(int, int);
|
|
void test_mmap_mode(int, int);
|
|
void test_mmap_len(size_t, off_t, int);
|
|
void test_poll_mode(int, int, int);
|
|
void test_poll_in_open(const char *);
|
|
void test_kqueue_mode(int, int, int);
|
|
volatile int sigio_caught;
|
|
void signal_FIOASYNC(int);
|
|
void test_AUDIO_SETFD_xxONLY(int);
|
|
void test_AUDIO_SETINFO_mode(int, int, int, int);
|
|
void test_AUDIO_SETINFO_params_set(int, int, int);
|
|
void test_AUDIO_SETINFO_pause(int, int, int);
|
|
int getenc_make_table(int, int[][5]);
|
|
void xp_getenc(int[][5], int, int, int, struct audio_prinfo *);
|
|
void getenc_check_encodings(int, int[][5]);
|
|
void test_AUDIO_ERROR(int);
|
|
void test_AUDIO_GETIOFFS_one(int);
|
|
void test_AUDIO_GETOOFFS_one(int);
|
|
void test_AUDIO_GETOOFFS_wrap(int);
|
|
void test_AUDIO_GETOOFFS_flush(int);
|
|
void test_AUDIO_GETOOFFS_set(int);
|
|
void test_audioctl_open_1(int, int);
|
|
void test_audioctl_open_2(int, int);
|
|
void try_audioctl_open_multiuser(const char *, const char *);
|
|
void test_audioctl_open_multiuser(bool, const char *, const char *);
|
|
void test_audioctl_rw(int);
|
|
|
|
#define DEF(name) \
|
|
void test__ ## name (void); \
|
|
void test__ ## name (void)
|
|
|
|
/*
|
|
* Whether it can be open()ed with specified mode.
|
|
*/
|
|
void
|
|
test_open_mode(int mode)
|
|
{
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("open_mode_%s", openmode_str[mode] + 2);
|
|
|
|
fd = OPEN(devaudio, mode);
|
|
if (mode2aumode(mode) != 0) {
|
|
XP_SYS_OK(fd);
|
|
} else {
|
|
XP_SYS_NG(ENXIO, fd);
|
|
}
|
|
|
|
if (fd >= 0) {
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
}
|
|
DEF(open_mode_RDONLY) { test_open_mode(O_RDONLY); }
|
|
DEF(open_mode_WRONLY) { test_open_mode(O_WRONLY); }
|
|
DEF(open_mode_RDWR) { test_open_mode(O_RDWR); }
|
|
|
|
/*
|
|
* Check the initial parameters and stickiness.
|
|
* /dev/audio
|
|
* The initial parameters are always the same whenever you open.
|
|
* /dev/sound and /dev/audioctl
|
|
* The initial parameters are inherited from the last /dev/sound or
|
|
* /dev/audio.
|
|
*/
|
|
void
|
|
test_open(const char *devname, int mode)
|
|
{
|
|
struct audio_info ai;
|
|
struct audio_info ai0;
|
|
char devfile[16];
|
|
int fd;
|
|
int r;
|
|
int can_play;
|
|
int can_rec;
|
|
int exp_mode;
|
|
int exp_encoding;
|
|
int exp_precision;
|
|
int exp_channels;
|
|
int exp_sample_rate;
|
|
int exp_pause;
|
|
int exp_popen;
|
|
int exp_ropen;
|
|
|
|
TEST("open_%s_%s", devname, openmode_str[mode] + 2);
|
|
|
|
snprintf(devfile, sizeof(devfile), "/dev/%s%d", devname, unit);
|
|
can_play = mode2play(mode);
|
|
can_rec = mode2rec(mode);
|
|
if (strcmp(devname, "audioctl") != 0) {
|
|
if (can_play + can_rec == 0) {
|
|
/* Check whether it cannot be opened */
|
|
fd = OPEN(devaudio, mode);
|
|
XP_SYS_NG(ENXIO, fd);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* /dev/audio is always initialized */
|
|
if (strcmp(devname, "audio") == 0) {
|
|
exp_encoding = AUDIO_ENCODING_ULAW;
|
|
exp_precision = 8;
|
|
exp_channels = 1;
|
|
exp_sample_rate = 8000;
|
|
exp_pause = 0;
|
|
} else {
|
|
exp_encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
exp_precision = 16;
|
|
exp_channels = 2;
|
|
exp_sample_rate = 11025;
|
|
exp_pause = 1;
|
|
}
|
|
|
|
/* /dev/audioctl is always "not opened" */
|
|
if (strcmp(devname, "audioctl") == 0) {
|
|
exp_mode = 0;
|
|
exp_popen = 0;
|
|
exp_ropen = 0;
|
|
} else {
|
|
exp_mode = mode2aumode(mode);
|
|
exp_popen = can_play;
|
|
exp_ropen = can_rec;
|
|
}
|
|
|
|
|
|
/*
|
|
* At first, initialize the sticky parameters both of play and rec.
|
|
* This uses /dev/audio to verify /dev/audio. It's not good way but
|
|
* I don't have better one...
|
|
*/
|
|
fd = OPEN(devaudio, openable_mode());
|
|
REQUIRED_SYS_OK(fd);
|
|
r = CLOSE(fd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/*
|
|
* Open target device and check the initial parameters
|
|
* At this moment, all devices are initialized by default.
|
|
*/
|
|
fd = OPEN(devfile, mode);
|
|
REQUIRED_SYS_OK(fd);
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
XP_NE(0, ai.blocksize);
|
|
/* hiwat/lowat */
|
|
XP_EQ(exp_mode, ai.mode);
|
|
/* ai.play */
|
|
XP_EQ(8000, ai.play.sample_rate);
|
|
XP_EQ(1, ai.play.channels);
|
|
XP_EQ(8, ai.play.precision);
|
|
XP_EQ(AUDIO_ENCODING_ULAW, ai.play.encoding);
|
|
/* gain */
|
|
/* port */
|
|
XP_EQ(0, ai.play.seek);
|
|
/* avail_ports */
|
|
XP_NE(0, ai.play.buffer_size);
|
|
XP_EQ(0, ai.play.samples);
|
|
XP_EQ(0, ai.play.eof);
|
|
XP_EQ(0, ai.play.pause);
|
|
XP_EQ(0, ai.play.error);
|
|
XP_EQ(0, ai.play.waiting);
|
|
/* balance */
|
|
XP_EQ(exp_popen, ai.play.open);
|
|
XP_EQ(0, ai.play.active);
|
|
/* ai.record */
|
|
XP_EQ(8000, ai.record.sample_rate);
|
|
XP_EQ(1, ai.record.channels);
|
|
XP_EQ(8, ai.record.precision);
|
|
XP_EQ(AUDIO_ENCODING_ULAW, ai.record.encoding);
|
|
/* gain */
|
|
/* port */
|
|
XP_EQ(0, ai.record.seek);
|
|
/* avail_ports */
|
|
XP_NE(0, ai.record.buffer_size);
|
|
XP_EQ(0, ai.record.samples);
|
|
XP_EQ(0, ai.record.eof);
|
|
XP_EQ(0, ai.record.pause);
|
|
XP_EQ(0, ai.record.error);
|
|
XP_EQ(0, ai.record.waiting);
|
|
/* balance */
|
|
XP_EQ(exp_ropen, ai.record.open);
|
|
if (netbsd < 9 && strcmp(devname, "sound") == 0) {
|
|
/*
|
|
* On NetBSD7/8, it doesn't seem to start recording on open
|
|
* for /dev/sound. It should be a bug.
|
|
*/
|
|
XP_EQ(0, ai.record.active);
|
|
} else {
|
|
XP_EQ(exp_ropen, ai.record.active);
|
|
}
|
|
/* Save it */
|
|
ai0 = ai;
|
|
|
|
/*
|
|
* Change much as possible
|
|
*/
|
|
AUDIO_INITINFO(&ai);
|
|
ai.mode = ai0.mode ^ AUMODE_PLAY_ALL;
|
|
ai.play.sample_rate = 11025;
|
|
ai.play.channels = 2;
|
|
ai.play.precision = 16;
|
|
ai.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
ai.play.pause = 1;
|
|
ai.record.sample_rate = 11025;
|
|
ai.record.channels = 2;
|
|
ai.record.precision = 16;
|
|
ai.record.encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
ai.record.pause = 1;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "ai");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
r = CLOSE(fd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/*
|
|
* Open the same target device again and check
|
|
*/
|
|
fd = OPEN(devfile, mode);
|
|
REQUIRED_SYS_OK(fd);
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
XP_NE(0, ai.blocksize);
|
|
/* hiwat/lowat */
|
|
if (netbsd < 8) {
|
|
/*
|
|
* On NetBSD7, the behavior when changing ai.mode on
|
|
* /dev/audioctl can not be explained yet but I won't
|
|
* verify it more over.
|
|
*/
|
|
} else {
|
|
/* On NetBSD9, changing mode never affects other fds */
|
|
XP_EQ(exp_mode, ai.mode);
|
|
}
|
|
/* ai.play */
|
|
XP_EQ(exp_sample_rate, ai.play.sample_rate);
|
|
XP_EQ(exp_channels, ai.play.channels);
|
|
XP_EQ(exp_precision, ai.play.precision);
|
|
XP_EQ(exp_encoding, ai.play.encoding);
|
|
/* gain */
|
|
/* port */
|
|
XP_EQ(0, ai.play.seek);
|
|
/* avail_ports */
|
|
XP_NE(0, ai.play.buffer_size);
|
|
XP_EQ(0, ai.play.samples);
|
|
XP_EQ(0, ai.play.eof);
|
|
XP_EQ(exp_pause, ai.play.pause);
|
|
XP_EQ(0, ai.play.error);
|
|
XP_EQ(0, ai.play.waiting);
|
|
/* balance */
|
|
XP_EQ(exp_popen, ai.play.open);
|
|
XP_EQ(0, ai.play.active);
|
|
/* ai.record */
|
|
XP_EQ(exp_sample_rate, ai.record.sample_rate);
|
|
XP_EQ(exp_channels, ai.record.channels);
|
|
XP_EQ(exp_precision, ai.record.precision);
|
|
XP_EQ(exp_encoding, ai.record.encoding);
|
|
/* gain */
|
|
/* port */
|
|
XP_EQ(0, ai.record.seek);
|
|
/* avail_ports */
|
|
XP_NE(0, ai.record.buffer_size);
|
|
XP_EQ(0, ai.record.samples);
|
|
XP_EQ(0, ai.record.eof);
|
|
XP_EQ(exp_pause, ai.record.pause);
|
|
XP_EQ(0, ai.record.error);
|
|
XP_EQ(0, ai.record.waiting);
|
|
/* balance */
|
|
XP_EQ(exp_ropen, ai.record.open);
|
|
if (netbsd < 9 && strcmp(devname, "sound") == 0) {
|
|
/*
|
|
* On NetBSD7/8, it doesn't seem to start recording on open
|
|
* for /dev/sound. It should be a bug.
|
|
*/
|
|
XP_EQ(0, ai.record.active);
|
|
} else {
|
|
XP_EQ(exp_ropen, ai.record.active);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
}
|
|
DEF(open_audio_RDONLY) { test_open("audio", O_RDONLY); }
|
|
DEF(open_audio_WRONLY) { test_open("audio", O_WRONLY); }
|
|
DEF(open_audio_RDWR) { test_open("audio", O_RDWR); }
|
|
DEF(open_sound_RDONLY) { test_open("sound", O_RDONLY); }
|
|
DEF(open_sound_WRONLY) { test_open("sound", O_WRONLY); }
|
|
DEF(open_sound_RDWR) { test_open("sound", O_RDWR); }
|
|
DEF(open_audioctl_RDONLY) { test_open("audioctl", O_RDONLY); }
|
|
DEF(open_audioctl_WRONLY) { test_open("audioctl", O_WRONLY); }
|
|
DEF(open_audioctl_RDWR) { test_open("audioctl", O_RDWR); }
|
|
|
|
/*
|
|
* Open (1) /dev/sound -> (2) /dev/audio -> (3) /dev/sound,
|
|
* Both of /dev/audio and /dev/sound share the sticky parameters,
|
|
* /dev/sound inherits and use it but /dev/audio initialize and use it.
|
|
* So 2nd audio descriptor affects 3rd sound descriptor.
|
|
*/
|
|
DEF(open_sound_sticky)
|
|
{
|
|
struct audio_info ai;
|
|
int fd;
|
|
int r;
|
|
int openmode;
|
|
|
|
TEST("open_sound_sticky");
|
|
|
|
openmode = openable_mode();
|
|
|
|
/* First, open /dev/sound and change encoding as a delegate */
|
|
fd = OPEN(devsound, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
ai.record.encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
r = CLOSE(fd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* Next, open /dev/audio. It makes the encoding mulaw */
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
r = CLOSE(fd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* And then, open /dev/sound again */
|
|
fd = OPEN(devsound, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
XP_EQ(AUDIO_ENCODING_ULAW, ai.play.encoding);
|
|
XP_EQ(AUDIO_ENCODING_ULAW, ai.record.encoding);
|
|
r = CLOSE(fd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* /dev/audioctl has stickiness like /dev/sound.
|
|
*/
|
|
DEF(open_audioctl_sticky)
|
|
{
|
|
struct audio_info ai;
|
|
int fd;
|
|
int r;
|
|
int openmode;
|
|
|
|
TEST("open_audioctl_sticky");
|
|
|
|
openmode = openable_mode();
|
|
|
|
/* First, open /dev/audio and change encoding */
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
ai.play.precision = 16;
|
|
ai.record.encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
ai.record.precision = 16;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "SLINEAR_LE");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
r = CLOSE(fd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* Next, open /dev/audioctl. It should be affected */
|
|
fd = OPEN(devaudioctl, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
XP_EQ(AUDIO_ENCODING_SLINEAR_LE, ai.play.encoding);
|
|
XP_EQ(16, ai.play.precision);
|
|
XP_EQ(AUDIO_ENCODING_SLINEAR_LE, ai.record.encoding);
|
|
XP_EQ(16, ai.record.precision);
|
|
|
|
/* Then, change /dev/audioctl */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.encoding = AUDIO_ENCODING_ULAW;
|
|
ai.play.precision = 8;
|
|
ai.record.encoding = AUDIO_ENCODING_ULAW;
|
|
ai.record.precision = 8;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "ULAW");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
r = CLOSE(fd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* Finally, open /dev/sound. It also should be affected */
|
|
fd = OPEN(devsound, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
XP_EQ(AUDIO_ENCODING_ULAW, ai.play.encoding);
|
|
XP_EQ(8, ai.play.precision);
|
|
XP_EQ(AUDIO_ENCODING_ULAW, ai.record.encoding);
|
|
XP_EQ(8, ai.record.precision);
|
|
r = CLOSE(fd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Open two descriptors simultaneously.
|
|
*/
|
|
void
|
|
test_open_simul(int mode0, int mode1)
|
|
{
|
|
struct audio_info ai;
|
|
int fd0, fd1;
|
|
int i;
|
|
int r;
|
|
int actmode;
|
|
#define AUMODE_BOTH (AUMODE_PLAY | AUMODE_RECORD)
|
|
struct {
|
|
int mode0;
|
|
int mode1;
|
|
} expfulltable[] = {
|
|
/* expected fd0 expected fd1 (-errno expects error) */
|
|
{ AUMODE_RECORD, AUMODE_RECORD }, // REC, REC
|
|
{ AUMODE_RECORD, AUMODE_PLAY }, // REC, PLAY
|
|
{ AUMODE_RECORD, AUMODE_BOTH }, // REC, BOTH
|
|
{ AUMODE_PLAY, AUMODE_RECORD }, // PLAY, REC
|
|
{ AUMODE_PLAY, AUMODE_PLAY }, // PLAY, PLAY
|
|
{ AUMODE_PLAY, AUMODE_BOTH }, // PLAY, BOTH
|
|
{ AUMODE_BOTH, AUMODE_RECORD }, // BOTH, REC
|
|
{ AUMODE_BOTH, AUMODE_PLAY }, // BOTH, PLAY
|
|
{ AUMODE_BOTH, AUMODE_BOTH }, // BOTH, BOTH
|
|
},
|
|
exphalftable[] = {
|
|
/* expected fd0 expected fd1 (-errno expects error) */
|
|
{ AUMODE_RECORD, AUMODE_RECORD }, // REC, REC
|
|
{ AUMODE_RECORD, -ENODEV }, // REC, PLAY
|
|
{ AUMODE_RECORD, -ENODEV }, // REC, BOTH
|
|
{ AUMODE_PLAY, -ENODEV }, // PLAY, REC
|
|
{ AUMODE_PLAY, AUMODE_PLAY }, // PLAY, PLAY
|
|
{ AUMODE_PLAY, AUMODE_PLAY }, // PLAY, BOTH
|
|
{ AUMODE_PLAY, -ENODEV }, // BOTH, REC
|
|
{ AUMODE_PLAY, AUMODE_PLAY }, // BOTH, PLAY
|
|
{ AUMODE_PLAY, AUMODE_PLAY }, // BOTH, BOTH
|
|
}, *exptable;
|
|
|
|
/* The expected values are different in half-duplex or full-duplex */
|
|
if (hw_fulldup()) {
|
|
exptable = expfulltable;
|
|
} else {
|
|
exptable = exphalftable;
|
|
}
|
|
|
|
TEST("open_simul_%s_%s",
|
|
openmode_str[mode0] + 2,
|
|
openmode_str[mode1] + 2);
|
|
|
|
if (netbsd < 8) {
|
|
XP_SKIP("Multiple open is not supported");
|
|
return;
|
|
}
|
|
|
|
if (mode2aumode(mode0) == 0 || mode2aumode(mode1) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
i = mode0 * 3 + mode1;
|
|
|
|
/* Open first one */
|
|
fd0 = OPEN(devaudio, mode0);
|
|
REQUIRED_SYS_OK(fd0);
|
|
r = IOCTL(fd0, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
actmode = ai.mode & AUMODE_BOTH;
|
|
XP_EQ(exptable[i].mode0, actmode);
|
|
|
|
/* Open second one */
|
|
fd1 = OPEN(devaudio, mode1);
|
|
if (exptable[i].mode1 >= 0) {
|
|
/* Case to expect to be able to open */
|
|
REQUIRED_SYS_OK(fd1);
|
|
r = IOCTL(fd1, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (r == 0) {
|
|
actmode = ai.mode & AUMODE_BOTH;
|
|
XP_EQ(exptable[i].mode1, actmode);
|
|
}
|
|
} else {
|
|
/* Case to expect not to be able to open */
|
|
XP_SYS_NG(ENODEV, fd1);
|
|
if (fd1 == -1) {
|
|
XP_EQ(-exptable[i].mode1, errno);
|
|
} else {
|
|
r = IOCTL(fd1, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (r == 0) {
|
|
actmode = ai.mode & AUMODE_BOTH;
|
|
XP_FAIL("expects error but %d", actmode);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fd1 >= 0) {
|
|
r = CLOSE(fd1);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
r = CLOSE(fd0);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(open_simul_RDONLY_RDONLY) { test_open_simul(O_RDONLY, O_RDONLY); }
|
|
DEF(open_simul_RDONLY_WRONLY) { test_open_simul(O_RDONLY, O_WRONLY); }
|
|
DEF(open_simul_RDONLY_RDWR) { test_open_simul(O_RDONLY, O_RDWR); }
|
|
DEF(open_simul_WRONLY_RDONLY) { test_open_simul(O_WRONLY, O_RDONLY); }
|
|
DEF(open_simul_WRONLY_WRONLY) { test_open_simul(O_WRONLY, O_WRONLY); }
|
|
DEF(open_simul_WRONLY_RDWR) { test_open_simul(O_WRONLY, O_RDWR); }
|
|
DEF(open_simul_RDWR_RDONLY) { test_open_simul(O_RDWR, O_RDONLY); }
|
|
DEF(open_simul_RDWR_WRONLY) { test_open_simul(O_RDWR, O_WRONLY); }
|
|
DEF(open_simul_RDWR_RDWR) { test_open_simul(O_RDWR, O_RDWR); }
|
|
|
|
/*
|
|
* /dev/audio can be opened by other user who opens /dev/audio.
|
|
*/
|
|
void
|
|
try_open_multiuser(bool multiuser)
|
|
{
|
|
int fd0;
|
|
int fd1;
|
|
int r;
|
|
uid_t ouid;
|
|
|
|
/*
|
|
* Test1: Open as root first and then unprivileged user.
|
|
*/
|
|
|
|
/* At first, open as root */
|
|
fd0 = OPEN(devaudio, openable_mode());
|
|
REQUIRED_SYS_OK(fd0);
|
|
|
|
ouid = GETUID();
|
|
r = SETEUID(1);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* Then, open as unprivileged user */
|
|
fd1 = OPEN(devaudio, openable_mode());
|
|
if (multiuser) {
|
|
/* If multiuser, another user also can open */
|
|
XP_SYS_OK(fd1);
|
|
} else {
|
|
/* If not multiuser, another user cannot open */
|
|
XP_SYS_NG(EPERM, fd1);
|
|
}
|
|
if (fd1 != -1) {
|
|
r = CLOSE(fd1);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
r = SETEUID(ouid);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd0);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/*
|
|
* Test2: Open as unprivileged user first and then root.
|
|
*/
|
|
|
|
/* At first, open as unprivileged user */
|
|
ouid = GETUID();
|
|
r = SETEUID(1);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
fd0 = OPEN(devaudio, openable_mode());
|
|
REQUIRED_SYS_OK(fd0);
|
|
|
|
/* Then open as root */
|
|
r = SETEUID(ouid);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* root always can open */
|
|
fd1 = OPEN(devaudio, openable_mode());
|
|
XP_SYS_OK(fd1);
|
|
if (fd1 != -1) {
|
|
r = CLOSE(fd1);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/* Close first one as unprivileged user */
|
|
r = SETEUID(1);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
r = CLOSE(fd0);
|
|
XP_SYS_EQ(0, r);
|
|
r = SETEUID(ouid);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
}
|
|
/*
|
|
* This is a wrapper for open_multiuser.
|
|
* XXX XP_* macros are not compatible with on-error-goto, we need try-catch...
|
|
*/
|
|
void
|
|
test_open_multiuser(bool multiuser)
|
|
{
|
|
char mibname[32];
|
|
bool oldval;
|
|
size_t oldlen;
|
|
int r;
|
|
|
|
TEST("open_multiuser_%d", multiuser);
|
|
if (netbsd < 8) {
|
|
XP_SKIP("Multiple open is not supported");
|
|
return;
|
|
}
|
|
if (netbsd < 9) {
|
|
/* NetBSD8 has no way (difficult) to determine device name */
|
|
XP_SKIP("NetBSD8 cannot determine device name");
|
|
return;
|
|
}
|
|
if (geteuid() != 0) {
|
|
XP_SKIP("Must be run as a privileged user");
|
|
return;
|
|
}
|
|
|
|
/* Get current multiuser mode (and save it) */
|
|
snprintf(mibname, sizeof(mibname), "hw.%s.multiuser", devicename);
|
|
oldlen = sizeof(oldval);
|
|
r = SYSCTLBYNAME(mibname, &oldval, &oldlen, NULL, 0);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
DPRINTF(" > multiuser=%d\n", oldval);
|
|
|
|
/* Change if necessary */
|
|
if (oldval != multiuser) {
|
|
r = SYSCTLBYNAME(mibname, NULL, NULL, &multiuser,
|
|
sizeof(multiuser));
|
|
REQUIRED_SYS_EQ(0, r);
|
|
DPRINTF(" > new multiuser=%d\n", multiuser);
|
|
}
|
|
|
|
/* Do test */
|
|
try_open_multiuser(multiuser);
|
|
|
|
/* Restore multiuser mode */
|
|
if (oldval != multiuser) {
|
|
DPRINTF(" > restore multiuser to %d\n", oldval);
|
|
r = SYSCTLBYNAME(mibname, NULL, NULL, &oldval, sizeof(oldval));
|
|
REQUIRED_SYS_EQ(0, r);
|
|
}
|
|
}
|
|
DEF(open_multiuser_0) { test_open_multiuser(false); }
|
|
DEF(open_multiuser_1) { test_open_multiuser(true); }
|
|
|
|
/*
|
|
* Normal playback (with PLAY_ALL).
|
|
* It does not verify real playback data.
|
|
*/
|
|
DEF(write_PLAY_ALL)
|
|
{
|
|
char buf[8000];
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("write_PLAY_ALL");
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
if (hw_canplay()) {
|
|
REQUIRED_SYS_OK(fd);
|
|
} else {
|
|
XP_SYS_NG(ENXIO, fd);
|
|
return;
|
|
}
|
|
|
|
/* mulaw 1sec silence */
|
|
memset(buf, 0xff, sizeof(buf));
|
|
r = WRITE(fd, buf, sizeof(buf));
|
|
XP_SYS_EQ(sizeof(buf), r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Normal playback (without PLAY_ALL).
|
|
* It does not verify real playback data.
|
|
*/
|
|
DEF(write_PLAY)
|
|
{
|
|
struct audio_info ai;
|
|
char *wav;
|
|
int wavsize;
|
|
int totalsize;
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("write_PLAY");
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
if (hw_canplay()) {
|
|
REQUIRED_SYS_OK(fd);
|
|
} else {
|
|
XP_SYS_NG(ENXIO, fd);
|
|
return;
|
|
}
|
|
|
|
/* Drop PLAY_ALL */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.mode = AUMODE_PLAY;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "mode");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* Check mode and get blocksize */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
XP_EQ(AUMODE_PLAY, ai.mode);
|
|
|
|
wavsize = ai.blocksize;
|
|
wav = (char *)malloc(wavsize);
|
|
REQUIRED_IF(wav != NULL);
|
|
memset(wav, 0xff, wavsize);
|
|
|
|
/* Write blocks until 1sec */
|
|
for (totalsize = 0; totalsize < 8000; ) {
|
|
r = WRITE(fd, wav, wavsize);
|
|
XP_SYS_EQ(wavsize, r);
|
|
if (r == -1)
|
|
break; /* XXX */
|
|
totalsize += r;
|
|
}
|
|
|
|
/* XXX What should I test it? */
|
|
/* Check ai.play.error */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
XP_EQ(0, ai.play.error);
|
|
|
|
/* Playback data is no longer necessary */
|
|
r = IOCTL(fd, AUDIO_FLUSH, NULL, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
free(wav);
|
|
}
|
|
|
|
/*
|
|
* Normal recording.
|
|
* It does not verify real recorded data.
|
|
*/
|
|
DEF(read)
|
|
{
|
|
char buf[8000];
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("read");
|
|
|
|
fd = OPEN(devaudio, O_RDONLY);
|
|
if (hw_canrec()) {
|
|
REQUIRED_SYS_OK(fd);
|
|
} else {
|
|
XP_SYS_NG(ENXIO, fd);
|
|
return;
|
|
}
|
|
|
|
/* mulaw 1sec */
|
|
r = READ(fd, buf, sizeof(buf));
|
|
XP_SYS_EQ(sizeof(buf), r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Repeat open-write-close cycle.
|
|
*/
|
|
DEF(rept_write)
|
|
{
|
|
struct timeval start, end, result;
|
|
double res;
|
|
char buf[8000]; /* 1sec in 8bit-mulaw,1ch,8000Hz */
|
|
int fd;
|
|
int r;
|
|
int n;
|
|
|
|
TEST("rept_write");
|
|
|
|
if (hw_canplay() == 0) {
|
|
XP_SKIP("This test is only for playable device");
|
|
return;
|
|
}
|
|
|
|
/* XXX It may timeout on some hardware driver. */
|
|
XP_SKIP("not yet");
|
|
return;
|
|
|
|
memset(buf, 0xff, sizeof(buf));
|
|
n = 3;
|
|
gettimeofday(&start, NULL);
|
|
for (int i = 0; i < n; i++) {
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
r = WRITE(fd, buf, sizeof(buf));
|
|
XP_SYS_EQ(sizeof(buf), r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
gettimeofday(&end, NULL);
|
|
timersub(&end, &start, &result);
|
|
res = (double)result.tv_sec + (double)result.tv_usec / 1000000;
|
|
/* Make judgement but not too strict */
|
|
if (res >= n * 1.5) {
|
|
XP_FAIL("expects %d sec but %4.1f sec", n, res);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Repeat open-read-close cycle.
|
|
*/
|
|
DEF(rept_read)
|
|
{
|
|
struct timeval start, end, result;
|
|
double res;
|
|
char buf[8000]; /* 1sec in 8bit-mulaw,1ch,8000Hz */
|
|
int fd;
|
|
int r;
|
|
int n;
|
|
|
|
TEST("rept_read");
|
|
|
|
if (hw_canrec() == 0) {
|
|
XP_SKIP("This test is only for recordable device");
|
|
return;
|
|
}
|
|
|
|
/* XXX It may timeout on some hardware driver. */
|
|
XP_SKIP("not yet");
|
|
return;
|
|
|
|
n = 3;
|
|
gettimeofday(&start, NULL);
|
|
for (int i = 0; i < n; i++) {
|
|
fd = OPEN(devaudio, O_RDONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
r = READ(fd, buf, sizeof(buf));
|
|
XP_SYS_EQ(sizeof(buf), r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
gettimeofday(&end, NULL);
|
|
timersub(&end, &start, &result);
|
|
res = (double)result.tv_sec + (double)result.tv_usec / 1000000;
|
|
/* Make judgement but not too strict */
|
|
if (res >= n * 1.5) {
|
|
XP_FAIL("expects %d sec but %4.1f sec", n, res);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Opening with O_RDWR on half-duplex hardware falls back to O_WRONLY.
|
|
* expwrite: expected to be able to play.
|
|
* expread : expected to be able to record.
|
|
*/
|
|
void
|
|
test_rdwr_fallback(int openmode, bool expwrite, bool expread)
|
|
{
|
|
struct audio_info ai;
|
|
char buf[10];
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("rdwr_fallback_%s", openmode_str[openmode] + 2);
|
|
|
|
if (hw_bidir() == 0) {
|
|
XP_SKIP("This test is only for bi-directional device");
|
|
return;
|
|
}
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
ai.record.pause = 1;
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Set pause not to play noise */
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
memset(buf, 0xff, sizeof(buf));
|
|
r = WRITE(fd, buf, sizeof(buf));
|
|
if (expwrite) {
|
|
XP_SYS_EQ(sizeof(buf), r);
|
|
} else {
|
|
XP_SYS_NG(EBADF, r);
|
|
}
|
|
|
|
r = READ(fd, buf, 0);
|
|
if (expread) {
|
|
XP_SYS_EQ(0, r);
|
|
} else {
|
|
XP_SYS_NG(EBADF, r);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
}
|
|
DEF(rdwr_fallback_RDONLY) { test_rdwr_fallback(O_RDONLY, false, true); }
|
|
DEF(rdwr_fallback_WRONLY) { test_rdwr_fallback(O_WRONLY, true, false); }
|
|
DEF(rdwr_fallback_RDWR) {
|
|
bool expread;
|
|
/*
|
|
* On NetBSD7, O_RDWR on half-duplex is accepted. It's possible to
|
|
* read and write if they don't occur at the same time.
|
|
* On NetBSD9, O_RDWR on half-duplex falls back O_WRONLY.
|
|
*/
|
|
if (netbsd < 8) {
|
|
expread = true;
|
|
} else {
|
|
expread = hw_fulldup() ? true : false;
|
|
}
|
|
test_rdwr_fallback(O_RDWR, true, expread);
|
|
}
|
|
|
|
/*
|
|
* On full-duplex hardware, the second descriptor's readability/writability
|
|
* does not depend on the first descriptor's open mode.
|
|
* On half-duplex hardware, it depends on the first descriptor's open mode.
|
|
*/
|
|
void
|
|
test_rdwr_two(int mode0, int mode1)
|
|
{
|
|
struct audio_info ai;
|
|
char wbuf[100]; /* 1/80sec in 8bit-mulaw,1ch,8000Hz */
|
|
char rbuf[100]; /* 1/80sec in 8bit-mulaw,1ch,8000Hz */
|
|
bool canopen;
|
|
bool canwrite;
|
|
bool canread;
|
|
int fd0;
|
|
int fd1;
|
|
int r;
|
|
struct {
|
|
bool canopen;
|
|
bool canwrite;
|
|
bool canread;
|
|
} exptable_full[] = {
|
|
/* open write read 1st, 2nd mode */
|
|
{ 1, 0, 1 }, /* REC, REC */
|
|
{ 1, 1, 0 }, /* REC, PLAY */
|
|
{ 1, 1, 1 }, /* REC, BOTH */
|
|
{ 1, 0, 1 }, /* PLAY, REC */
|
|
{ 1, 1, 0 }, /* PLAY, PLAY */
|
|
{ 1, 1, 1 }, /* PLAY, BOTH */
|
|
{ 1, 0, 1 }, /* BOTH, REC */
|
|
{ 1, 1, 0 }, /* BOTH, PLAY */
|
|
{ 1, 1, 1 }, /* BOTH, BOTH */
|
|
},
|
|
exptable_half[] = {
|
|
{ 1, 0, 1 }, /* REC, REC */
|
|
{ 0, 0, 0 }, /* REC, PLAY */
|
|
{ 0, 0, 0 }, /* REC, BOTH */
|
|
{ 0, 0, 0 }, /* PLAY, REC */
|
|
{ 1, 1, 0 }, /* PLAY, PLAY */
|
|
{ 1, 1, 0 }, /* PLAY, BOTH */
|
|
{ 0, 0, 0 }, /* BOTH, REC */
|
|
{ 1, 1, 0 }, /* BOTH, PLAY */
|
|
{ 0, 0, 0 }, /* BOTH, BOTH */
|
|
}, *exptable;
|
|
|
|
TEST("rdwr_two_%s_%s",
|
|
openmode_str[mode0] + 2,
|
|
openmode_str[mode1] + 2);
|
|
|
|
if (netbsd < 8) {
|
|
XP_SKIP("Multiple open is not supported");
|
|
return;
|
|
}
|
|
if (hw_bidir() == 0) {
|
|
XP_SKIP("This test is only for bi-directional device");
|
|
return;
|
|
}
|
|
|
|
exptable = hw_fulldup() ? exptable_full : exptable_half;
|
|
|
|
canopen = exptable[mode0 * 3 + mode1].canopen;
|
|
canwrite = exptable[mode0 * 3 + mode1].canwrite;
|
|
canread = exptable[mode0 * 3 + mode1].canread;
|
|
|
|
if (!canopen) {
|
|
XP_SKIP("This combination is not openable on half-duplex");
|
|
return;
|
|
}
|
|
|
|
fd0 = OPEN(devaudio, mode0);
|
|
REQUIRED_SYS_OK(fd0);
|
|
|
|
fd1 = OPEN(devaudio, mode1);
|
|
REQUIRED_SYS_OK(fd1);
|
|
|
|
/* Silent data to make no sound */
|
|
memset(&wbuf, 0xff, sizeof(wbuf));
|
|
/* Pause to make no sound */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd0, AUDIO_SETINFO, &ai, "pause");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* write(fd1) */
|
|
r = WRITE(fd1, wbuf, sizeof(wbuf));
|
|
if (canwrite) {
|
|
XP_SYS_EQ(100, r);
|
|
} else {
|
|
XP_SYS_NG(EBADF, r);
|
|
}
|
|
|
|
/* read(fd1) */
|
|
r = READ(fd1, rbuf, sizeof(rbuf));
|
|
if (canread) {
|
|
XP_SYS_EQ(100, r);
|
|
} else {
|
|
XP_SYS_NG(EBADF, r);
|
|
}
|
|
|
|
r = CLOSE(fd0);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(fd1);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(rdwr_two_RDONLY_RDONLY) { test_rdwr_two(O_RDONLY, O_RDONLY); }
|
|
DEF(rdwr_two_RDONLY_WRONLY) { test_rdwr_two(O_RDONLY, O_WRONLY); }
|
|
DEF(rdwr_two_RDONLY_RDWR) { test_rdwr_two(O_RDONLY, O_RDWR); }
|
|
DEF(rdwr_two_WRONLY_RDONLY) { test_rdwr_two(O_WRONLY, O_RDONLY); }
|
|
DEF(rdwr_two_WRONLY_WRONLY) { test_rdwr_two(O_WRONLY, O_WRONLY); }
|
|
DEF(rdwr_two_WRONLY_RDWR) { test_rdwr_two(O_WRONLY, O_RDWR); }
|
|
DEF(rdwr_two_RDWR_RDONLY) { test_rdwr_two(O_RDWR, O_RDONLY); }
|
|
DEF(rdwr_two_RDWR_WRONLY) { test_rdwr_two(O_RDWR, O_WRONLY); }
|
|
DEF(rdwr_two_RDWR_RDWR) { test_rdwr_two(O_RDWR, O_RDWR); }
|
|
|
|
/*
|
|
* Read and write different descriptors simultaneously.
|
|
* Only on full-duplex.
|
|
*/
|
|
DEF(rdwr_simul)
|
|
{
|
|
char wbuf[1000]; /* 1/8sec in mulaw,1ch,8kHz */
|
|
char rbuf[1000];
|
|
int fd0;
|
|
int fd1;
|
|
int r;
|
|
int status;
|
|
pid_t pid;
|
|
|
|
TEST("rdwr_simul");
|
|
if (netbsd < 8) {
|
|
XP_SKIP("Multiple open is not supported");
|
|
return;
|
|
}
|
|
if (!hw_fulldup()) {
|
|
XP_SKIP("This test is only for full-duplex device");
|
|
return;
|
|
}
|
|
|
|
/* Silence data to make no sound */
|
|
memset(wbuf, 0xff, sizeof(wbuf));
|
|
|
|
fd0 = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd0);
|
|
fd1 = OPEN(devaudio, O_RDONLY);
|
|
REQUIRED_SYS_OK(fd1);
|
|
|
|
fflush(stdout);
|
|
fflush(stderr);
|
|
pid = fork();
|
|
if (pid == -1)
|
|
xp_err(1, __LINE__, "fork");
|
|
|
|
if (pid == 0) {
|
|
/* child (read) */
|
|
for (int i = 0; i < 10; i++) {
|
|
r = READ(fd1, rbuf, sizeof(rbuf));
|
|
if (r == -1)
|
|
xp_err(1, __LINE__, "read(i=%d)", i);
|
|
}
|
|
exit(0);
|
|
} else {
|
|
/* parent (write) */
|
|
for (int i = 0; i < 10; i++) {
|
|
r = WRITE(fd0, wbuf, sizeof(wbuf));
|
|
if (r == -1)
|
|
xp_err(1, __LINE__, "write(i=%d)", i);
|
|
}
|
|
waitpid(pid, &status, 0);
|
|
}
|
|
|
|
CLOSE(fd0);
|
|
CLOSE(fd1);
|
|
/* If you reach here, consider as success */
|
|
XP_EQ(0, 0);
|
|
}
|
|
|
|
/*
|
|
* DRAIN should work even on incomplete data left.
|
|
*/
|
|
DEF(drain_incomplete)
|
|
{
|
|
struct audio_info ai;
|
|
int r;
|
|
int fd;
|
|
|
|
TEST("drain_incomplete");
|
|
|
|
if (hw_canplay() == 0) {
|
|
XP_SKIP("This test is only for playable device");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
/* let precision > 8 */
|
|
ai.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
ai.play.precision = 16;
|
|
ai.mode = AUMODE_PLAY;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
/* Write one byte and then close */
|
|
r = WRITE(fd, &r, 1);
|
|
XP_SYS_EQ(1, r);
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* DRAIN should work even in pause.
|
|
*/
|
|
DEF(drain_pause)
|
|
{
|
|
struct audio_info ai;
|
|
int r;
|
|
int fd;
|
|
|
|
TEST("drain_pause");
|
|
|
|
if (hw_canplay() == 0) {
|
|
XP_SKIP("This test is only for playable device");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Set pause */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
/* Write some data and then close */
|
|
r = WRITE(fd, &r, 4);
|
|
XP_SYS_EQ(4, r);
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* DRAIN does not affect for record-only descriptor.
|
|
*/
|
|
DEF(drain_onrec)
|
|
{
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("drain_onrec");
|
|
|
|
if (hw_canrec() == 0) {
|
|
XP_SKIP("This test is only for recordable device");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, O_RDONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Whether mmap() succeeds with specified parameter.
|
|
*/
|
|
void
|
|
test_mmap_mode(int mode, int prot)
|
|
{
|
|
char buf[10];
|
|
struct audio_info ai;
|
|
const char *protstr;
|
|
int expected;
|
|
int fd;
|
|
int r;
|
|
int len;
|
|
void *ptr;
|
|
|
|
if (prot == PROT_NONE) {
|
|
protstr = "NONE";
|
|
} else if (prot == PROT_READ) {
|
|
protstr = "READ";
|
|
} else if (prot == PROT_WRITE) {
|
|
protstr = "WRITE";
|
|
} else if (prot == (PROT_READ | PROT_WRITE)) {
|
|
protstr = "READWRITE";
|
|
} else {
|
|
xp_errx(1, __LINE__, "unknown prot %x\n", prot);
|
|
}
|
|
TEST("mmap_%s_%s", openmode_str[mode] + 2, protstr);
|
|
if ((props & AUDIO_PROP_MMAP) == 0) {
|
|
XP_SKIP("This test is only for mmap-able device");
|
|
return;
|
|
}
|
|
if (mode2aumode(mode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump) {
|
|
XP_SKIP("rump doesn't support mmap");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* On NetBSD7 and 8, mmap() always succeeds regardless of open mode.
|
|
* On NetBSD9, mmap() succeeds only for writable descriptor.
|
|
*/
|
|
expected = mode2play(mode);
|
|
if (netbsd < 9) {
|
|
expected = true;
|
|
}
|
|
|
|
fd = OPEN(devaudio, mode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "get");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
len = ai.play.buffer_size;
|
|
|
|
/* Make it pause */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
ptr = MMAP(NULL, len, prot, MAP_FILE, fd, 0);
|
|
XP_SYS_PTR(expected ? 0 : EACCES, ptr);
|
|
if (expected) {
|
|
/* XXX Doing mmap(2) doesn't inhibit read(2) */
|
|
if (mode2rec(mode)) {
|
|
r = READ(fd, buf, 0);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
/* Doing mmap(2) inhibits write(2) */
|
|
if (mode2play(mode)) {
|
|
/* NetBSD9 changes errno */
|
|
r = WRITE(fd, buf, 0);
|
|
if (netbsd < 9) {
|
|
XP_SYS_NG(EINVAL, r);
|
|
} else {
|
|
XP_SYS_NG(EPERM, r);
|
|
}
|
|
}
|
|
}
|
|
if (ptr != MAP_FAILED) {
|
|
r = MUNMAP(ptr, len);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/* Whether the pause is still valid */
|
|
if (mode2play(mode)) {
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(1, ai.play.pause);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
reset_after_mmap();
|
|
}
|
|
#define PROT_READWRITE (PROT_READ | PROT_WRITE)
|
|
DEF(mmap_mode_RDONLY_NONE) { test_mmap_mode(O_RDONLY, PROT_NONE); }
|
|
DEF(mmap_mode_RDONLY_READ) { test_mmap_mode(O_RDONLY, PROT_READ); }
|
|
DEF(mmap_mode_RDONLY_WRITE) { test_mmap_mode(O_RDONLY, PROT_WRITE); }
|
|
DEF(mmap_mode_RDONLY_READWRITE) { test_mmap_mode(O_RDONLY, PROT_READWRITE); }
|
|
DEF(mmap_mode_WRONLY_NONE) { test_mmap_mode(O_WRONLY, PROT_NONE); }
|
|
DEF(mmap_mode_WRONLY_READ) { test_mmap_mode(O_WRONLY, PROT_READ); }
|
|
DEF(mmap_mode_WRONLY_WRITE) { test_mmap_mode(O_WRONLY, PROT_WRITE); }
|
|
DEF(mmap_mode_WRONLY_READWRITE) { test_mmap_mode(O_WRONLY, PROT_READWRITE); }
|
|
DEF(mmap_mode_RDWR_NONE) { test_mmap_mode(O_RDWR, PROT_NONE); }
|
|
DEF(mmap_mode_RDWR_READ) { test_mmap_mode(O_RDWR, PROT_READ); }
|
|
DEF(mmap_mode_RDWR_WRITE) { test_mmap_mode(O_RDWR, PROT_WRITE); }
|
|
DEF(mmap_mode_RDWR_READWRITE) { test_mmap_mode(O_RDWR, PROT_READWRITE); }
|
|
|
|
/*
|
|
* Check mmap()'s length and offset.
|
|
*
|
|
* Actual len and offset cannot be determined before open. So that,
|
|
* pass pre-defined constant as argument, and convert it after open.
|
|
*/
|
|
#define LS (100) /* lsize */
|
|
#define LS1 (101) /* lsize + 1 */
|
|
void
|
|
test_mmap_len(size_t len, off_t offset, int exp)
|
|
{
|
|
struct audio_info ai;
|
|
int fd;
|
|
int r;
|
|
size_t plen;
|
|
void *ptr;
|
|
int bufsize;
|
|
int pagesize;
|
|
int lsize;
|
|
|
|
TEST("mmap_len(%zd, %jd, %d)", len, offset, exp);
|
|
if ((props & AUDIO_PROP_MMAP) == 0) {
|
|
XP_SKIP("This test is only for mmap-able device");
|
|
return;
|
|
}
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump) {
|
|
XP_SKIP("rump doesn't support mmap");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
plen = sizeof(pagesize);
|
|
r = SYSCTLBYNAME("hw.pagesize", &pagesize, &plen, NULL, 0);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(r);
|
|
|
|
/* Get buffer_size */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
bufsize = ai.play.buffer_size;
|
|
|
|
/*
|
|
* XXX someone refers bufsize and another one does pagesize.
|
|
* I'm not sure.
|
|
*/
|
|
lsize = roundup2(bufsize, pagesize);
|
|
|
|
/* Here, lsize can be assigned */
|
|
if (len == LS) {
|
|
len = lsize;
|
|
} else if (len == LS1) {
|
|
len = lsize + 1;
|
|
}
|
|
if (offset == LS) {
|
|
offset = lsize;
|
|
} else if (offset == LS1) {
|
|
offset = lsize + 1;
|
|
}
|
|
|
|
ptr = MMAP(NULL, len, PROT_WRITE, MAP_FILE, fd, offset);
|
|
if (exp == 0) {
|
|
XP_SYS_PTR(0, ptr);
|
|
} else {
|
|
/* NetBSD8 introduces EOVERFLOW */
|
|
if (netbsd < 8 && exp == EOVERFLOW)
|
|
exp = EINVAL;
|
|
XP_SYS_PTR(exp, ptr);
|
|
}
|
|
|
|
if (ptr != MAP_FAILED) {
|
|
r = MUNMAP(ptr, len);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
reset_after_mmap();
|
|
}
|
|
#define f(l, o, e) test_mmap_len(l, o, e)
|
|
DEF(mmap_len_0) { f(0, 0, EINVAL); } /* len is 0 */
|
|
DEF(mmap_len_1) { f(1, 0, 0); } /* len is smaller than lsize */
|
|
DEF(mmap_len_2) { f(LS, 0, 0); } /* len is the same as lsize */
|
|
DEF(mmap_len_3) { f(LS1, 0, EOVERFLOW); } /* len is larger */
|
|
DEF(mmap_len_4) { f(0, -1, EINVAL); } /* offset is negative */
|
|
DEF(mmap_len_5) { f(0, LS, EINVAL); } /* len is 0 */
|
|
DEF(mmap_len_6) { f(0, LS1, EINVAL); } /* len is 0 */
|
|
DEF(mmap_len_7) { f(1, LS, EOVERFLOW); } /* exceed */
|
|
/*
|
|
* When you treat the offset as 32bit, offset will be 0 and thus it
|
|
* incorrectly succeeds.
|
|
*/
|
|
DEF(mmap_len_8) { f(LS, 1ULL << 32, EOVERFLOW); }
|
|
#undef f
|
|
|
|
/*
|
|
* mmap() the same descriptor twice.
|
|
*/
|
|
DEF(mmap_twice)
|
|
{
|
|
struct audio_info ai;
|
|
int fd;
|
|
int r;
|
|
int len;
|
|
void *ptr1;
|
|
void *ptr2;
|
|
|
|
TEST("mmap_twice");
|
|
if ((props & AUDIO_PROP_MMAP) == 0) {
|
|
XP_SKIP("This test is only for mmap-able device");
|
|
return;
|
|
}
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump) {
|
|
XP_SKIP("rump doesn't support mmap");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "get");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
len = ai.play.buffer_size;
|
|
|
|
ptr1 = MMAP(NULL, len, PROT_WRITE, MAP_FILE, fd, 0);
|
|
XP_SYS_PTR(0, ptr1);
|
|
|
|
/* XXX I'm not sure this sucess is intended. Anyway I follow it */
|
|
ptr2 = MMAP(NULL, len, PROT_WRITE, MAP_FILE, fd, 0);
|
|
XP_SYS_PTR(0, ptr2);
|
|
|
|
if (ptr2 != MAP_FAILED) {
|
|
r = MUNMAP(ptr2, len);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
if (ptr1 != MAP_FAILED) {
|
|
r = MUNMAP(ptr1, len);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
reset_after_mmap();
|
|
}
|
|
|
|
/*
|
|
* mmap() different descriptors.
|
|
*/
|
|
DEF(mmap_multi)
|
|
{
|
|
struct audio_info ai;
|
|
int fd0;
|
|
int fd1;
|
|
int r;
|
|
int len;
|
|
void *ptr0;
|
|
void *ptr1;
|
|
|
|
TEST("mmap_multi");
|
|
if (netbsd < 8) {
|
|
XP_SKIP("Multiple open is not supported");
|
|
return;
|
|
}
|
|
if ((props & AUDIO_PROP_MMAP) == 0) {
|
|
XP_SKIP("This test is only for mmap-able device");
|
|
return;
|
|
}
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump) {
|
|
XP_SKIP("rump doesn't support mmap");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
fd0 = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd0);
|
|
|
|
r = IOCTL(fd0, AUDIO_GETBUFINFO, &ai, "get");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
len = ai.play.buffer_size;
|
|
|
|
fd1 = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd1);
|
|
|
|
ptr0 = MMAP(NULL, len, PROT_WRITE, MAP_FILE, fd0, 0);
|
|
XP_SYS_PTR(0, ptr0);
|
|
|
|
ptr1 = MMAP(NULL, len, PROT_WRITE, MAP_FILE, fd1, 0);
|
|
XP_SYS_PTR(0, ptr1);
|
|
|
|
if (ptr0 != MAP_FAILED) {
|
|
r = MUNMAP(ptr1, len);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
r = CLOSE(fd1);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
if (ptr1 != MAP_FAILED) {
|
|
r = MUNMAP(ptr0, len);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
r = CLOSE(fd0);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
reset_after_mmap();
|
|
}
|
|
|
|
#define IN POLLIN
|
|
#define OUT POLLOUT
|
|
/*
|
|
* Whether poll() succeeds with specified mode.
|
|
*/
|
|
void
|
|
test_poll_mode(int mode, int events, int expected_revents)
|
|
{
|
|
struct pollfd pfd;
|
|
const char *events_str;
|
|
int fd;
|
|
int r;
|
|
int expected_r;
|
|
|
|
if (events == IN) {
|
|
events_str = "IN";
|
|
} else if (events == OUT) {
|
|
events_str = "OUT";
|
|
} else if (events == (IN | OUT)) {
|
|
events_str = "INOUT";
|
|
} else {
|
|
events_str = "?";
|
|
}
|
|
TEST("poll_mode_%s_%s", openmode_str[mode] + 2, events_str);
|
|
if (mode2aumode(mode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
expected_r = (expected_revents != 0) ? 1 : 0;
|
|
|
|
fd = OPEN(devaudio, mode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Wait a bit to be recorded. */
|
|
usleep(100 * 1000);
|
|
|
|
memset(&pfd, 0, sizeof(pfd));
|
|
pfd.fd = fd;
|
|
pfd.events = events;
|
|
|
|
r = POLL(&pfd, 1, 100);
|
|
/* It's a bit complicated.. */
|
|
if (r < 0 || r > 1) {
|
|
/*
|
|
* Check these two cases first:
|
|
* - system call fails.
|
|
* - poll() with one nfds returns >1. It's strange.
|
|
*/
|
|
XP_SYS_EQ(expected_r, r);
|
|
} else {
|
|
/*
|
|
* Otherwise, poll() returned 0 or 1.
|
|
*/
|
|
DPRINTF(" > pfd.revents=%s\n", event_tostr(pfd.revents));
|
|
|
|
/* NetBSD7,8 have several strange behavior. It must be bug. */
|
|
|
|
XP_SYS_EQ(expected_r, r);
|
|
XP_EQ(expected_revents, pfd.revents);
|
|
}
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(poll_mode_RDONLY_IN) { test_poll_mode(O_RDONLY, IN, IN); }
|
|
DEF(poll_mode_RDONLY_OUT) { test_poll_mode(O_RDONLY, OUT, 0); }
|
|
DEF(poll_mode_RDONLY_INOUT) { test_poll_mode(O_RDONLY, IN|OUT, IN); }
|
|
DEF(poll_mode_WRONLY_IN) { test_poll_mode(O_WRONLY, IN, 0); }
|
|
DEF(poll_mode_WRONLY_OUT) { test_poll_mode(O_WRONLY, OUT, OUT); }
|
|
DEF(poll_mode_WRONLY_INOUT) { test_poll_mode(O_WRONLY, IN|OUT, OUT); }
|
|
DEF(poll_mode_RDWR_IN) {
|
|
/* On half-duplex, O_RDWR is the same as O_WRONLY. */
|
|
if (hw_fulldup()) test_poll_mode(O_RDWR, IN, IN);
|
|
else test_poll_mode(O_RDWR, IN, 0);
|
|
}
|
|
DEF(poll_mode_RDWR_OUT) { test_poll_mode(O_RDWR, OUT, OUT); }
|
|
DEF(poll_mode_RDWR_INOUT) {
|
|
/* On half-duplex, O_RDWR is the same as O_WRONLY. */
|
|
if (hw_fulldup()) test_poll_mode(O_RDWR, IN|OUT, IN|OUT);
|
|
else test_poll_mode(O_RDWR, IN|OUT, OUT);
|
|
}
|
|
|
|
/*
|
|
* Poll(OUT) when buffer is empty.
|
|
*/
|
|
DEF(poll_out_empty)
|
|
{
|
|
struct pollfd pfd;
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("poll_out_empty");
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
memset(&pfd, 0, sizeof(pfd));
|
|
pfd.fd = fd;
|
|
pfd.events = POLLOUT;
|
|
|
|
/* Check when empty. It should succeed even if timeout == 0 */
|
|
r = POLL(&pfd, 1, 0);
|
|
XP_SYS_EQ(1, r);
|
|
XP_EQ(POLLOUT, pfd.revents);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Poll(OUT) when buffer is full.
|
|
*/
|
|
DEF(poll_out_full)
|
|
{
|
|
struct audio_info ai;
|
|
struct pollfd pfd;
|
|
int fd;
|
|
int r;
|
|
char *buf;
|
|
int buflen;
|
|
|
|
TEST("poll_out_full");
|
|
|
|
fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Pause */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Get buffer size */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Write until full */
|
|
buflen = ai.play.buffer_size;
|
|
buf = (char *)malloc(buflen);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, buflen);
|
|
do {
|
|
r = WRITE(fd, buf, buflen);
|
|
} while (r == buflen);
|
|
if (r == -1) {
|
|
XP_SYS_NG(EAGAIN, r);
|
|
}
|
|
|
|
/* Do poll */
|
|
memset(&pfd, 0, sizeof(pfd));
|
|
pfd.fd = fd;
|
|
pfd.events = POLLOUT;
|
|
r = POLL(&pfd, 1, 0);
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, pfd.revents);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
free(buf);
|
|
}
|
|
|
|
/*
|
|
* Poll(OUT) when buffer is full but hiwat sets lower than full.
|
|
*/
|
|
DEF(poll_out_hiwat)
|
|
{
|
|
struct audio_info ai;
|
|
struct pollfd pfd;
|
|
int fd;
|
|
int r;
|
|
char *buf;
|
|
int buflen;
|
|
int newhiwat;
|
|
|
|
TEST("poll_out_hiwat");
|
|
|
|
fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Get buffer size and hiwat */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
/* Change hiwat some different value */
|
|
newhiwat = ai.lowat;
|
|
|
|
/* Set pause and hiwat */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
ai.hiwat = newhiwat;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=1;hiwat");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Get the set hiwat again */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Write until full */
|
|
buflen = ai.blocksize * ai.hiwat;
|
|
buf = (char *)malloc(buflen);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, buflen);
|
|
do {
|
|
r = WRITE(fd, buf, buflen);
|
|
} while (r == buflen);
|
|
if (r == -1) {
|
|
XP_SYS_NG(EAGAIN, r);
|
|
}
|
|
|
|
/* Do poll */
|
|
memset(&pfd, 0, sizeof(pfd));
|
|
pfd.fd = fd;
|
|
pfd.events = POLLOUT;
|
|
r = POLL(&pfd, 1, 0);
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, pfd.revents);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
free(buf);
|
|
}
|
|
|
|
/*
|
|
* Unpause from buffer full, POLLOUT should raise.
|
|
* XXX poll(2) on NetBSD7 is really incomplete and weird. I don't test it.
|
|
*/
|
|
DEF(poll_out_unpause)
|
|
{
|
|
struct audio_info ai;
|
|
struct pollfd pfd;
|
|
int fd;
|
|
int r;
|
|
char *buf;
|
|
int buflen;
|
|
u_int blocksize;
|
|
int hiwat;
|
|
int lowat;
|
|
|
|
TEST("poll_out_unpause");
|
|
if (netbsd < 8) {
|
|
XP_SKIP("NetBSD7's poll() is too incomplete to test.");
|
|
return;
|
|
}
|
|
|
|
/* Non-blocking open */
|
|
fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Adjust block size and hiwat/lowat to make the test time 1sec */
|
|
blocksize = 1000; /* 1/8 sec in mulaw,1ch,8000Hz */
|
|
hiwat = 12; /* 1.5sec */
|
|
lowat = 4; /* 0.5sec */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.blocksize = blocksize;
|
|
ai.hiwat = hiwat;
|
|
ai.lowat = lowat;
|
|
/* and also set encoding */
|
|
/*
|
|
* XXX NetBSD7 has different results depending on whether the input
|
|
* encoding is emulated (AUDIO_ENCODINGFLAG_EMULATED) or not. It's
|
|
* not easy to ensure this situation on all hardware environment.
|
|
* On NetBSD9, the result is the same regardless of input encoding.
|
|
*/
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "blocksize=%d", blocksize);
|
|
XP_SYS_EQ(0, r);
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
if (ai.blocksize != blocksize) {
|
|
/*
|
|
* NetBSD9 can not change the blocksize. Then,
|
|
* adjust using hiwat/lowat.
|
|
*/
|
|
blocksize = ai.blocksize;
|
|
hiwat = howmany(8000 * 1.5, blocksize);
|
|
lowat = howmany(8000 * 0.5, blocksize);
|
|
}
|
|
/* Anyway, set the parameters */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.blocksize = blocksize;
|
|
ai.hiwat = hiwat;
|
|
ai.lowat = lowat;
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=1");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Get the set parameters again */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Write until full */
|
|
buflen = ai.blocksize * ai.hiwat;
|
|
buf = (char *)malloc(buflen);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, buflen);
|
|
do {
|
|
r = WRITE(fd, buf, buflen);
|
|
} while (r == buflen);
|
|
if (r == -1) {
|
|
XP_SYS_NG(EAGAIN, r);
|
|
}
|
|
|
|
/* At this time, POLLOUT should not be set because buffer is full */
|
|
memset(&pfd, 0, sizeof(pfd));
|
|
pfd.fd = fd;
|
|
pfd.events = POLLOUT;
|
|
r = POLL(&pfd, 1, 0);
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, pfd.revents);
|
|
|
|
/* Unpause */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 0;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=0");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/*
|
|
* When unpause occurs:
|
|
* - NetBSD7 (emul=0) -> the buffer remains.
|
|
* - NetBSD7 (emul=1) -> the buffer is cleared.
|
|
* - NetBSD8 -> the buffer remains.
|
|
* - NetBSD9 -> the buffer remains.
|
|
*/
|
|
|
|
/* Check poll() up to 2sec */
|
|
pfd.revents = 0;
|
|
r = POLL(&pfd, 1, 2000);
|
|
XP_SYS_EQ(1, r);
|
|
XP_EQ(POLLOUT, pfd.revents);
|
|
|
|
/*
|
|
* Since POLLOUT is set, it should be writable.
|
|
* But at this time, no all buffer may be writable.
|
|
*/
|
|
r = WRITE(fd, buf, buflen);
|
|
XP_SYS_OK(r);
|
|
|
|
/* Flush it because there is no need to play it */
|
|
r = IOCTL(fd, AUDIO_FLUSH, NULL, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
free(buf);
|
|
}
|
|
|
|
/*
|
|
* poll(2) must not be affected by playback of other descriptors.
|
|
*/
|
|
DEF(poll_out_simul)
|
|
{
|
|
struct audio_info ai;
|
|
struct pollfd pfd[2];
|
|
int fd[2];
|
|
int r;
|
|
char *buf;
|
|
u_int blocksize;
|
|
int hiwat;
|
|
int lowat;
|
|
int buflen;
|
|
int time;
|
|
|
|
TEST("poll_out_simul");
|
|
if (netbsd < 8) {
|
|
XP_SKIP("Multiple open is not supported");
|
|
return;
|
|
}
|
|
|
|
/* Make sure that it's not affected by descriptor order */
|
|
for (int i = 0; i < 2; i++) {
|
|
int a = i;
|
|
int b = 1 - i;
|
|
|
|
fd[0] = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
|
|
REQUIRED_SYS_OK(fd[0]);
|
|
fd[1] = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
|
|
REQUIRED_SYS_OK(fd[1]);
|
|
|
|
/*
|
|
* Adjust block size and hiwat/lowat.
|
|
* I want to choice suitable blocksize (if possible).
|
|
*/
|
|
blocksize = 1000; /* 1/8 sec in mulaw,1ch,8000Hz */
|
|
hiwat = 12; /* 1.5sec */
|
|
lowat = 4; /* 0.5sec */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.blocksize = blocksize;
|
|
ai.hiwat = hiwat;
|
|
ai.lowat = lowat;
|
|
r = IOCTL(fd[0], AUDIO_SETINFO, &ai, "blocksize=1000");
|
|
XP_SYS_EQ(0, r);
|
|
r = IOCTL(fd[0], AUDIO_GETBUFINFO, &ai, "read back blocksize");
|
|
if (ai.blocksize != blocksize) {
|
|
/*
|
|
* NetBSD9 can not change the blocksize. Then,
|
|
* adjust using hiwat/lowat.
|
|
*/
|
|
blocksize = ai.blocksize;
|
|
hiwat = howmany(8000 * 1.5, blocksize);
|
|
lowat = howmany(8000 * 0.5, blocksize);
|
|
}
|
|
/* Anyway, set the parameters */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.blocksize = blocksize;
|
|
ai.hiwat = hiwat;
|
|
ai.lowat = lowat;
|
|
/* Pause fdA */
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd[a], AUDIO_SETINFO, &ai, "pause=1");
|
|
XP_SYS_EQ(0, r);
|
|
/* Unpause fdB */
|
|
ai.play.pause = 0;
|
|
r = IOCTL(fd[b], AUDIO_SETINFO, &ai, "pause=0");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Get again. XXX two individual ioctls are correct */
|
|
r = IOCTL(fd[0], AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
DPRINTF(" > blocksize=%d lowat=%d hiwat=%d\n",
|
|
ai.blocksize, ai.lowat, ai.hiwat);
|
|
|
|
/* Enough long time than the playback time */
|
|
time = (ai.hiwat - ai.lowat) * blocksize / 8; /*[msec]*/
|
|
time *= 2;
|
|
|
|
/* Write fdA full */
|
|
buflen = blocksize * ai.lowat;
|
|
buf = (char *)malloc(buflen);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, buflen);
|
|
do {
|
|
r = WRITE(fd[a], buf, buflen);
|
|
} while (r == buflen);
|
|
if (r == -1) {
|
|
XP_SYS_NG(EAGAIN, r);
|
|
}
|
|
|
|
/* POLLOUT should not be set, because fdA is buffer full */
|
|
memset(pfd, 0, sizeof(pfd));
|
|
pfd[0].fd = fd[a];
|
|
pfd[0].events = POLLOUT;
|
|
r = POLL(pfd, 1, 0);
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, pfd[0].revents);
|
|
|
|
/* Write fdB at least lowat */
|
|
r = WRITE(fd[b], buf, buflen);
|
|
XP_SYS_EQ(buflen, r);
|
|
r = WRITE(fd[b], buf, buflen);
|
|
if (r == -1) {
|
|
XP_SYS_NG(EAGAIN, r);
|
|
}
|
|
|
|
/* Only fdB should become POLLOUT */
|
|
memset(pfd, 0, sizeof(pfd));
|
|
pfd[0].fd = fd[0];
|
|
pfd[0].events = POLLOUT;
|
|
pfd[1].fd = fd[1];
|
|
pfd[1].events = POLLOUT;
|
|
r = POLL(pfd, 2, time);
|
|
XP_SYS_EQ(1, r);
|
|
if (r != -1) {
|
|
XP_EQ(0, pfd[a].revents);
|
|
XP_EQ(POLLOUT, pfd[b].revents);
|
|
}
|
|
|
|
/* Drop the rest */
|
|
r = IOCTL(fd[0], AUDIO_FLUSH, NULL, "");
|
|
XP_SYS_EQ(0, r);
|
|
r = IOCTL(fd[1], AUDIO_FLUSH, NULL, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd[0]);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(fd[1]);
|
|
XP_SYS_EQ(0, r);
|
|
free(buf);
|
|
|
|
xxx_close_wait();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Open with READ mode starts recording immediately.
|
|
* Of course, audioctl doesn't start.
|
|
*/
|
|
void
|
|
test_poll_in_open(const char *devname)
|
|
{
|
|
struct audio_info ai;
|
|
struct pollfd pfd;
|
|
char buf[4096];
|
|
char devfile[16];
|
|
int fd;
|
|
int r;
|
|
bool is_audioctl;
|
|
|
|
TEST("poll_in_open_%s", devname);
|
|
if (hw_canrec() == 0) {
|
|
XP_SKIP("This test is only for recordable device");
|
|
return;
|
|
}
|
|
|
|
snprintf(devfile, sizeof(devfile), "/dev/%s%d", devname, unit);
|
|
is_audioctl = (strcmp(devname, "audioctl") == 0);
|
|
|
|
fd = OPEN(devfile, O_RDONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
if (is_audioctl) {
|
|
/* opening /dev/audioctl doesn't start recording. */
|
|
XP_EQ(0, ai.record.active);
|
|
} else {
|
|
/* opening /dev/{audio,sound} starts recording. */
|
|
/*
|
|
* On NetBSD7/8, opening /dev/sound doesn't start recording.
|
|
* It must be a bug.
|
|
*/
|
|
XP_EQ(1, ai.record.active);
|
|
}
|
|
|
|
memset(&pfd, 0, sizeof(pfd));
|
|
pfd.fd = fd;
|
|
pfd.events = POLLIN;
|
|
r = POLL(&pfd, 1, 1000);
|
|
if (is_audioctl) {
|
|
/*
|
|
* poll-ing /dev/audioctl always fails.
|
|
* XXX Returning error instead of timeout should be better(?).
|
|
*/
|
|
REQUIRED_SYS_EQ(0, r);
|
|
} else {
|
|
/*
|
|
* poll-ing /dev/{audio,sound} will succeed when recorded
|
|
* data is arrived.
|
|
*/
|
|
/*
|
|
* On NetBSD7/8, opening /dev/sound doesn't start recording.
|
|
* It must be a bug.
|
|
*/
|
|
REQUIRED_SYS_EQ(1, r);
|
|
|
|
/* In this case, read() should succeed. */
|
|
r = READ(fd, buf, sizeof(buf));
|
|
XP_SYS_OK(r);
|
|
XP_NE(0, r);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(poll_in_open_audio) { test_poll_in_open("audio"); }
|
|
DEF(poll_in_open_sound) { test_poll_in_open("sound"); }
|
|
DEF(poll_in_open_audioctl) { test_poll_in_open("audioctl"); }
|
|
|
|
/*
|
|
* poll(2) must not be affected by other recording descriptors even if
|
|
* playback descriptor waits with POLLIN (though it's not normal usage).
|
|
* In other words, two POLLIN must not interfere.
|
|
*/
|
|
DEF(poll_in_simul)
|
|
{
|
|
struct audio_info ai;
|
|
struct pollfd pfd;
|
|
int fd[2];
|
|
int r;
|
|
char *buf;
|
|
int blocksize;
|
|
|
|
TEST("poll_in_simul");
|
|
if (netbsd < 8) {
|
|
XP_SKIP("Multiple open is not supported");
|
|
return;
|
|
}
|
|
if (hw_fulldup() == 0) {
|
|
XP_SKIP("This test is only for full-duplex device");
|
|
return;
|
|
}
|
|
|
|
int play = 0;
|
|
int rec = 1;
|
|
|
|
fd[play] = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
|
|
REQUIRED_SYS_OK(fd[play]);
|
|
fd[rec] = OPEN(devaudio, O_RDONLY);
|
|
REQUIRED_SYS_OK(fd[rec]);
|
|
|
|
/* Get block size */
|
|
r = IOCTL(fd[rec], AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
blocksize = ai.blocksize;
|
|
|
|
buf = (char *)malloc(blocksize);
|
|
REQUIRED_IF(buf != NULL);
|
|
|
|
/*
|
|
* At first, make sure the playback one doesn't return POLLIN.
|
|
*/
|
|
memset(&pfd, 0, sizeof(pfd));
|
|
pfd.fd = fd[play];
|
|
pfd.events = POLLIN;
|
|
r = POLL(&pfd, 1, 0);
|
|
if (r == 0 && pfd.revents == 0) {
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, pfd.revents);
|
|
} else {
|
|
XP_FAIL("play fd returns POLLIN");
|
|
goto abort;
|
|
}
|
|
|
|
/* Start recording */
|
|
r = READ(fd[rec], buf, blocksize);
|
|
XP_SYS_EQ(blocksize, r);
|
|
|
|
/* Poll()ing playback descriptor with POLLIN should not raise */
|
|
r = POLL(&pfd, 1, 1000);
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, pfd.revents);
|
|
|
|
/* Poll()ing recording descriptor with POLLIN should raise */
|
|
pfd.fd = fd[rec];
|
|
r = POLL(&pfd, 1, 0);
|
|
XP_SYS_EQ(1, r);
|
|
XP_EQ(POLLIN, pfd.revents);
|
|
|
|
abort:
|
|
r = CLOSE(fd[play]);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(fd[rec]);
|
|
XP_SYS_EQ(0, r);
|
|
free(buf);
|
|
}
|
|
|
|
/*
|
|
* Whether kqueue() succeeds with specified mode.
|
|
*/
|
|
void
|
|
test_kqueue_mode(int openmode, int filt, int expected)
|
|
{
|
|
struct kevent kev;
|
|
struct timespec ts;
|
|
int fd;
|
|
int kq;
|
|
int r;
|
|
|
|
TEST("kqueue_mode_%s_%s",
|
|
openmode_str[openmode] + 2,
|
|
(filt == EVFILT_READ) ? "READ" : "WRITE");
|
|
if (mode2aumode(openmode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
ts.tv_sec = 0;
|
|
ts.tv_nsec = 100 * 1000 * 1000; // 100msec
|
|
|
|
kq = KQUEUE();
|
|
XP_SYS_OK(kq);
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/*
|
|
* Check whether the specified filter can be set.
|
|
* Any filters can always be set, even if pointless combination.
|
|
* For example, EVFILT_READ can be set on O_WRONLY descriptor
|
|
* though it will never raise.
|
|
* I will not mention about good or bad of this behavior here.
|
|
*/
|
|
EV_SET(&kev, fd, filt, EV_ADD, 0, 0, 0);
|
|
r = KEVENT_SET(kq, &kev, 1);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
if (r == 0) {
|
|
/* If the filter can be set, try kevent(poll) */
|
|
r = KEVENT_POLL(kq, &kev, 1, &ts);
|
|
XP_SYS_EQ(expected, r);
|
|
|
|
/* Delete it */
|
|
EV_SET(&kev, fd, filt, EV_DELETE, 0, 0, 0);
|
|
r = KEVENT_SET(kq, &kev, 1);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(kq);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(kqueue_mode_RDONLY_READ) {
|
|
/* Should raise */
|
|
test_kqueue_mode(O_RDONLY, EVFILT_READ, 1);
|
|
}
|
|
DEF(kqueue_mode_RDONLY_WRITE) {
|
|
/* Should never raise (NetBSD7 has bugs) */
|
|
int expected = (netbsd < 8) ? 1 : 0;
|
|
test_kqueue_mode(O_RDONLY, EVFILT_WRITE, expected);
|
|
}
|
|
DEF(kqueue_mode_WRONLY_READ) {
|
|
/* Should never raise */
|
|
test_kqueue_mode(O_WRONLY, EVFILT_READ, 0);
|
|
}
|
|
DEF(kqueue_mode_WRONLY_WRITE) {
|
|
/* Should raise */
|
|
test_kqueue_mode(O_WRONLY, EVFILT_WRITE, 1);
|
|
}
|
|
DEF(kqueue_mode_RDWR_READ) {
|
|
/* Should raise on fulldup but not on halfdup, on NetBSD9 */
|
|
int expected = hw_fulldup() ? 1 : 0;
|
|
test_kqueue_mode(O_RDWR, EVFILT_READ, expected);
|
|
}
|
|
DEF(kqueue_mode_RDWR_WRITE) {
|
|
/* Should raise */
|
|
test_kqueue_mode(O_RDWR, EVFILT_WRITE, 1);
|
|
}
|
|
|
|
/*
|
|
* kqueue(2) when buffer is empty.
|
|
*/
|
|
DEF(kqueue_empty)
|
|
{
|
|
struct audio_info ai;
|
|
struct kevent kev;
|
|
struct timespec ts;
|
|
int kq;
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("kqueue_empty");
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
kq = KQUEUE();
|
|
XP_SYS_OK(kq);
|
|
|
|
EV_SET(&kev, fd, EV_ADD, EVFILT_WRITE, 0, 0, 0);
|
|
r = KEVENT_SET(kq, &kev, 1);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* When the buffer is empty, it should succeed even if timeout == 0 */
|
|
memset(&ts, 0, sizeof(ts));
|
|
r = KEVENT_POLL(kq, &kev, 1, &ts);
|
|
XP_SYS_EQ(1, r);
|
|
XP_EQ(fd, kev.ident);
|
|
/*
|
|
* XXX According to kqueue(2) manpage, returned kev.data contains
|
|
* "the amount of space remaining in the write buffer".
|
|
* NetBSD7 returns buffer_size. Shouldn't it be blocksize * hiwat?
|
|
*/
|
|
/* XP_EQ(ai.blocksize * ai.hiwat, kev.data); */
|
|
XP_EQ(ai.play.buffer_size, kev.data);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(kq);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* kqueue(2) when buffer is full.
|
|
*/
|
|
DEF(kqueue_full)
|
|
{
|
|
struct audio_info ai;
|
|
struct kevent kev;
|
|
struct timespec ts;
|
|
int kq;
|
|
int fd;
|
|
int r;
|
|
char *buf;
|
|
int buflen;
|
|
|
|
TEST("kqueue_full");
|
|
|
|
fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Pause */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Get buffer size */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Write until full */
|
|
buflen = ai.play.buffer_size;
|
|
buf = (char *)malloc(buflen);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, buflen);
|
|
do {
|
|
r = WRITE(fd, buf, buflen);
|
|
} while (r == buflen);
|
|
if (r == -1) {
|
|
XP_SYS_NG(EAGAIN, r);
|
|
}
|
|
|
|
kq = KQUEUE();
|
|
XP_SYS_OK(kq);
|
|
|
|
EV_SET(&kev, fd, EV_ADD, EVFILT_WRITE, 0, 0, 0);
|
|
r = KEVENT_SET(kq, &kev, 1);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* kevent() should not raise */
|
|
ts.tv_sec = 0;
|
|
ts.tv_nsec = 100L * 1000 * 1000; /* 100msec */
|
|
r = KEVENT_POLL(kq, &kev, 1, &ts);
|
|
XP_SYS_EQ(0, r);
|
|
if (r > 0) {
|
|
XP_EQ(fd, kev.ident);
|
|
XP_EQ(0, kev.data);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(kq);
|
|
XP_SYS_EQ(0, r);
|
|
free(buf);
|
|
}
|
|
|
|
/*
|
|
* kqueue(2) when buffer is full but hiwat sets lower than full.
|
|
*/
|
|
DEF(kqueue_hiwat)
|
|
{
|
|
struct audio_info ai;
|
|
struct kevent kev;
|
|
struct timespec ts;
|
|
int kq;
|
|
int fd;
|
|
int r;
|
|
char *buf;
|
|
int buflen;
|
|
int newhiwat;
|
|
|
|
TEST("kqueue_hiwat");
|
|
|
|
fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Get buffer size and hiwat */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "hiwat");
|
|
XP_SYS_EQ(0, r);
|
|
/* Change hiwat some different value */
|
|
newhiwat = ai.hiwat - 1;
|
|
|
|
/* Set pause and hiwat */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
ai.hiwat = newhiwat;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=1;hiwat");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Get the set parameters again */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(1, ai.play.pause);
|
|
XP_EQ(newhiwat, ai.hiwat);
|
|
|
|
/* Write until full */
|
|
buflen = ai.blocksize * ai.hiwat;
|
|
buf = (char *)malloc(buflen);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, buflen);
|
|
do {
|
|
r = WRITE(fd, buf, buflen);
|
|
} while (r == buflen);
|
|
if (r == -1) {
|
|
XP_SYS_NG(EAGAIN, r);
|
|
}
|
|
|
|
kq = KQUEUE();
|
|
XP_SYS_OK(kq);
|
|
|
|
EV_SET(&kev, fd, EV_ADD, EVFILT_WRITE, 0, 0, 0);
|
|
r = KEVENT_SET(kq, &kev, 1);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Should not raise because it's not possible to write */
|
|
ts.tv_sec = 0;
|
|
ts.tv_nsec = 100L * 1000 * 1000; /* 100msec */
|
|
r = KEVENT_POLL(kq, &kev, 1, &ts);
|
|
if (r > 0)
|
|
DEBUG_KEV("kev", &kev);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(kq);
|
|
XP_SYS_EQ(0, r);
|
|
free(buf);
|
|
}
|
|
|
|
/*
|
|
* Unpause from buffer full, kevent() should raise.
|
|
*/
|
|
DEF(kqueue_unpause)
|
|
{
|
|
struct audio_info ai;
|
|
struct kevent kev;
|
|
struct timespec ts;
|
|
int fd;
|
|
int r;
|
|
int kq;
|
|
char *buf;
|
|
int buflen;
|
|
u_int blocksize;
|
|
int hiwat;
|
|
int lowat;
|
|
|
|
TEST("kqueue_unpause");
|
|
|
|
/* Non-blocking open */
|
|
fd = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Adjust block size and hiwat/lowat to make the test time 1sec */
|
|
blocksize = 1000; /* 1/8 sec in mulaw,1ch,8000Hz */
|
|
hiwat = 12; /* 1.5sec */
|
|
lowat = 4; /* 0.5sec */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.blocksize = blocksize;
|
|
ai.hiwat = hiwat;
|
|
ai.lowat = lowat;
|
|
/* and also set encoding */
|
|
/*
|
|
* XXX NetBSD7 has different results depending on whether the input
|
|
* encoding is emulated (AUDIO_ENCODINGFLAG_EMULATED) or not. It's
|
|
* not easy to ensure this situation on all hardware environment.
|
|
* On NetBSD9, the result is the same regardless of input encoding.
|
|
*/
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "blocksize=%d", blocksize);
|
|
XP_SYS_EQ(0, r);
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
if (ai.blocksize != blocksize) {
|
|
/*
|
|
* NetBSD9 can not change the blocksize. Then,
|
|
* adjust using hiwat/lowat.
|
|
*/
|
|
blocksize = ai.blocksize;
|
|
hiwat = howmany(8000 * 1.5, blocksize);
|
|
lowat = howmany(8000 * 0.5, blocksize);
|
|
}
|
|
/* Anyway, set the parameters */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.blocksize = blocksize;
|
|
ai.hiwat = hiwat;
|
|
ai.lowat = lowat;
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=1");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Get the set parameters again */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
DPRINTF(" > blocksize=%d hiwat=%d lowat=%d buffer_size=%d\n",
|
|
ai.blocksize, ai.hiwat, ai.lowat, ai.play.buffer_size);
|
|
|
|
/* Write until full */
|
|
buflen = ai.blocksize * ai.hiwat;
|
|
buf = (char *)malloc(buflen);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, buflen);
|
|
do {
|
|
r = WRITE(fd, buf, buflen);
|
|
} while (r == buflen);
|
|
if (r == -1) {
|
|
XP_SYS_NG(EAGAIN, r);
|
|
}
|
|
|
|
kq = KQUEUE();
|
|
XP_SYS_OK(kq);
|
|
|
|
EV_SET(&kev, fd, EV_ADD, EVFILT_WRITE, 0, 0, 0);
|
|
r = KEVENT_SET(kq, &kev, 1);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Unpause */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 0;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=0");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Check kevent() up to 2sec */
|
|
ts.tv_sec = 2;
|
|
ts.tv_nsec = 0;
|
|
r = KEVENT_POLL(kq, &kev, 1, &ts);
|
|
if (r >= 1)
|
|
DEBUG_KEV("kev", &kev);
|
|
if (netbsd < 8) {
|
|
/*
|
|
* NetBSD7 with EMULATED_FLAG unset has bugs. Unpausing
|
|
* unintentionally clears buffer (and therefore it becomes
|
|
* writable) but it doesn't raise EVFILT_WRITE.
|
|
*/
|
|
} else {
|
|
XP_SYS_EQ(1, r);
|
|
}
|
|
|
|
/* Flush it because there is no need to play it */
|
|
r = IOCTL(fd, AUDIO_FLUSH, NULL, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(kq);
|
|
XP_SYS_EQ(0, r);
|
|
free(buf);
|
|
}
|
|
|
|
/*
|
|
* kevent(2) must not be affected by other audio descriptors.
|
|
*/
|
|
DEF(kqueue_simul)
|
|
{
|
|
struct audio_info ai;
|
|
struct audio_info ai2;
|
|
struct kevent kev[2];
|
|
struct timespec ts;
|
|
int fd[2];
|
|
int r;
|
|
int kq;
|
|
u_int blocksize;
|
|
int hiwat;
|
|
int lowat;
|
|
char *buf;
|
|
int buflen;
|
|
|
|
TEST("kqueue_simul");
|
|
if (netbsd < 8) {
|
|
XP_SKIP("Multiple open is not supported");
|
|
return;
|
|
}
|
|
|
|
memset(&ts, 0, sizeof(ts));
|
|
|
|
/* Make sure that it's not affected by descriptor order */
|
|
for (int i = 0; i < 2; i++) {
|
|
int a = i;
|
|
int b = 1 - i;
|
|
|
|
fd[0] = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
|
|
REQUIRED_SYS_OK(fd[0]);
|
|
fd[1] = OPEN(devaudio, O_WRONLY | O_NONBLOCK);
|
|
REQUIRED_SYS_OK(fd[1]);
|
|
|
|
/*
|
|
* Adjust block size and hiwat/lowat.
|
|
* I want to choice suitable blocksize (if possible).
|
|
*/
|
|
blocksize = 1000; /* 1/8 sec in mulaw,1ch,8000Hz */
|
|
hiwat = 12; /* 1.5sec */
|
|
lowat = 4; /* 0.5sec */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.blocksize = blocksize;
|
|
ai.hiwat = hiwat;
|
|
ai.lowat = lowat;
|
|
r = IOCTL(fd[0], AUDIO_SETINFO, &ai, "blocksize=1000");
|
|
XP_SYS_EQ(0, r);
|
|
r = IOCTL(fd[0], AUDIO_GETBUFINFO, &ai, "read back blocksize");
|
|
if (ai.blocksize != blocksize) {
|
|
/*
|
|
* NetBSD9 can not change the blocksize. Then,
|
|
* adjust using hiwat/lowat.
|
|
*/
|
|
blocksize = ai.blocksize;
|
|
hiwat = howmany(8000 * 1.5, blocksize);
|
|
lowat = howmany(8000 * 0.5, blocksize);
|
|
}
|
|
/* Anyway, set the parameters to both */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.blocksize = blocksize;
|
|
ai.hiwat = hiwat;
|
|
ai.lowat = lowat;
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd[a], AUDIO_SETINFO, &ai, "pause=1");
|
|
XP_SYS_EQ(0, r);
|
|
r = IOCTL(fd[b], AUDIO_SETINFO, &ai, "pause=1");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Write both until full */
|
|
buflen = ai.blocksize * ai.hiwat;
|
|
buf = (char *)malloc(buflen);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, buflen);
|
|
/* Write fdA */
|
|
do {
|
|
r = WRITE(fd[a], buf, buflen);
|
|
} while (r == buflen);
|
|
if (r == -1) {
|
|
XP_SYS_NG(EAGAIN, r);
|
|
}
|
|
/* Write fdB */
|
|
do {
|
|
r = WRITE(fd[b], buf, buflen);
|
|
} while (r == buflen);
|
|
if (r == -1) {
|
|
XP_SYS_NG(EAGAIN, r);
|
|
}
|
|
|
|
/* Get fdB's initial seek for later */
|
|
r = IOCTL(fd[b], AUDIO_GETBUFINFO, &ai2, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
kq = KQUEUE();
|
|
XP_SYS_OK(kq);
|
|
|
|
/* Both aren't raised at this point */
|
|
EV_SET(&kev[0], fd[a], EV_ADD, EVFILT_WRITE, 0, 0, 0);
|
|
EV_SET(&kev[1], fd[b], EV_ADD, EVFILT_WRITE, 0, 0, 0);
|
|
r = KEVENT_SET(kq, kev, 2);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Unpause only fdA */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 0;
|
|
r = IOCTL(fd[a], AUDIO_SETINFO, &ai, "pause=0");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* kevent() up to 2sec */
|
|
ts.tv_sec = 2;
|
|
ts.tv_nsec = 0;
|
|
r = KEVENT_POLL(kq, &kev[0], 1, &ts);
|
|
if (r >= 1)
|
|
DEBUG_KEV("kev", &kev[0]);
|
|
/* fdA should raise */
|
|
XP_SYS_EQ(1, r);
|
|
XP_EQ(fd[a], kev[0].ident);
|
|
|
|
/* Make sure that fdB keeps whole data */
|
|
r = IOCTL(fd[b], AUDIO_GETBUFINFO, &ai, "");
|
|
XP_EQ(ai2.play.seek, ai.play.seek);
|
|
|
|
/* Flush it because there is no need to play it */
|
|
r = IOCTL(fd[0], AUDIO_FLUSH, NULL, "");
|
|
XP_SYS_EQ(0, r);
|
|
r = IOCTL(fd[1], AUDIO_FLUSH, NULL, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd[0]);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(fd[1]);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(kq);
|
|
XP_SYS_EQ(0, r);
|
|
free(buf);
|
|
|
|
xxx_close_wait();
|
|
}
|
|
}
|
|
|
|
/* Shared data between threads for ioctl_while_write */
|
|
struct ioctl_while_write_data {
|
|
int fd;
|
|
struct timeval start;
|
|
int terminated;
|
|
};
|
|
|
|
/* Test thread for ioctl_while_write */
|
|
void *thread_ioctl_while_write(void *);
|
|
void *
|
|
thread_ioctl_while_write(void *arg)
|
|
{
|
|
struct ioctl_while_write_data *data = arg;
|
|
struct timeval now, res;
|
|
struct audio_info ai;
|
|
int r;
|
|
|
|
/* If 0.5 seconds have elapsed since writing, assume it's blocked */
|
|
do {
|
|
usleep(100);
|
|
gettimeofday(&now, NULL);
|
|
timersub(&now, &data->start, &res);
|
|
} while (res.tv_usec < 500000);
|
|
|
|
/* Then, do ioctl() */
|
|
r = IOCTL(data->fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Terminate */
|
|
data->terminated = 1;
|
|
|
|
/* Resume write() by unpause */
|
|
AUDIO_INITINFO(&ai);
|
|
if (netbsd < 8) {
|
|
/*
|
|
* XXX NetBSD7 has bugs and it cannot be unpaused.
|
|
* However, it also has another bug and it clears buffer
|
|
* when encoding is changed. I use it. :-P
|
|
*/
|
|
ai.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
}
|
|
ai.play.pause = 0;
|
|
r = IOCTL(data->fd, AUDIO_SETINFO, &ai, "pause=0");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* ioctl(2) can be issued while write(2)-ing.
|
|
*/
|
|
DEF(ioctl_while_write)
|
|
{
|
|
struct audio_info ai;
|
|
struct ioctl_while_write_data data0, *data;
|
|
char buf[8000]; /* 1sec in mulaw,1ch,8000Hz */
|
|
pthread_t tid;
|
|
int r;
|
|
|
|
TEST("ioctl_while_write");
|
|
|
|
data = &data0;
|
|
memset(data, 0, sizeof(*data));
|
|
memset(buf, 0xff, sizeof(buf));
|
|
|
|
data->fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(data->fd);
|
|
|
|
/* Pause to block write(2)ing */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
r = IOCTL(data->fd, AUDIO_SETINFO, &ai, "pause=1");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
gettimeofday(&data->start, NULL);
|
|
|
|
pthread_create(&tid, NULL, thread_ioctl_while_write, data);
|
|
|
|
/* Write until blocking */
|
|
for (;;) {
|
|
r = WRITE(data->fd, buf, sizeof(buf));
|
|
if (data->terminated)
|
|
break;
|
|
XP_SYS_EQ(sizeof(buf), r);
|
|
|
|
/* Update written time */
|
|
gettimeofday(&data->start, NULL);
|
|
}
|
|
|
|
pthread_join(tid, NULL);
|
|
|
|
/* Flush */
|
|
r = IOCTL(data->fd, AUDIO_FLUSH, NULL, "");
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(data->fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
volatile int sigio_caught;
|
|
void
|
|
signal_FIOASYNC(int signo)
|
|
{
|
|
if (signo == SIGIO) {
|
|
sigio_caught = 1;
|
|
DPRINTF(" > %d: pid %d got SIGIO\n", __LINE__, (int)getpid());
|
|
}
|
|
}
|
|
|
|
/*
|
|
* FIOASYNC between two descriptors should be split.
|
|
*/
|
|
DEF(FIOASYNC_reset)
|
|
{
|
|
int fd0, fd1;
|
|
int r;
|
|
int val;
|
|
|
|
TEST("FIOASYNC_reset");
|
|
if (netbsd < 8) {
|
|
XP_SKIP("Multiple open is not supported");
|
|
return;
|
|
}
|
|
|
|
/* The first one opens */
|
|
fd0 = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd0);
|
|
|
|
/* The second one opens, enables ASYNC, and closes */
|
|
fd1 = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd1);
|
|
val = 1;
|
|
r = IOCTL(fd1, FIOASYNC, &val, "on");
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(fd1);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Again, the second one opens and enables ASYNC */
|
|
fd1 = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd1);
|
|
val = 1;
|
|
r = IOCTL(fd1, FIOASYNC, &val, "on");
|
|
XP_SYS_EQ(0, r); /* NetBSD8 fails */
|
|
r = CLOSE(fd1);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(fd0);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Whether SIGIO is emitted on playback.
|
|
* XXX I don't understand conditions that NetBSD7 emits signal.
|
|
*/
|
|
DEF(FIOASYNC_play_signal)
|
|
{
|
|
struct audio_info ai;
|
|
int r;
|
|
int fd;
|
|
int val;
|
|
char *data;
|
|
int i;
|
|
|
|
TEST("FIOASYNC_play_signal");
|
|
if (hw_canplay() == 0) {
|
|
XP_SKIP("This test is only for playable device");
|
|
return;
|
|
}
|
|
|
|
signal(SIGIO, signal_FIOASYNC);
|
|
sigio_caught = 0;
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
REQUIRED_IF(ai.blocksize != 0);
|
|
data = (char *)malloc(ai.blocksize);
|
|
REQUIRED_IF(data != NULL);
|
|
memset(data, 0xff, ai.blocksize);
|
|
|
|
val = 1;
|
|
r = IOCTL(fd, FIOASYNC, &val, "on");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = WRITE(fd, data, ai.blocksize);
|
|
XP_SYS_EQ(ai.blocksize, r);
|
|
|
|
/* Waits signal until 1sec */
|
|
for (i = 0; i < 100 && sigio_caught == 0; i++) {
|
|
usleep(10000);
|
|
}
|
|
signal(SIGIO, SIG_IGN);
|
|
XP_EQ(1, sigio_caught);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
free(data);
|
|
signal(SIGIO, SIG_IGN);
|
|
sigio_caught = 0;
|
|
}
|
|
|
|
/*
|
|
* Whether SIGIO is emitted on recording.
|
|
*/
|
|
DEF(FIOASYNC_rec_signal)
|
|
{
|
|
char buf[10];
|
|
int r;
|
|
int fd;
|
|
int val;
|
|
int i;
|
|
|
|
TEST("FIOASYNC_rec_signal");
|
|
if (hw_canrec() == 0) {
|
|
XP_SKIP("This test is only for recordable device");
|
|
return;
|
|
}
|
|
|
|
signal(SIGIO, signal_FIOASYNC);
|
|
sigio_caught = 0;
|
|
|
|
fd = OPEN(devaudio, O_RDONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
val = 1;
|
|
r = IOCTL(fd, FIOASYNC, &val, "on");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = READ(fd, buf, sizeof(buf));
|
|
XP_SYS_EQ(sizeof(buf), r);
|
|
|
|
/* Wait signal until 1sec */
|
|
for (i = 0; i < 100 && sigio_caught == 0; i++) {
|
|
usleep(10000);
|
|
}
|
|
signal(SIGIO, SIG_IGN);
|
|
XP_EQ(1, sigio_caught);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
signal(SIGIO, SIG_IGN);
|
|
sigio_caught = 0;
|
|
}
|
|
|
|
/*
|
|
* FIOASYNC doesn't affect other descriptor.
|
|
* For simplify, test only for playback...
|
|
*/
|
|
DEF(FIOASYNC_multi)
|
|
{
|
|
struct audio_info ai;
|
|
char *buf;
|
|
char pipebuf[1];
|
|
int r;
|
|
int i;
|
|
int fd1;
|
|
int fd2;
|
|
int pd[2];
|
|
int val;
|
|
pid_t pid;
|
|
int status;
|
|
|
|
TEST("FIOASYNC_multi");
|
|
if (netbsd < 8) {
|
|
XP_SKIP("Multiple open is not supported");
|
|
return;
|
|
}
|
|
if (hw_canplay() == 0) {
|
|
XP_SKIP("This test is only for playable device");
|
|
return;
|
|
}
|
|
|
|
/* Pipe used between parent and child */
|
|
r = pipe(pd);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
fd1 = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd1);
|
|
fd2 = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd2);
|
|
|
|
/* Pause fd2 */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd2, AUDIO_SETINFO, &ai, "pause");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* Fill both */
|
|
r = IOCTL(fd1, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
REQUIRED_IF(ai.blocksize != 0);
|
|
buf = (char *)malloc(ai.blocksize);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, ai.blocksize);
|
|
r = WRITE(fd1, buf, ai.blocksize);
|
|
XP_SYS_EQ(ai.blocksize, r);
|
|
|
|
sigio_caught = 0;
|
|
val = 1;
|
|
|
|
fflush(stdout);
|
|
fflush(stderr);
|
|
pid = fork();
|
|
if (pid == -1) {
|
|
REQUIRED_SYS_OK(pid);
|
|
}
|
|
if (pid == 0) {
|
|
/* Child */
|
|
close(fd1);
|
|
|
|
/* Child enables ASYNC on fd2 */
|
|
signal(SIGIO, signal_FIOASYNC);
|
|
r = IOCTL(fd2, FIOASYNC, &val, "on");
|
|
/* It cannot count errors because here is a child process */
|
|
/* XP_SYS_EQ(0, r); */
|
|
|
|
/*
|
|
* Waits signal until 1sec.
|
|
* But fd2 is paused so it should never raise.
|
|
*/
|
|
for (i = 0; i < 100 && sigio_caught == 0; i++) {
|
|
usleep(10000);
|
|
}
|
|
signal(SIGIO, SIG_IGN);
|
|
pipebuf[0] = sigio_caught;
|
|
/* This is not WRITE() macro here */
|
|
write(pd[1], pipebuf, sizeof(pipebuf));
|
|
|
|
/* XXX? */
|
|
close(fd2);
|
|
sleep(1);
|
|
exit(0);
|
|
} else {
|
|
/* Parent */
|
|
DPRINTF(" > fork() = %d\n", (int)pid);
|
|
|
|
/* Parent enables ASYNC on fd1 */
|
|
signal(SIGIO, signal_FIOASYNC);
|
|
r = IOCTL(fd1, FIOASYNC, &val, "on");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Waits signal until 1sec */
|
|
for (i = 0; i < 100 && sigio_caught == 0; i++) {
|
|
usleep(10000);
|
|
}
|
|
signal(SIGIO, SIG_IGN);
|
|
XP_EQ(1, sigio_caught);
|
|
|
|
/* Then read child's result from pipe */
|
|
r = read(pd[0], pipebuf, sizeof(pipebuf));
|
|
if (r != 1) {
|
|
XP_FAIL("reading from child failed");
|
|
}
|
|
DPRINTF(" > child's sigio_cauht = %d\n", pipebuf[0]);
|
|
XP_EQ(0, pipebuf[0]);
|
|
|
|
waitpid(pid, &status, 0);
|
|
}
|
|
|
|
r = CLOSE(fd1);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(fd2);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
signal(SIGIO, SIG_IGN);
|
|
sigio_caught = 0;
|
|
free(buf);
|
|
}
|
|
|
|
/*
|
|
* Check AUDIO_WSEEK behavior.
|
|
*/
|
|
DEF(AUDIO_WSEEK)
|
|
{
|
|
char buf[4];
|
|
struct audio_info ai;
|
|
int r;
|
|
int fd;
|
|
u_long n;
|
|
|
|
TEST("AUDIO_WSEEK");
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Pause to count sample data */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause=1");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* On the initial state, it should be 0 bytes */
|
|
n = 0;
|
|
r = IOCTL(fd, AUDIO_WSEEK, &n, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, n);
|
|
|
|
/* When writing 4 bytes, it should be 4 bytes */
|
|
memset(buf, 0xff, sizeof(buf));
|
|
r = WRITE(fd, buf, sizeof(buf));
|
|
REQUIRED_EQ(sizeof(buf), r);
|
|
r = IOCTL(fd, AUDIO_WSEEK, &n, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (netbsd < 9) {
|
|
/*
|
|
* On NetBSD7, it will return 0.
|
|
* Perhaps, WSEEK returns the number of pustream bytes but
|
|
* data has already advanced...
|
|
*/
|
|
XP_EQ(0, n);
|
|
} else {
|
|
/* Data less than one block remains here */
|
|
XP_EQ(4, n);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Check AUDIO_SETFD behavior for O_*ONLY descriptor.
|
|
* On NetBSD7, SETFD modify audio layer's state (and MD driver's state)
|
|
* regardless of open mode. GETFD obtains audio layer's duplex.
|
|
* On NetBSD9, SETFD is obsoleted. GETFD obtains hardware's duplex.
|
|
*/
|
|
void
|
|
test_AUDIO_SETFD_xxONLY(int openmode)
|
|
{
|
|
struct audio_info ai;
|
|
int r;
|
|
int fd;
|
|
int n;
|
|
|
|
TEST("AUDIO_SETFD_%s", openmode_str[openmode] + 2);
|
|
if (openmode == O_RDONLY && hw_canrec() == 0) {
|
|
XP_SKIP("This test is for recordable device");
|
|
return;
|
|
}
|
|
if (openmode == O_WRONLY && hw_canplay() == 0) {
|
|
XP_SKIP("This test is for playable device");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/*
|
|
* Just after open(2),
|
|
* - On NetBSD7, it's always half-duplex.
|
|
* - On NetBSD9, it's the same as hardware one regardless of openmode.
|
|
*/
|
|
n = 0;
|
|
r = IOCTL(fd, AUDIO_GETFD, &n, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (netbsd < 9) {
|
|
XP_EQ(0, n);
|
|
} else {
|
|
XP_EQ(hw_fulldup(), n);
|
|
}
|
|
|
|
/*
|
|
* When trying to set to full-duplex,
|
|
* - On NetBSD7, it will succeed if the hardware is full-duplex, or
|
|
* will fail if the hardware is half-duplex.
|
|
* - On NetBSD9, it will always succeed but will not be modified.
|
|
*/
|
|
n = 1;
|
|
r = IOCTL(fd, AUDIO_SETFD, &n, "on");
|
|
if (netbsd < 8) {
|
|
if (hw_fulldup()) {
|
|
XP_SYS_EQ(0, r);
|
|
} else {
|
|
XP_SYS_NG(ENOTTY, r);
|
|
}
|
|
} else if (netbsd == 8) {
|
|
XP_FAIL("expected result is unknown");
|
|
} else {
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* When obtain it,
|
|
* - On NetBSD7, it will be 1 if the hardware is full-duplex or
|
|
* 0 if half-duplex.
|
|
* - On NetBSD9, it will never be changed because it's the hardware
|
|
* property.
|
|
*/
|
|
n = 0;
|
|
r = IOCTL(fd, AUDIO_GETFD, &n, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (netbsd < 8) {
|
|
XP_EQ(hw_fulldup(), n);
|
|
} else if (netbsd == 8) {
|
|
XP_FAIL("expected result is unknown");
|
|
} else {
|
|
XP_EQ(hw_fulldup(), n);
|
|
}
|
|
|
|
/* Some track parameters like ai.*.open should not change */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(mode2play(openmode), ai.play.open);
|
|
XP_EQ(mode2rec(openmode), ai.record.open);
|
|
|
|
/*
|
|
* When trying to set to half-duplex,
|
|
* - On NetBSD7, it will succeed if the hardware is full-duplex, or
|
|
* it will succeed with nothing happens.
|
|
* - On NetBSD9, it will always succeed but nothing happens.
|
|
*/
|
|
n = 0;
|
|
r = IOCTL(fd, AUDIO_SETFD, &n, "off");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/*
|
|
* When obtain it again,
|
|
* - On NetBSD7, it will be 0 if the hardware is full-duplex, or
|
|
* still 0 if half-duplex.
|
|
* - On NetBSD9, it should not change.
|
|
*/
|
|
n = 0;
|
|
r = IOCTL(fd, AUDIO_GETFD, &n, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (netbsd < 9) {
|
|
XP_EQ(0, n);
|
|
} else {
|
|
XP_EQ(hw_fulldup(), n);
|
|
}
|
|
|
|
/* Some track parameters like ai.*.open should not change */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(mode2play(openmode), ai.play.open);
|
|
XP_EQ(mode2rec(openmode), ai.record.open);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(AUDIO_SETFD_RDONLY) { test_AUDIO_SETFD_xxONLY(O_RDONLY); }
|
|
DEF(AUDIO_SETFD_WRONLY) { test_AUDIO_SETFD_xxONLY(O_WRONLY); }
|
|
|
|
/*
|
|
* Check AUDIO_SETFD behavior for O_RDWR descriptor.
|
|
*/
|
|
DEF(AUDIO_SETFD_RDWR)
|
|
{
|
|
struct audio_info ai;
|
|
int r;
|
|
int fd;
|
|
int n;
|
|
|
|
TEST("AUDIO_SETFD_RDWR");
|
|
if (!hw_fulldup()) {
|
|
XP_SKIP("This test is only for full-duplex device");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, O_RDWR);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/*
|
|
* - audio(4) manpage until NetBSD7 said "If a full-duplex capable
|
|
* audio device is opened for both reading and writing it will
|
|
* start in half-duplex play mode", but implementation doesn't
|
|
* seem to follow it. It returns full-duplex.
|
|
* - On NetBSD9, it should return full-duplex on full-duplex, or
|
|
* half-duplex on half-duplex.
|
|
*/
|
|
n = 0;
|
|
r = IOCTL(fd, AUDIO_GETFD, &n, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(hw_fulldup(), n);
|
|
|
|
/*
|
|
* When trying to set to full-duplex,
|
|
* - On NetBSD7, it will succeed with nothing happens if full-duplex,
|
|
* or will fail if half-duplex.
|
|
* - On NetBSD9, it will always succeed with nothing happens.
|
|
*/
|
|
n = 1;
|
|
r = IOCTL(fd, AUDIO_SETFD, &n, "on");
|
|
if (netbsd < 9) {
|
|
if (hw_fulldup()) {
|
|
XP_SYS_EQ(0, r);
|
|
} else {
|
|
XP_SYS_NG(ENOTTY, r);
|
|
}
|
|
} else {
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/* When obtains it, it returns half/full-duplex as is */
|
|
n = 0;
|
|
r = IOCTL(fd, AUDIO_GETFD, &n, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(hw_fulldup(), n);
|
|
|
|
/* Some track parameters like ai.*.open should not change */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(1, ai.play.open);
|
|
XP_EQ(mode2rec(O_RDWR), ai.record.open);
|
|
|
|
/*
|
|
* When trying to set to half-duplex,
|
|
* - On NetBSD7, it will succeed if the hardware is full-duplex, or
|
|
* it will succeed with nothing happens.
|
|
* - On NetBSD9, it will always succeed but nothing happens.
|
|
*/
|
|
n = 0;
|
|
r = IOCTL(fd, AUDIO_SETFD, &n, "off");
|
|
if (netbsd < 8) {
|
|
XP_SYS_EQ(0, r);
|
|
} else if (netbsd == 8) {
|
|
XP_FAIL("expected result is unknown");
|
|
} else {
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* When obtain it again,
|
|
* - On NetBSD7, it will be 0 if the hardware is full-duplex, or
|
|
* still 0 if half-duplex.
|
|
* - On NetBSD9, it should be 1 if the hardware is full-duplex, or
|
|
* 0 if half-duplex.
|
|
*/
|
|
n = 0;
|
|
r = IOCTL(fd, AUDIO_GETFD, &n, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (netbsd < 8) {
|
|
XP_EQ(0, n);
|
|
} else if (netbsd == 8) {
|
|
XP_FAIL("expected result is unknown");
|
|
} else {
|
|
XP_EQ(hw_fulldup(), n);
|
|
}
|
|
|
|
/* Some track parameters like ai.*.open should not change */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(1, ai.play.open);
|
|
XP_EQ(mode2rec(O_RDWR), ai.record.open);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Check AUDIO_GETINFO.eof behavior.
|
|
*/
|
|
DEF(AUDIO_GETINFO_eof)
|
|
{
|
|
struct audio_info ai;
|
|
char buf[4];
|
|
int r;
|
|
int fd, fd1;
|
|
|
|
TEST("AUDIO_GETINFO_eof");
|
|
if (hw_canplay() == 0) {
|
|
XP_SKIP("This test is for playable device");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, O_RDWR);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Pause to make no sound */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "pause");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* It should be 0 initially */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, ai.play.eof);
|
|
XP_EQ(0, ai.record.eof);
|
|
|
|
/* Writing zero bytes should increment it */
|
|
r = WRITE(fd, &r, 0);
|
|
REQUIRED_SYS_OK(r);
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(1, ai.play.eof);
|
|
XP_EQ(0, ai.record.eof);
|
|
|
|
/* Writing one ore more bytes should noto increment it */
|
|
memset(buf, 0xff, sizeof(buf));
|
|
r = WRITE(fd, buf, sizeof(buf));
|
|
REQUIRED_SYS_OK(r);
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(1, ai.play.eof);
|
|
XP_EQ(0, ai.record.eof);
|
|
|
|
/* Writing zero bytes again should increment it */
|
|
r = WRITE(fd, buf, 0);
|
|
REQUIRED_SYS_OK(r);
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(2, ai.play.eof);
|
|
XP_EQ(0, ai.record.eof);
|
|
|
|
/* Reading zero bytes should not increment it */
|
|
if (hw_fulldup()) {
|
|
r = READ(fd, buf, 0);
|
|
REQUIRED_SYS_OK(r);
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(2, ai.play.eof);
|
|
XP_EQ(0, ai.record.eof);
|
|
}
|
|
|
|
/* should not interfere with other descriptor */
|
|
if (netbsd >= 8) {
|
|
fd1 = OPEN(devaudio, O_RDWR);
|
|
REQUIRED_SYS_OK(fd1);
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd1, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, ai.play.eof);
|
|
XP_EQ(0, ai.record.eof);
|
|
r = CLOSE(fd1);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
xxx_close_wait();
|
|
|
|
/* When reopen, it should reset the counter */
|
|
fd = OPEN(devaudio, O_RDWR);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, ai.play.eof);
|
|
XP_EQ(0, ai.record.eof);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Check relationship between openmode and mode set by AUDIO_SETINFO.
|
|
*/
|
|
void
|
|
test_AUDIO_SETINFO_mode(int openmode, int index, int setmode, int expected)
|
|
{
|
|
struct audio_info ai;
|
|
char buf[10];
|
|
int inimode;
|
|
int r;
|
|
int fd;
|
|
bool canwrite;
|
|
bool canread;
|
|
|
|
/* index was passed only for displaying here */
|
|
TEST("AUDIO_SETINFO_mode_%s_%d", openmode_str[openmode] + 2, index);
|
|
if (mode2aumode(openmode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
inimode = mode2aumode(openmode);
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* When just after opening */
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd, AUDIO_GETINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
XP_EQ(inimode, ai.mode);
|
|
XP_EQ(mode2play(openmode), ai.play.open);
|
|
XP_EQ(mode2rec(openmode), ai.record.open);
|
|
XP_NE(0, ai.play.buffer_size);
|
|
XP_NE(0, ai.record.buffer_size);
|
|
|
|
/* Change mode (and pause here) */
|
|
ai.mode = setmode;
|
|
ai.play.pause = 1;
|
|
ai.record.pause = 1;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "mode");
|
|
XP_SYS_EQ(0, r);
|
|
if (r == 0) {
|
|
r = IOCTL(fd, AUDIO_GETINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(expected, ai.mode);
|
|
|
|
/* It seems to keep the initial openmode regardless of mode */
|
|
XP_EQ(mode2play(openmode), ai.play.open);
|
|
XP_EQ(mode2rec(openmode), ai.record.open);
|
|
XP_NE(0, ai.play.buffer_size);
|
|
XP_NE(0, ai.record.buffer_size);
|
|
}
|
|
|
|
/*
|
|
* On NetBSD7, whether writable depends openmode when open.
|
|
* On NetBSD9, whether writable should depend inimode when open.
|
|
* Modifying after open should not affect this mode.
|
|
*/
|
|
if (netbsd < 9) {
|
|
canwrite = (openmode != O_RDONLY);
|
|
} else {
|
|
canwrite = ((inimode & AUMODE_PLAY) != 0);
|
|
}
|
|
r = WRITE(fd, buf, 0);
|
|
if (canwrite) {
|
|
XP_SYS_EQ(0, r);
|
|
} else {
|
|
XP_SYS_NG(EBADF, r);
|
|
}
|
|
|
|
/*
|
|
* On NetBSD7, whether readable depends openmode when open.
|
|
* On NetBSD9, whether readable should depend inimode when open.
|
|
* Modifying after open should not affect this mode.
|
|
*/
|
|
if (netbsd < 9) {
|
|
canread = (openmode != O_WRONLY);
|
|
} else {
|
|
canread = ((inimode & AUMODE_RECORD) != 0);
|
|
}
|
|
r = READ(fd, buf, 0);
|
|
if (canread) {
|
|
XP_SYS_EQ(0, r);
|
|
} else {
|
|
XP_SYS_NG(EBADF, r);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
/*
|
|
* XXX hmm... it's too complex
|
|
*/
|
|
/* shortcut for table form */
|
|
#define P AUMODE_PLAY
|
|
#define A AUMODE_PLAY_ALL
|
|
#define R AUMODE_RECORD
|
|
struct setinfo_mode_t {
|
|
int setmode; /* mode used in SETINFO */
|
|
int expmode7; /* expected mode on NetBSD7 */
|
|
int expmode9; /* expected mode on NetBSD9 */
|
|
};
|
|
/*
|
|
* The following tables show this operation on NetBSD7 is almost 'undefined'.
|
|
* In contrast, NetBSD9 never changes mode by AUDIO_SETINFO except
|
|
* AUMODE_PLAY_ALL.
|
|
*
|
|
* setmode == 0 and 8 are out of range and invalid input samples.
|
|
* But NetBSD7 seems to accept it as is.
|
|
*/
|
|
struct setinfo_mode_t table_SETINFO_mode_O_RDONLY[] = {
|
|
/* setmode expmode7 expmode9 */
|
|
{ 0, 0, R },
|
|
{ P, P, R },
|
|
{ A , A|P, R },
|
|
{ A|P, A|P, R },
|
|
{ R , R , R },
|
|
{ R| P, P, R },
|
|
{ R|A , A|P, R },
|
|
{ R|A|P, A|P, R },
|
|
{ 8, 8, R },
|
|
};
|
|
struct setinfo_mode_t table_SETINFO_mode_O_WRONLY[] = {
|
|
/* setmode expmode7 expmode9 */
|
|
{ 0, 0, P },
|
|
{ P, P, P },
|
|
{ A , A|P, A|P },
|
|
{ A|P, A|P, A|P },
|
|
{ R , R , P },
|
|
{ R| P, P, P },
|
|
{ R|A , A|P, A|P },
|
|
{ R|A|P, A|P, A|P },
|
|
{ 8, 8, P },
|
|
};
|
|
#define f(openmode, index) do { \
|
|
struct setinfo_mode_t *table = table_SETINFO_mode_##openmode; \
|
|
int setmode = table[index].setmode; \
|
|
int expected = (netbsd < 9) \
|
|
? table[index].expmode7 \
|
|
: table[index].expmode9; \
|
|
test_AUDIO_SETINFO_mode(openmode, index, setmode, expected); \
|
|
} while (0)
|
|
DEF(AUDIO_SETINFO_mode_RDONLY_0) { f(O_RDONLY, 0); }
|
|
DEF(AUDIO_SETINFO_mode_RDONLY_1) { f(O_RDONLY, 1); }
|
|
DEF(AUDIO_SETINFO_mode_RDONLY_2) { f(O_RDONLY, 2); }
|
|
DEF(AUDIO_SETINFO_mode_RDONLY_3) { f(O_RDONLY, 3); }
|
|
DEF(AUDIO_SETINFO_mode_RDONLY_4) { f(O_RDONLY, 4); }
|
|
DEF(AUDIO_SETINFO_mode_RDONLY_5) { f(O_RDONLY, 5); }
|
|
DEF(AUDIO_SETINFO_mode_RDONLY_6) { f(O_RDONLY, 6); }
|
|
DEF(AUDIO_SETINFO_mode_RDONLY_7) { f(O_RDONLY, 7); }
|
|
DEF(AUDIO_SETINFO_mode_RDONLY_8) { f(O_RDONLY, 8); }
|
|
DEF(AUDIO_SETINFO_mode_WRONLY_0) { f(O_WRONLY, 0); }
|
|
DEF(AUDIO_SETINFO_mode_WRONLY_1) { f(O_WRONLY, 1); }
|
|
DEF(AUDIO_SETINFO_mode_WRONLY_2) { f(O_WRONLY, 2); }
|
|
DEF(AUDIO_SETINFO_mode_WRONLY_3) { f(O_WRONLY, 3); }
|
|
DEF(AUDIO_SETINFO_mode_WRONLY_4) { f(O_WRONLY, 4); }
|
|
DEF(AUDIO_SETINFO_mode_WRONLY_5) { f(O_WRONLY, 5); }
|
|
DEF(AUDIO_SETINFO_mode_WRONLY_6) { f(O_WRONLY, 6); }
|
|
DEF(AUDIO_SETINFO_mode_WRONLY_7) { f(O_WRONLY, 7); }
|
|
DEF(AUDIO_SETINFO_mode_WRONLY_8) { f(O_WRONLY, 8); }
|
|
#undef f
|
|
/*
|
|
* The following tables also show that NetBSD7's behavior is almost
|
|
* 'undefined'.
|
|
*/
|
|
struct setinfo_mode_t table_SETINFO_mode_O_RDWR_full[] = {
|
|
/* setmode expmode7 expmode9 */
|
|
{ 0, 0, R| P },
|
|
{ P, P, R| P },
|
|
{ A , A|P, R|A|P },
|
|
{ A|P, A|P, R|A|P },
|
|
{ R , R , R| P },
|
|
{ R| P, R| P, R| P },
|
|
{ R|A , R|A|P, R|A|P },
|
|
{ R|A|P, R|A|P, R|A|P },
|
|
{ 8, 8, R| P },
|
|
};
|
|
struct setinfo_mode_t table_SETINFO_mode_O_RDWR_half[] = {
|
|
/* setmode expmode7 expmode9 */
|
|
{ 0, 0, P },
|
|
{ P, P, P },
|
|
{ A , A|P, A|P },
|
|
{ A|P, A|P, A|P },
|
|
{ R , R , P },
|
|
{ R| P, P, P },
|
|
{ R|A , A|P, A|P },
|
|
{ R|A|P, A|P, A|P },
|
|
{ 8, 8, P },
|
|
};
|
|
#define f(index) do { \
|
|
struct setinfo_mode_t *table = (hw_fulldup()) \
|
|
? table_SETINFO_mode_O_RDWR_full \
|
|
: table_SETINFO_mode_O_RDWR_half; \
|
|
int setmode = table[index].setmode; \
|
|
int expected = (netbsd < 9) \
|
|
? table[index].expmode7 \
|
|
: table[index].expmode9; \
|
|
test_AUDIO_SETINFO_mode(O_RDWR, index, setmode, expected); \
|
|
} while (0)
|
|
DEF(AUDIO_SETINFO_mode_RDWR_0) { f(0); }
|
|
DEF(AUDIO_SETINFO_mode_RDWR_1) { f(1); }
|
|
DEF(AUDIO_SETINFO_mode_RDWR_2) { f(2); }
|
|
DEF(AUDIO_SETINFO_mode_RDWR_3) { f(3); }
|
|
DEF(AUDIO_SETINFO_mode_RDWR_4) { f(4); }
|
|
DEF(AUDIO_SETINFO_mode_RDWR_5) { f(5); }
|
|
DEF(AUDIO_SETINFO_mode_RDWR_6) { f(6); }
|
|
DEF(AUDIO_SETINFO_mode_RDWR_7) { f(7); }
|
|
DEF(AUDIO_SETINFO_mode_RDWR_8) { f(8); }
|
|
#undef f
|
|
#undef P
|
|
#undef A
|
|
#undef R
|
|
|
|
/*
|
|
* Check whether encoding params can be set.
|
|
*/
|
|
void
|
|
test_AUDIO_SETINFO_params_set(int openmode, int aimode, int pause)
|
|
{
|
|
struct audio_info ai;
|
|
int r;
|
|
int fd;
|
|
|
|
/*
|
|
* aimode is bool value that indicates whether to change ai.mode.
|
|
* pause is bool value that indicates whether to change ai.*.pause.
|
|
*/
|
|
|
|
TEST("AUDIO_SETINFO_params_%s_%d_%d",
|
|
openmode_str[openmode] + 2, aimode, pause);
|
|
if (mode2aumode(openmode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
/* On half-duplex, O_RDWR is the same as O_WRONLY, so skip it */
|
|
if (!hw_fulldup() && openmode == O_RDWR) {
|
|
XP_SKIP("This is the same with O_WRONLY on half-duplex");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
/*
|
|
* It takes time and effort to check all parameters independently,
|
|
* so that use sample_rate as a representative.
|
|
*/
|
|
ai.play.sample_rate = 11025;
|
|
ai.record.sample_rate = 11025;
|
|
if (aimode)
|
|
ai.mode = mode2aumode(openmode) & ~AUMODE_PLAY_ALL;
|
|
if (pause) {
|
|
ai.play.pause = 1;
|
|
ai.record.pause = 1;
|
|
}
|
|
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
int expmode = (aimode)
|
|
? (mode2aumode(openmode) & ~AUMODE_PLAY_ALL)
|
|
: mode2aumode(openmode);
|
|
XP_EQ(expmode, ai.mode);
|
|
XP_EQ(11025, ai.play.sample_rate);
|
|
XP_EQ(pause, ai.play.pause);
|
|
XP_EQ(11025, ai.record.sample_rate);
|
|
XP_EQ(pause, ai.record.pause);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
#define f(a,b,c) test_AUDIO_SETINFO_params_set(a, b, c)
|
|
DEF(AUDIO_SETINFO_params_set_RDONLY_0) { f(O_RDONLY, 0, 0); }
|
|
DEF(AUDIO_SETINFO_params_set_RDONLY_1) { f(O_RDONLY, 0, 1); }
|
|
/* On RDONLY, ai.mode is not changeable
|
|
* AUDIO_SETINFO_params_set_RDONLY_2) { f(O_RDONLY, 1, 0); }
|
|
* AUDIO_SETINFO_params_set_RDONLY_3) { f(O_RDONLY, 1, 1); }
|
|
*/
|
|
DEF(AUDIO_SETINFO_params_set_WRONLY_0) { f(O_WRONLY, 0, 0); }
|
|
DEF(AUDIO_SETINFO_params_set_WRONLY_1) { f(O_WRONLY, 0, 1); }
|
|
DEF(AUDIO_SETINFO_params_set_WRONLY_2) { f(O_WRONLY, 1, 0); }
|
|
DEF(AUDIO_SETINFO_params_set_WRONLY_3) { f(O_WRONLY, 1, 1); }
|
|
DEF(AUDIO_SETINFO_params_set_RDWR_0) { f(O_RDWR, 0, 0); }
|
|
DEF(AUDIO_SETINFO_params_set_RDWR_1) { f(O_RDWR, 0, 1); }
|
|
DEF(AUDIO_SETINFO_params_set_RDWR_2) { f(O_RDWR, 1, 0); }
|
|
DEF(AUDIO_SETINFO_params_set_RDWR_3) { f(O_RDWR, 1, 1); }
|
|
#undef f
|
|
|
|
/*
|
|
* AUDIO_SETINFO for existing track should not be interfered by other
|
|
* descriptor.
|
|
* AUDIO_SETINFO for non-existing track affects/is affected sticky parameters
|
|
* for backward compatibility.
|
|
*/
|
|
DEF(AUDIO_SETINFO_params_simul)
|
|
{
|
|
struct audio_info ai;
|
|
int fd0;
|
|
int fd1;
|
|
int r;
|
|
|
|
TEST("AUDIO_SETINFO_params_simul");
|
|
if (netbsd < 8) {
|
|
XP_SKIP("Multiple open is not supported");
|
|
return;
|
|
}
|
|
if (hw_canplay() == 0) {
|
|
XP_SKIP("This test is for playable device");
|
|
return;
|
|
}
|
|
|
|
/* Open the 1st one as playback only */
|
|
fd0 = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd0);
|
|
|
|
/* Open the 2nd one as both of playback and recording */
|
|
fd1 = OPEN(devaudio, O_RDWR);
|
|
REQUIRED_SYS_OK(fd1);
|
|
|
|
/* Change some parameters of both track on the 2nd one */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.sample_rate = 11025;
|
|
ai.record.sample_rate = 11025;
|
|
r = IOCTL(fd1, AUDIO_SETINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/*
|
|
* The 1st one doesn't have recording track so that only recording
|
|
* parameter is affected by sticky parameter.
|
|
*/
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd0, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(8000, ai.play.sample_rate);
|
|
XP_EQ(11025, ai.record.sample_rate);
|
|
|
|
/* Next, change some parameters of both track on the 1st one */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.sample_rate = 16000;
|
|
ai.record.sample_rate = 16000;
|
|
r = IOCTL(fd0, AUDIO_SETINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/*
|
|
* On full-duplex device, the 2nd one has both track so that
|
|
* both track are not affected by sticky parameter.
|
|
* Otherwise, the 2nd one has only playback track so that
|
|
* playback track is not affected by sticky parameter.
|
|
*/
|
|
memset(&ai, 0, sizeof(ai));
|
|
r = IOCTL(fd1, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(11025, ai.play.sample_rate);
|
|
if (hw_fulldup()) {
|
|
XP_EQ(11025, ai.record.sample_rate);
|
|
} else {
|
|
XP_EQ(16000, ai.record.sample_rate);
|
|
}
|
|
|
|
r = CLOSE(fd0);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(fd1);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* AUDIO_SETINFO(encoding/precision) is tested in AUDIO_GETENC_range below.
|
|
*/
|
|
|
|
/*
|
|
* Check whether the number of channels can be set.
|
|
*/
|
|
DEF(AUDIO_SETINFO_channels)
|
|
{
|
|
struct audio_info hwinfo;
|
|
struct audio_info ai;
|
|
int mode;
|
|
int r;
|
|
int fd;
|
|
int i;
|
|
unsigned int ch;
|
|
struct {
|
|
int ch;
|
|
bool expected;
|
|
} table[] = {
|
|
{ 0, false },
|
|
{ 1, true }, /* monaural */
|
|
{ 2, true }, /* stereo */
|
|
};
|
|
|
|
TEST("AUDIO_SETINFO_channels");
|
|
if (netbsd < 8) {
|
|
/*
|
|
* On NetBSD7, the result depends the hardware and there is
|
|
* no way to know it.
|
|
*/
|
|
XP_SKIP("The test doesn't make sense on NetBSD7");
|
|
return;
|
|
}
|
|
|
|
mode = openable_mode();
|
|
fd = OPEN(devaudio, mode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/*
|
|
* The audio layer always supports monaural and stereo regardless of
|
|
* the hardware capability.
|
|
*/
|
|
for (i = 0; i < (int)__arraycount(table); i++) {
|
|
ch = table[i].ch;
|
|
bool expected = table[i].expected;
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
if (mode != O_RDONLY)
|
|
ai.play.channels = ch;
|
|
if (mode != O_WRONLY)
|
|
ai.record.channels = ch;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=%d", ch);
|
|
if (expected) {
|
|
/* Expects to succeed */
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (mode != O_RDONLY)
|
|
XP_EQ(ch, ai.play.channels);
|
|
if (mode != O_WRONLY)
|
|
XP_EQ(ch, ai.record.channels);
|
|
} else {
|
|
/* Expects to fail */
|
|
XP_SYS_NG(EINVAL, r);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The maximum number of supported channels depends the hardware.
|
|
*/
|
|
/* Get the number of channels that the hardware supports */
|
|
r = IOCTL(fd, AUDIO_GETFORMAT, &hwinfo, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
if ((hwinfo.mode & AUMODE_PLAY)) {
|
|
DPRINTF(" > hwinfo.play.channels = %d\n",
|
|
hwinfo.play.channels);
|
|
for (ch = 3; ch <= hwinfo.play.channels; ch++) {
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.channels = ch;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=%d", ch);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(ch, ai.play.channels);
|
|
}
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.channels = ch;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=%d", ch);
|
|
XP_SYS_NG(EINVAL, r);
|
|
}
|
|
if ((hwinfo.mode & AUMODE_RECORD)) {
|
|
DPRINTF(" > hwinfo.record.channels = %d\n",
|
|
hwinfo.record.channels);
|
|
for (ch = 3; ch <= hwinfo.record.channels; ch++) {
|
|
AUDIO_INITINFO(&ai);
|
|
ai.record.channels = ch;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=%d", ch);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(ch, ai.record.channels);
|
|
}
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
ai.record.channels = ch;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=%d", ch);
|
|
XP_SYS_NG(EINVAL, r);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Check whether the sample rate can be set.
|
|
*/
|
|
DEF(AUDIO_SETINFO_sample_rate)
|
|
{
|
|
struct audio_info ai;
|
|
int mode;
|
|
int r;
|
|
int fd;
|
|
int i;
|
|
struct {
|
|
int freq;
|
|
bool expected;
|
|
} table[] = {
|
|
{ 999, false },
|
|
{ 1000, true }, /* lower limit */
|
|
{ 48000, true },
|
|
{ 192000, true }, /* upper limit */
|
|
{ 192001, false },
|
|
};
|
|
|
|
TEST("AUDIO_SETINFO_sample_rate");
|
|
if (netbsd < 8) {
|
|
/*
|
|
* On NetBSD7, the result depends the hardware and there is
|
|
* no way to know it.
|
|
*/
|
|
XP_SKIP("The test doesn't make sense on NetBSD7");
|
|
return;
|
|
}
|
|
|
|
mode = openable_mode();
|
|
fd = OPEN(devaudio, mode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
for (i = 0; i < (int)__arraycount(table); i++) {
|
|
int freq = table[i].freq;
|
|
bool expected = table[i].expected;
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
if (mode != O_RDONLY)
|
|
ai.play.sample_rate = freq;
|
|
if (mode != O_WRONLY)
|
|
ai.record.sample_rate = freq;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "sample_rate=%d", freq);
|
|
if (expected) {
|
|
/* Expects to succeed */
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (mode != O_RDONLY)
|
|
XP_EQ(freq, ai.play.sample_rate);
|
|
if (mode != O_WRONLY)
|
|
XP_EQ(freq, ai.record.sample_rate);
|
|
} else {
|
|
/* Expects to fail */
|
|
XP_SYS_NG(EINVAL, r);
|
|
}
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* SETINFO(sample_rate = 0) should fail correctly.
|
|
*/
|
|
DEF(AUDIO_SETINFO_sample_rate_0)
|
|
{
|
|
struct audio_info ai;
|
|
int mode;
|
|
int r;
|
|
int fd;
|
|
|
|
TEST("AUDIO_SETINFO_sample_rate_0");
|
|
if (netbsd < 9) {
|
|
/*
|
|
* On NetBSD7,8 this will block system call and you will not
|
|
* even be able to shutdown...
|
|
*/
|
|
XP_SKIP("This will cause an infinite loop in the kernel");
|
|
return;
|
|
}
|
|
|
|
mode = openable_mode();
|
|
fd = OPEN(devaudio, mode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.sample_rate = 0;
|
|
ai.record.sample_rate = 0;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "sample_rate=0");
|
|
/* Expects to fail */
|
|
XP_SYS_NG(EINVAL, r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Check whether the pause/unpause works.
|
|
*/
|
|
void
|
|
test_AUDIO_SETINFO_pause(int openmode, int aimode, int param)
|
|
{
|
|
struct audio_info ai;
|
|
int r;
|
|
int fd;
|
|
|
|
/*
|
|
* aimode is bool value that indicates whether to change ai.mode.
|
|
* param is bool value that indicates whether to change encoding
|
|
* parameters of ai.{play,record}.*.
|
|
*/
|
|
|
|
TEST("AUDIO_SETINFO_pause_%s_%d_%d",
|
|
openmode_str[openmode] + 2, aimode, param);
|
|
if (mode2aumode(openmode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
/* On half-duplex, O_RDWR is the same as O_WRONLY, so skip it */
|
|
if (!hw_fulldup() && openmode == O_RDWR) {
|
|
XP_SKIP("This is the same with O_WRONLY on half-duplex");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Set pause */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
ai.record.pause = 1;
|
|
if (aimode)
|
|
ai.mode = mode2aumode(openmode) & ~AUMODE_PLAY_ALL;
|
|
if (param) {
|
|
ai.play.sample_rate = 11025;
|
|
ai.record.sample_rate = 11025;
|
|
}
|
|
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
int expmode = (aimode)
|
|
? (mode2aumode(openmode) & ~AUMODE_PLAY_ALL)
|
|
: mode2aumode(openmode);
|
|
XP_EQ(expmode, ai.mode);
|
|
XP_EQ(1, ai.play.pause);
|
|
XP_EQ(param ? 11025 : 8000, ai.play.sample_rate);
|
|
XP_EQ(1, ai.record.pause);
|
|
XP_EQ(param ? 11025 : 8000, ai.record.sample_rate);
|
|
|
|
/* Set unpause (?) */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 0;
|
|
ai.record.pause = 0;
|
|
if (aimode)
|
|
ai.mode = mode2aumode(openmode);
|
|
if (param) {
|
|
ai.play.sample_rate = 16000;
|
|
ai.record.sample_rate = 16000;
|
|
}
|
|
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(mode2aumode(openmode), ai.mode);
|
|
XP_EQ(0, ai.play.pause);
|
|
XP_EQ(0, ai.record.pause);
|
|
if (openmode != O_RDONLY)
|
|
XP_EQ(param ? 16000 : 8000, ai.play.sample_rate);
|
|
if (openmode != O_WRONLY)
|
|
XP_EQ(param ? 16000 : 8000, ai.record.sample_rate);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(AUDIO_SETINFO_pause_RDONLY_0) { test_AUDIO_SETINFO_pause(O_RDONLY, 0, 0); }
|
|
DEF(AUDIO_SETINFO_pause_RDONLY_1) { test_AUDIO_SETINFO_pause(O_RDONLY, 0, 1); }
|
|
/* On RDONLY, ai.mode is not changeable
|
|
* AUDIO_SETINFO_pause_RDONLY_2) { test_AUDIO_SETINFO_pause(O_RDONLY, 1, 0); }
|
|
* AUDIO_SETINFO_pause_RDONLY_3) { test_AUDIO_SETINFO_pause(O_RDONLY, 1, 1); }
|
|
*/
|
|
DEF(AUDIO_SETINFO_pause_WRONLY_0) { test_AUDIO_SETINFO_pause(O_WRONLY, 0, 0); }
|
|
DEF(AUDIO_SETINFO_pause_WRONLY_1) { test_AUDIO_SETINFO_pause(O_WRONLY, 0, 1); }
|
|
DEF(AUDIO_SETINFO_pause_WRONLY_2) { test_AUDIO_SETINFO_pause(O_WRONLY, 1, 0); }
|
|
DEF(AUDIO_SETINFO_pause_WRONLY_3) { test_AUDIO_SETINFO_pause(O_WRONLY, 1, 1); }
|
|
DEF(AUDIO_SETINFO_pause_RDWR_0) { test_AUDIO_SETINFO_pause(O_RDWR, 0, 0); }
|
|
DEF(AUDIO_SETINFO_pause_RDWR_1) { test_AUDIO_SETINFO_pause(O_RDWR, 0, 1); }
|
|
DEF(AUDIO_SETINFO_pause_RDWR_2) { test_AUDIO_SETINFO_pause(O_RDWR, 1, 0); }
|
|
DEF(AUDIO_SETINFO_pause_RDWR_3) { test_AUDIO_SETINFO_pause(O_RDWR, 1, 1); }
|
|
|
|
/*
|
|
* Check whether gain can be obtained/set.
|
|
* And the gain should work with rich mixer.
|
|
* PR kern/52781
|
|
*/
|
|
DEF(AUDIO_SETINFO_gain)
|
|
{
|
|
struct audio_info ai;
|
|
mixer_ctrl_t m;
|
|
int index;
|
|
int master;
|
|
int master_backup;
|
|
int gain;
|
|
int fd;
|
|
int mixerfd;
|
|
int r;
|
|
|
|
TEST("AUDIO_SETINFO_gain");
|
|
|
|
/* Open /dev/mixer */
|
|
mixerfd = OPEN(devmixer, O_RDWR);
|
|
REQUIRED_SYS_OK(mixerfd);
|
|
index = mixer_get_outputs_master(mixerfd);
|
|
if (index == -1) {
|
|
XP_SKIP("Hardware has no outputs.master");
|
|
CLOSE(mixerfd);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Get current outputs.master.
|
|
* auich(4) requires class type (m.type) and number of channels
|
|
* (un.value.num_channels) in addition to the index (m.dev)...
|
|
* What is the index...?
|
|
*/
|
|
memset(&m, 0, sizeof(m));
|
|
m.dev = index;
|
|
m.type = AUDIO_MIXER_VALUE;
|
|
m.un.value.num_channels = 1; /* dummy */
|
|
r = IOCTL(mixerfd, AUDIO_MIXER_READ, &m, "m.dev=%d", m.dev);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
master = m.un.value.level[0];
|
|
DPRINTF(" > outputs.master = %d\n", master);
|
|
master_backup = master;
|
|
|
|
/* Open /dev/audio */
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Check ai.play.gain */
|
|
r = IOCTL(fd, AUDIO_GETINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(master, ai.play.gain);
|
|
|
|
/* Change it some different value */
|
|
AUDIO_INITINFO(&ai);
|
|
if (master == 0)
|
|
gain = 255;
|
|
else
|
|
gain = 0;
|
|
ai.play.gain = gain;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "play.gain=%d", ai.play.gain);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Check gain has changed */
|
|
r = IOCTL(fd, AUDIO_GETINFO, &ai, "play.gain");
|
|
XP_SYS_EQ(0, r);
|
|
XP_NE(master, ai.play.gain);
|
|
|
|
/* Check whether outputs.master work with gain */
|
|
r = IOCTL(mixerfd, AUDIO_MIXER_READ, &m, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(ai.play.gain, m.un.value.level[0]);
|
|
|
|
/* Restore outputs.master */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.gain = master_backup;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "play.gain=%d", ai.play.gain);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
r = CLOSE(mixerfd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Look if there are any (non-zero) gain values that can be changed.
|
|
* If any gain can be set, it is set to gain[0].
|
|
* If another gain can be set, it is set to gain[1], otherwise gain[1] = -1.
|
|
* This is for AUDIO_SETINFO_gain_balance.
|
|
*/
|
|
static void
|
|
get_changeable_gain(int fd, int *gain, const char *dir, int offset)
|
|
{
|
|
struct audio_info ai;
|
|
int *ai_gain;
|
|
int hi;
|
|
int lo;
|
|
int r;
|
|
|
|
/* A hack to handle ai.{play,record}.gain in the same code.. */
|
|
ai_gain = (int *)(((char *)&ai) + offset);
|
|
|
|
/* Try to set the maximum gain */
|
|
AUDIO_INITINFO(&ai);
|
|
*ai_gain = AUDIO_MAX_GAIN;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "%s.gain=%d", dir, *ai_gain);
|
|
XP_SYS_EQ(0, r);
|
|
/* Get again. The value you set is not always used as is. */
|
|
AUDIO_INITINFO(&ai);
|
|
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
|
|
XP_SYS_EQ(0, r);
|
|
hi = *ai_gain;
|
|
|
|
/* Look for next configurable value. */
|
|
for (lo = hi - 1; lo >= 0; lo--) {
|
|
AUDIO_INITINFO(&ai);
|
|
*ai_gain = lo;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "%s.gain=%d", dir, *ai_gain);
|
|
XP_SYS_EQ(0, r);
|
|
/* Get again */
|
|
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
|
|
XP_SYS_EQ(0, r);
|
|
if (*ai_gain != hi) {
|
|
lo = *ai_gain;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Now gain is lo(=gain[0]). */
|
|
|
|
/*
|
|
* hi lo
|
|
* --- ---
|
|
* <0 <0 : not available.
|
|
* >=0 <0 : available but not changeable.
|
|
* >=0 >=0 (hi!=lo) : available and changeable.
|
|
*/
|
|
if (hi < 0) {
|
|
gain[0] = -1;
|
|
gain[1] = -1;
|
|
DPRINTF(" > %s.gain cannot be set\n", dir);
|
|
} else if (lo < 0) {
|
|
gain[0] = hi;
|
|
gain[1] = -1;
|
|
DPRINTF(" > %s.gain can only be set %d\n", dir, gain[0]);
|
|
} else {
|
|
gain[0] = lo;
|
|
gain[1] = hi;
|
|
DPRINTF(" > %s.gain can be set %d, %d\n",
|
|
dir, gain[0], gain[1]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Look if there are any balance values that can be changed.
|
|
* If any balance value can be set, it is set to balance[0].
|
|
* If another balance value can be set, it is set to balance[1],
|
|
* otherwise balance[1] = -1.
|
|
* This is for AUDIO_SETINFO_gain_balance.
|
|
*/
|
|
static void
|
|
get_changeable_balance(int fd, int *balance, const char *dir, int offset)
|
|
{
|
|
struct audio_info ai;
|
|
u_char *ai_balance;
|
|
u_char left;
|
|
u_char right;
|
|
int r;
|
|
|
|
/* A hack to handle ai.{play,record}.balance in the same code.. */
|
|
ai_balance = ((u_char *)&ai) + offset;
|
|
|
|
/* Look for the right side configurable value. */
|
|
AUDIO_INITINFO(&ai);
|
|
*ai_balance = AUDIO_RIGHT_BALANCE;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "%s.balance=%d", dir, *ai_balance);
|
|
XP_SYS_EQ(0, r);
|
|
/* Get again. The value you set is not always used as is. */
|
|
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
|
|
XP_SYS_EQ(0, r);
|
|
right = *ai_balance;
|
|
|
|
/* Look for the left side configurable value. */
|
|
AUDIO_INITINFO(&ai);
|
|
*ai_balance = AUDIO_LEFT_BALANCE;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "%s.balance=%d", dir, *ai_balance);
|
|
XP_SYS_EQ(0, r);
|
|
/* Get again */
|
|
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
|
|
XP_SYS_EQ(0, r);
|
|
left = *ai_balance;
|
|
|
|
/* Now balance is the left(=balance[0]). */
|
|
|
|
if (left == right) {
|
|
/* The driver has no balance feature. */
|
|
balance[0] = left;
|
|
balance[1] = -1;
|
|
DPRINTF(" > %s.balance can only be set %d\n",
|
|
dir, balance[0]);
|
|
} else {
|
|
balance[0] = left;
|
|
balance[1] = right;
|
|
DPRINTF(" > %s.balance can be set %d, %d\n",
|
|
dir, balance[0], balance[1]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check whether gain and balance can be set at the same time.
|
|
* PR kern/56308
|
|
*/
|
|
DEF(AUDIO_SETINFO_gain_balance)
|
|
{
|
|
struct audio_info oai;
|
|
struct audio_info ai;
|
|
int i;
|
|
int mode;
|
|
int fd;
|
|
int r;
|
|
int pgain[2];
|
|
int pbalance[2];
|
|
int rgain[2];
|
|
int rbalance[2];
|
|
bool ptest;
|
|
bool rtest;
|
|
|
|
TEST("AUDIO_SETINFO_gain_balance");
|
|
|
|
mode = openable_mode();
|
|
fd = OPEN(devaudio, mode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Backup current gain and balance */
|
|
r = IOCTL(fd, AUDIO_GETINFO, &oai, "&oai");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
if (debug) {
|
|
printf(" > old play.gain = %d\n", oai.play.gain);
|
|
printf(" > old play.balance = %d\n", oai.play.balance);
|
|
printf(" > old record.gain = %d\n", oai.record.gain);
|
|
printf(" > old record.balance = %d\n", oai.record.balance);
|
|
}
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
pgain[i] = -1;
|
|
pbalance[i] = -1;
|
|
rgain[i] = -1;
|
|
rbalance[i] = -1;
|
|
}
|
|
|
|
/*
|
|
* First, check each one separately can be changed.
|
|
*
|
|
* The simplest two different gain values are zero and non-zero.
|
|
* But some device drivers seem to process balance differently
|
|
* when the gain is high enough and when the gain is zero or near.
|
|
* So I needed to select two different "non-zero (and high if
|
|
* possible)" gains.
|
|
*/
|
|
if (hw_canplay()) {
|
|
get_changeable_gain(fd, pgain, "play",
|
|
offsetof(struct audio_info, play.gain));
|
|
get_changeable_balance(fd, pbalance, "play",
|
|
offsetof(struct audio_info, play.balance));
|
|
}
|
|
if (hw_canrec()) {
|
|
get_changeable_gain(fd, rgain, "record",
|
|
offsetof(struct audio_info, record.gain));
|
|
get_changeable_balance(fd, rbalance, "record",
|
|
offsetof(struct audio_info, record.balance));
|
|
}
|
|
|
|
/*
|
|
* [0] [1]
|
|
* --- ---
|
|
* -1 * : not available.
|
|
* >=0 -1 : available but not changeable.
|
|
* >=0 >=0 : available and changeable. It can be tested.
|
|
*/
|
|
ptest = (pgain[0] >= 0 && pgain[1] >= 0 &&
|
|
pbalance[0] >= 0 && pbalance[1] >= 0);
|
|
rtest = (rgain[0] >= 0 && rgain[1] >= 0 &&
|
|
rbalance[0] >= 0 && rbalance[1] >= 0);
|
|
|
|
if (ptest == false && rtest == false) {
|
|
XP_SKIP(
|
|
"The test requires changeable gain and changeable balance");
|
|
|
|
/* Restore as possible */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.gain = oai.play.gain;
|
|
ai.play.balance = oai.play.balance;
|
|
ai.record.gain = oai.record.gain;
|
|
ai.record.balance = oai.record.balance;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "restore all");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If both play.gain and play.balance are changeable,
|
|
* it should be able to set both at the same time.
|
|
*/
|
|
if (ptest) {
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.gain = pgain[1];
|
|
ai.play.balance = pbalance[1];
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "play.gain=%d/balance=%d",
|
|
ai.play.gain, ai.play.balance);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
DPRINTF(" > setting play.gain=%d/balance=%d: "
|
|
"result gain=%d/balance=%d\n",
|
|
pgain[1], pbalance[1], ai.play.gain, ai.play.balance);
|
|
XP_EQ(ai.play.gain, pgain[1]);
|
|
XP_EQ(ai.play.balance, pbalance[1]);
|
|
}
|
|
/*
|
|
* If both record.gain and record.balance are changeable,
|
|
* it should be able to set both at the same time.
|
|
*/
|
|
if (rtest) {
|
|
AUDIO_INITINFO(&ai);
|
|
ai.record.gain = rgain[1];
|
|
ai.record.balance = rbalance[1];
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "record.gain=%d/balance=%d",
|
|
ai.record.gain, ai.record.balance);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
DPRINTF(" > setting record.gain=%d/balance=%d: "
|
|
"result gain=%d/balance=%d\n",
|
|
rgain[1], rbalance[1], ai.record.gain, ai.record.balance);
|
|
XP_EQ(ai.record.gain, rgain[1]);
|
|
XP_EQ(ai.record.balance, rbalance[1]);
|
|
}
|
|
|
|
/*
|
|
* Restore all values as possible at the same time.
|
|
* This restore is also a test.
|
|
*/
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.gain = oai.play.gain;
|
|
ai.play.balance = oai.play.balance;
|
|
ai.record.gain = oai.record.gain;
|
|
ai.record.balance = oai.record.balance;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "restore all");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
r = IOCTL(fd, AUDIO_GETINFO, &ai, "&ai");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(oai.play.gain, ai.play.gain);
|
|
XP_EQ(oai.play.balance, ai.play.balance);
|
|
XP_EQ(oai.record.gain, ai.record.gain);
|
|
XP_EQ(oai.record.balance, ai.record.balance);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Changing track formats after mmap should fail.
|
|
*/
|
|
DEF(AUDIO_SETINFO_mmap_enc)
|
|
{
|
|
struct audio_info ai;
|
|
void *ptr;
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("AUDIO_SETINFO_mmap");
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump) {
|
|
XP_SKIP("rump doesn't support mmap");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
ptr = MMAP(NULL, 1, PROT_WRITE, MAP_FILE, fd, 0);
|
|
XP_SYS_PTR(0, ptr);
|
|
|
|
/*
|
|
* SETINFO after mmap should fail.
|
|
* NetBSD9 changes errno.
|
|
*/
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.channels = 2;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "channels=2");
|
|
if (netbsd < 9) {
|
|
XP_SYS_NG(EINVAL, r);
|
|
} else {
|
|
XP_SYS_NG(EIO, r);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
reset_after_mmap();
|
|
}
|
|
|
|
/*
|
|
* Even after mmap, changing pause should succeed.
|
|
*/
|
|
DEF(AUDIO_SETINFO_mmap_pause)
|
|
{
|
|
struct audio_info ai;
|
|
void *ptr;
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("AUDIO_SETINFO_mmap");
|
|
|
|
#if !defined(NO_RUMP)
|
|
if (use_rump) {
|
|
XP_SKIP("rump doesn't support mmap");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
fd = OPEN(devaudio, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
ptr = MMAP(NULL, 1, PROT_WRITE, MAP_FILE, fd, 0);
|
|
XP_SYS_PTR(0, ptr);
|
|
|
|
/* SETINFO after mmap should fail */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 1;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "set pause");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
AUDIO_INITINFO(&ai);
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "get pause");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
XP_EQ(1, ai.play.pause);
|
|
|
|
/*
|
|
* Unpause before close. Unless, subsequent audioplay(1) which use
|
|
* /dev/sound by default will pause...
|
|
*/
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.pause = 0;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "reset pause");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
reset_after_mmap();
|
|
}
|
|
|
|
#define NENC (AUDIO_ENCODING_AC3 + 1)
|
|
#define NPREC (5)
|
|
/*
|
|
* Make table of encoding+precision supported by this device.
|
|
* Return last used index .
|
|
* This function is called from test_AUDIO_GETENC_*()
|
|
*/
|
|
int
|
|
getenc_make_table(int fd, int expected[][5])
|
|
{
|
|
audio_encoding_t ae;
|
|
int idx;
|
|
int p;
|
|
int r;
|
|
|
|
/*
|
|
* expected[][] is two dimensional table.
|
|
* encoding \ precision| 4 8 16 24 32
|
|
* --------------------+-----------------
|
|
* AUDIO_ENCODING_NONE |
|
|
* AUDIO_ENCODING_ULAW |
|
|
* :
|
|
*
|
|
* Each cell has expected behavior.
|
|
* 0: the hardware doesn't support this encoding/precision.
|
|
* 1: the hardware supports this encoding/precision.
|
|
* 2: the hardware doesn't support this encoding/precision but
|
|
* audio layer will respond as supported for compatibility.
|
|
*/
|
|
for (idx = 0; ; idx++) {
|
|
memset(&ae, 0, sizeof(ae));
|
|
ae.index = idx;
|
|
r = IOCTL(fd, AUDIO_GETENC, &ae, "index=%d", idx);
|
|
if (r != 0) {
|
|
XP_SYS_NG(EINVAL, r);
|
|
break;
|
|
}
|
|
|
|
XP_EQ(idx, ae.index);
|
|
if (0 <= ae.encoding && ae.encoding <= AUDIO_ENCODING_AC3) {
|
|
XP_EQ_STR(encoding_names[ae.encoding], ae.name);
|
|
} else {
|
|
XP_FAIL("ae.encoding %d", ae.encoding);
|
|
}
|
|
|
|
if (ae.precision != 4 &&
|
|
ae.precision != 8 &&
|
|
ae.precision != 16 &&
|
|
ae.precision != 24 &&
|
|
ae.precision != 32)
|
|
{
|
|
XP_FAIL("ae.precision %d", ae.precision);
|
|
}
|
|
/* Other bits should not be set */
|
|
XP_EQ(0, (ae.flags & ~AUDIO_ENCODINGFLAG_EMULATED));
|
|
|
|
expected[ae.encoding][ae.precision / 8] = 1;
|
|
DPRINTF(" > encoding=%s precision=%d\n",
|
|
encoding_names[ae.encoding], ae.precision);
|
|
}
|
|
|
|
/*
|
|
* Backward compatibility bandaid.
|
|
*
|
|
* - Some encoding/precision pairs are obviously inconsistent
|
|
* (e.g., encoding=AUDIO_ENCODING_PCM8, precision=16) but
|
|
* it's due to historical reasons.
|
|
* - It's incomplete for NetBSD7 and NetBSD8. I don't really
|
|
* understand their rule... This is just memo, not specification.
|
|
*/
|
|
#define SET(x) do { \
|
|
if ((x) == 0) \
|
|
x = 2; \
|
|
} while (0)
|
|
#define p4 (0)
|
|
#define p8 (1)
|
|
#define p16 (2)
|
|
#define p24 (3)
|
|
#define p32 (4)
|
|
|
|
if (expected[AUDIO_ENCODING_SLINEAR][p8]) {
|
|
SET(expected[AUDIO_ENCODING_SLINEAR_LE][p8]);
|
|
SET(expected[AUDIO_ENCODING_SLINEAR_BE][p8]);
|
|
}
|
|
if (expected[AUDIO_ENCODING_ULINEAR][p8]) {
|
|
SET(expected[AUDIO_ENCODING_ULINEAR_LE][p8]);
|
|
SET(expected[AUDIO_ENCODING_ULINEAR_BE][p8]);
|
|
SET(expected[AUDIO_ENCODING_PCM8][p8]);
|
|
SET(expected[AUDIO_ENCODING_PCM16][p8]);
|
|
}
|
|
for (p = p16; p <= p32; p++) {
|
|
#if !defined(AUDIO_SUPPORT_LINEAR24)
|
|
if (p == p24)
|
|
continue;
|
|
#endif
|
|
if (expected[AUDIO_ENCODING_SLINEAR_NE][p]) {
|
|
SET(expected[AUDIO_ENCODING_SLINEAR][p]);
|
|
SET(expected[AUDIO_ENCODING_PCM16][p]);
|
|
}
|
|
if (expected[AUDIO_ENCODING_ULINEAR_NE][p]) {
|
|
SET(expected[AUDIO_ENCODING_ULINEAR][p]);
|
|
}
|
|
}
|
|
|
|
if (netbsd < 9) {
|
|
if (expected[AUDIO_ENCODING_SLINEAR_LE][p16] ||
|
|
expected[AUDIO_ENCODING_SLINEAR_BE][p16] ||
|
|
expected[AUDIO_ENCODING_ULINEAR_LE][p16] ||
|
|
expected[AUDIO_ENCODING_ULINEAR_BE][p16])
|
|
{
|
|
SET(expected[AUDIO_ENCODING_PCM8][p8]);
|
|
SET(expected[AUDIO_ENCODING_PCM16][p8]);
|
|
SET(expected[AUDIO_ENCODING_SLINEAR_LE][p8]);
|
|
SET(expected[AUDIO_ENCODING_SLINEAR_BE][p8]);
|
|
SET(expected[AUDIO_ENCODING_ULINEAR_LE][p8]);
|
|
SET(expected[AUDIO_ENCODING_ULINEAR_BE][p8]);
|
|
SET(expected[AUDIO_ENCODING_SLINEAR][p8]);
|
|
SET(expected[AUDIO_ENCODING_ULINEAR][p8]);
|
|
}
|
|
}
|
|
|
|
/* Return last used index */
|
|
return idx;
|
|
#undef SET
|
|
#undef p4
|
|
#undef p8
|
|
#undef p16
|
|
#undef p24
|
|
#undef p32
|
|
}
|
|
|
|
/*
|
|
* This function is called from test_AUDIO_GETENC below.
|
|
*/
|
|
void
|
|
xp_getenc(int expected[][5], int enc, int j, int r, struct audio_prinfo *pr)
|
|
{
|
|
int prec = (j == 0) ? 4 : j * 8;
|
|
|
|
if (expected[enc][j]) {
|
|
/* expect to succeed */
|
|
XP_SYS_EQ(0, r);
|
|
|
|
XP_EQ(enc, pr->encoding);
|
|
XP_EQ(prec, pr->precision);
|
|
} else {
|
|
/* expect to fail */
|
|
XP_SYS_NG(EINVAL, r);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This function is called from test_AUDIO_GETENC below.
|
|
*/
|
|
void
|
|
getenc_check_encodings(int openmode, int expected[][5])
|
|
{
|
|
struct audio_info ai;
|
|
int fd;
|
|
int i, j;
|
|
int r;
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
for (i = 0; i < NENC; i++) {
|
|
for (j = 0; j < NPREC; j++) {
|
|
/* precisions are 4 and 8, 16, 24, 32 */
|
|
int prec = (j == 0) ? 4 : j * 8;
|
|
|
|
/*
|
|
* AUDIO_GETENC has no way to know range of
|
|
* supported channels and sample_rate.
|
|
*/
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.encoding = i;
|
|
ai.play.precision = prec;
|
|
ai.record.encoding = i;
|
|
ai.record.precision = prec;
|
|
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "%s:%d",
|
|
encoding_names[i], prec);
|
|
if (mode2play(openmode))
|
|
xp_getenc(expected, i, j, r, &ai.play);
|
|
if (mode2rec(openmode))
|
|
xp_getenc(expected, i, j, r, &ai.record);
|
|
}
|
|
}
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* Check whether encoding+precision obtained by AUDIO_GETENC can be set.
|
|
*/
|
|
DEF(AUDIO_GETENC_range)
|
|
{
|
|
audio_encoding_t ae;
|
|
int fd;
|
|
int r;
|
|
int expected[NENC][NPREC];
|
|
int i, j;
|
|
|
|
TEST("AUDIO_GETENC_range");
|
|
|
|
fd = OPEN(devaudio, openable_mode());
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
memset(&expected, 0, sizeof(expected));
|
|
i = getenc_make_table(fd, expected);
|
|
|
|
/* When error has occurred, the next index should also occur error */
|
|
ae.index = i + 1;
|
|
r = IOCTL(fd, AUDIO_GETENC, &ae, "index=%d", ae.index);
|
|
XP_SYS_NG(EINVAL, r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* For debug */
|
|
if (debug) {
|
|
for (i = 0; i < NENC; i++) {
|
|
printf("expected[%2d] %15s", i, encoding_names[i]);
|
|
for (j = 0; j < NPREC; j++) {
|
|
printf(" %d", expected[i][j]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
/* Whether obtained encodings can be actually set */
|
|
if (hw_fulldup()) {
|
|
/* Test both R/W at once using single descriptor */
|
|
getenc_check_encodings(O_RDWR, expected);
|
|
} else {
|
|
/* Test playback and recording if available */
|
|
if (hw_canplay()) {
|
|
getenc_check_encodings(O_WRONLY, expected);
|
|
}
|
|
if (hw_canplay() && hw_canrec()) {
|
|
xxx_close_wait();
|
|
}
|
|
if (hw_canrec()) {
|
|
getenc_check_encodings(O_RDONLY, expected);
|
|
}
|
|
}
|
|
}
|
|
#undef NENC
|
|
#undef NPREC
|
|
|
|
/*
|
|
* Check AUDIO_GETENC out of range.
|
|
*/
|
|
DEF(AUDIO_GETENC_error)
|
|
{
|
|
audio_encoding_t e;
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("AUDIO_GETENC_error");
|
|
|
|
fd = OPEN(devaudio, openable_mode());
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
memset(&e, 0, sizeof(e));
|
|
e.index = -1;
|
|
r = IOCTL(fd, AUDIO_GETENC, &e, "index=-1");
|
|
/* NetBSD7 may not fail depending on hardware driver */
|
|
XP_SYS_NG(EINVAL, r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* AUDIO_[PR]ERROR should be zero on the initial state even on non-existent
|
|
* track.
|
|
*/
|
|
void
|
|
test_AUDIO_ERROR(int openmode)
|
|
{
|
|
int fd;
|
|
int r;
|
|
int errors;
|
|
|
|
TEST("AUDIO_ERROR_%s", openmode_str[openmode] + 2);
|
|
if (mode2aumode(openmode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Check PERROR */
|
|
errors = 0xdeadbeef;
|
|
r = IOCTL(fd, AUDIO_PERROR, &errors, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, errors);
|
|
|
|
/* Check RERROR */
|
|
errors = 0xdeadbeef;
|
|
r = IOCTL(fd, AUDIO_RERROR, &errors, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, errors);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(AUDIO_ERROR_RDONLY) { test_AUDIO_ERROR(O_RDONLY); }
|
|
DEF(AUDIO_ERROR_WRONLY) { test_AUDIO_ERROR(O_WRONLY); }
|
|
DEF(AUDIO_ERROR_RDWR) { test_AUDIO_ERROR(O_RDWR); }
|
|
|
|
/*
|
|
* AUDIO_GETIOFFS at least one block.
|
|
*/
|
|
void
|
|
test_AUDIO_GETIOFFS_one(int openmode)
|
|
{
|
|
struct audio_info ai;
|
|
audio_offset_t o;
|
|
int fd;
|
|
int r;
|
|
u_int blocksize;
|
|
u_int blk_ms;
|
|
|
|
TEST("AUDIO_GETIOFFS_one_%s", openmode_str[openmode] + 2);
|
|
if (mode2aumode(openmode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
#if 0
|
|
/*
|
|
* On NetBSD7/8, native encodings and emulated encodings behave
|
|
* differently. But it's hard to identify which encoding is native.
|
|
* If you try other encodings, edit these parameters manually.
|
|
*/
|
|
AUDIO_INITINFO(&ai);
|
|
ai.record.encoding = AUDIO_ENCODING_SLINEAR_NE;
|
|
ai.record.precision = 16;
|
|
ai.record.channels = 2;
|
|
ai.record.sample_rate = 48000;
|
|
/* ai.blocksize is shared by play and record, so set both the same. */
|
|
*ai.play = *ai.record;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
#endif
|
|
|
|
/* Get blocksize to calc blk_ms. */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
blocksize = ai.blocksize;
|
|
if (netbsd < 9) {
|
|
blk_ms = 0;
|
|
} else {
|
|
/* On NetBSD9, blocktime can always be calculated. */
|
|
blk_ms = blocksize * 1000 /
|
|
(ai.play.precision / 8 * ai.play.channels *
|
|
ai.play.sample_rate);
|
|
}
|
|
if (blk_ms == 0)
|
|
blk_ms = 50;
|
|
DPRINTF(" > blocksize=%u, estimated blk_ms=%u\n", blocksize, blk_ms);
|
|
|
|
/*
|
|
* Even when just opened, recording counters will start.
|
|
* Wait a moment, about one block time.
|
|
*/
|
|
usleep(blk_ms * 1000);
|
|
|
|
r = IOCTL(fd, AUDIO_GETIOFFS, &o, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (mode2rec(openmode)) {
|
|
/*
|
|
* It's difficult to know exact values.
|
|
* But at least these should not be zero.
|
|
*/
|
|
DPRINTF(" > %d: samples=%u deltablks=%u offset=%u\n",
|
|
__LINE__, o.samples, o.deltablks, o.offset);
|
|
XP_NE(0, o.samples);
|
|
XP_NE(0, o.deltablks);
|
|
XP_NE(0, o.offset);
|
|
} else {
|
|
/* All are zero on playback track. */
|
|
XP_EQ(0, o.samples);
|
|
XP_EQ(0, o.deltablks);
|
|
XP_EQ(0, o.offset);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(AUDIO_GETIOFFS_one_RDONLY) { test_AUDIO_GETIOFFS_one(O_RDONLY); }
|
|
DEF(AUDIO_GETIOFFS_one_WRONLY) { test_AUDIO_GETIOFFS_one(O_WRONLY); }
|
|
DEF(AUDIO_GETIOFFS_one_RDWR) { test_AUDIO_GETIOFFS_one(O_RDWR); }
|
|
|
|
/*
|
|
* AUDIO_GETOOFFS for one block.
|
|
*/
|
|
void
|
|
test_AUDIO_GETOOFFS_one(int openmode)
|
|
{
|
|
struct audio_info ai;
|
|
audio_offset_t o;
|
|
char *buf;
|
|
int fd;
|
|
int r;
|
|
u_int blocksize;
|
|
u_int initial_offset;
|
|
u_int blk_ms;
|
|
|
|
TEST("AUDIO_GETOOFFS_one_%s", openmode_str[openmode] + 2);
|
|
if (mode2aumode(openmode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
#if 0
|
|
/*
|
|
* On NetBSD7/8, native encodings and emulated encodings behave
|
|
* differently. But it's hard to identify which encoding is native.
|
|
* If you try other encodings, edit these parameters manually.
|
|
*/
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.encoding = AUDIO_ENCODING_SLINEAR_NE;
|
|
ai.play.precision = 16;
|
|
ai.play.channels = 2;
|
|
ai.play.sample_rate = 48000;
|
|
/* ai.blocksize is shared by play and record, so set both the same. */
|
|
*ai.record = *ai.play;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "slinear16/2ch/48000");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
#endif
|
|
|
|
/* Get blocksize to calc blk_ms. */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
blocksize = ai.blocksize;
|
|
if (netbsd < 9) {
|
|
blk_ms = 0;
|
|
} else {
|
|
/* On NetBSD9, blocktime can always be calculated. */
|
|
blk_ms = blocksize * 1000 /
|
|
(ai.play.precision / 8 * ai.play.channels *
|
|
ai.play.sample_rate);
|
|
}
|
|
if (blk_ms == 0)
|
|
blk_ms = 50;
|
|
DPRINTF(" > blocksize=%u, estimated blk_ms=%u\n", blocksize, blk_ms);
|
|
|
|
buf = (char *)malloc(blocksize);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, blocksize);
|
|
|
|
/*
|
|
* On NetBSD7, .offset starts from one block. What is the block??
|
|
* On NetBSD9, .offset starts from zero.
|
|
*/
|
|
if (netbsd < 9) {
|
|
initial_offset = blocksize;
|
|
} else {
|
|
initial_offset = 0;
|
|
}
|
|
|
|
/* When just opened, all are zero. */
|
|
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, o.samples);
|
|
XP_EQ(0, o.deltablks);
|
|
XP_EQ(initial_offset, o.offset);
|
|
|
|
/* Even if wait (at least) one block, these remain unchanged. */
|
|
usleep(blk_ms * 1000);
|
|
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, o.samples);
|
|
XP_EQ(0, o.deltablks);
|
|
XP_EQ(initial_offset, o.offset);
|
|
|
|
/* Write one block. */
|
|
r = WRITE(fd, buf, blocksize);
|
|
if (mode2play(openmode)) {
|
|
XP_SYS_EQ(blocksize, r);
|
|
} else {
|
|
XP_SYS_NG(EBADF, r);
|
|
}
|
|
r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (mode2play(openmode)) {
|
|
/* All advance one block. */
|
|
XP_EQ(blocksize, o.samples);
|
|
XP_EQ(1, o.deltablks);
|
|
XP_EQ(initial_offset + blocksize, o.offset);
|
|
} else {
|
|
/*
|
|
* All are zero on non-play track.
|
|
* On NetBSD7, the rec track has play buffer, too.
|
|
*/
|
|
XP_EQ(0, o.samples);
|
|
XP_EQ(0, o.deltablks);
|
|
XP_EQ(initial_offset, o.offset);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
free(buf);
|
|
}
|
|
DEF(AUDIO_GETOOFFS_one_RDONLY) { test_AUDIO_GETOOFFS_one(O_RDONLY); }
|
|
DEF(AUDIO_GETOOFFS_one_WRONLY) { test_AUDIO_GETOOFFS_one(O_WRONLY); }
|
|
DEF(AUDIO_GETOOFFS_one_RDWR) { test_AUDIO_GETOOFFS_one(O_RDWR); }
|
|
|
|
/*
|
|
* AUDIO_GETOOFFS when wrap around buffer.
|
|
*/
|
|
void
|
|
test_AUDIO_GETOOFFS_wrap(int openmode)
|
|
{
|
|
struct audio_info ai;
|
|
audio_offset_t o;
|
|
char *buf;
|
|
int fd;
|
|
int r;
|
|
u_int blocksize;
|
|
u_int buffer_size;
|
|
u_int initial_offset;
|
|
u_int nblks;
|
|
|
|
TEST("AUDIO_GETOOFFS_wrap_%s", openmode_str[openmode] + 2);
|
|
if (mode2aumode(openmode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
#if 1
|
|
/* To save test time, use larger format if possible. */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.encoding = AUDIO_ENCODING_SLINEAR_NE;
|
|
ai.play.precision = 16;
|
|
ai.play.channels = 2;
|
|
ai.play.sample_rate = 48000;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "slinear16/2/48000");
|
|
if (r != 0)
|
|
#endif
|
|
{
|
|
/*
|
|
* If it cannot be set, use common format instead.
|
|
* May be happened on NetBSD7/8.
|
|
*/
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.encoding = AUDIO_ENCODING_ULAW;
|
|
ai.play.precision = 8;
|
|
ai.play.channels = 1;
|
|
ai.play.sample_rate = 8000;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "ulaw/1/8000");
|
|
}
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* Get buffer_size and blocksize. */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
buffer_size = ai.play.buffer_size;
|
|
blocksize = ai.blocksize;
|
|
nblks = buffer_size / blocksize;
|
|
DPRINTF(" > buffer_size=%u blocksize=%u nblks=%u\n",
|
|
buffer_size, blocksize, nblks);
|
|
|
|
buf = (char *)malloc(buffer_size);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, buffer_size);
|
|
|
|
/*
|
|
* On NetBSD7, .offset starts from one block. What is the block??
|
|
* On NetBSD9, .offset starts from zero.
|
|
*/
|
|
if (netbsd < 9) {
|
|
initial_offset = blocksize;
|
|
} else {
|
|
initial_offset = 0;
|
|
}
|
|
|
|
/* Write full buffer. */
|
|
r = WRITE(fd, buf, buffer_size);
|
|
if (mode2play(openmode)) {
|
|
XP_SYS_EQ(buffer_size, r);
|
|
|
|
/* Then, wait. */
|
|
r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
} else {
|
|
XP_SYS_NG(EBADF, r);
|
|
}
|
|
|
|
/*
|
|
* .deltablks is number of blocks since last checked.
|
|
* .offset is wrapped around to zero.
|
|
*/
|
|
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (mode2play(openmode)) {
|
|
/*
|
|
* On NetBSD7, samples may be blocksize * nblks or buffer_size
|
|
* depending on native/emulated encoding.
|
|
* On NetBSD9, samples is always equal to buffer_size.
|
|
*/
|
|
if (buffer_size != blocksize * nblks &&
|
|
o.samples == blocksize * nblks) {
|
|
DPRINTF(" > %d: samples(%u) == blocksize * nblks\n",
|
|
__LINE__, o.samples);
|
|
} else {
|
|
XP_EQ(buffer_size, o.samples);
|
|
}
|
|
XP_EQ(nblks, o.deltablks);
|
|
XP_EQ(initial_offset, o.offset);
|
|
} else {
|
|
/*
|
|
* On non-play track, it silently succeeds with zero.
|
|
* But on NetBSD7, RDONLY descriptor also has play buffer.
|
|
*/
|
|
XP_EQ(0, o.samples);
|
|
XP_EQ(0, o.deltablks);
|
|
XP_EQ(initial_offset, o.offset);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
free(buf);
|
|
}
|
|
DEF(AUDIO_GETOOFFS_wrap_RDONLY) { test_AUDIO_GETOOFFS_wrap(O_RDONLY); }
|
|
DEF(AUDIO_GETOOFFS_wrap_WRONLY) { test_AUDIO_GETOOFFS_wrap(O_WRONLY); }
|
|
DEF(AUDIO_GETOOFFS_wrap_RDWR) { test_AUDIO_GETOOFFS_wrap(O_RDWR); }
|
|
|
|
/*
|
|
* Check whether AUDIO_FLUSH clears AUDIO_GETOOFFS.
|
|
*/
|
|
void
|
|
test_AUDIO_GETOOFFS_flush(int openmode)
|
|
{
|
|
struct audio_info ai;
|
|
audio_offset_t o;
|
|
char *buf;
|
|
int fd;
|
|
int r;
|
|
u_int initial_offset;
|
|
u_int last_offset;
|
|
|
|
TEST("AUDIO_GETOOFFS_flush_%s", openmode_str[openmode] + 2);
|
|
if (mode2aumode(openmode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
#if 0
|
|
/* On NetBSD7/8, native encoding changes buffer behavior. */
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.encoding = AUDIO_ENCODING_SLINEAR_NE;
|
|
ai.play.precision = 16;
|
|
ai.play.channels = 2;
|
|
ai.play.sample_rate = 48000;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
#endif
|
|
|
|
/* Get blocksize. */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
buf = (char *)malloc(ai.blocksize);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, ai.blocksize);
|
|
|
|
/*
|
|
* On NetBSD7, .offset starts from one block. What is the block??
|
|
* On NetBSD9, .offset starts from zero.
|
|
*/
|
|
if (netbsd < 9) {
|
|
initial_offset = ai.blocksize;
|
|
} else {
|
|
initial_offset = 0;
|
|
}
|
|
|
|
/* Write one block. */
|
|
r = WRITE(fd, buf, ai.blocksize);
|
|
if (mode2play(openmode)) {
|
|
XP_SYS_EQ(ai.blocksize, r);
|
|
} else {
|
|
XP_SYS_NG(EBADF, r);
|
|
}
|
|
r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* Obtain once. */
|
|
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
|
|
XP_SYS_EQ(0, r);
|
|
if (mode2play(openmode)) {
|
|
XP_EQ(ai.blocksize, o.samples);
|
|
XP_EQ(1, o.deltablks);
|
|
XP_EQ(initial_offset + ai.blocksize, o.offset);
|
|
} else {
|
|
/*
|
|
* On non-play track, it silently succeeds with zero.
|
|
* But on NetBSD7, RDONLY descriptor also has play buffer.
|
|
*/
|
|
XP_EQ(0, o.samples);
|
|
XP_EQ(0, o.deltablks);
|
|
XP_EQ(initial_offset, o.offset);
|
|
}
|
|
|
|
/* Write one more block to advance .offset. */
|
|
r = WRITE(fd, buf, ai.blocksize);
|
|
if (mode2play(openmode)) {
|
|
XP_SYS_EQ(ai.blocksize, r);
|
|
} else {
|
|
XP_SYS_NG(EBADF, r);
|
|
}
|
|
r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/* If offset remains unchanged, this is expected offset. */
|
|
last_offset = initial_offset + ai.blocksize * 2;
|
|
|
|
/* Then, flush. */
|
|
r = IOCTL(fd, AUDIO_FLUSH, NULL, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
/* All should be cleared. */
|
|
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, o.samples);
|
|
XP_EQ(0, o.deltablks);
|
|
if (mode2play(openmode)) {
|
|
/*
|
|
* On NetBSD7,
|
|
* offset is cleared if native encodings(?), but remains
|
|
* unchanged if emulated encodings(?). Looks a bug.
|
|
* On NetBSD9, it should always be cleared.
|
|
*/
|
|
if (netbsd < 9 && o.offset == last_offset) {
|
|
DPRINTF(" > %d: offset(%u) == last_offset\n",
|
|
__LINE__, o.offset);
|
|
} else {
|
|
XP_EQ(initial_offset, o.offset);
|
|
}
|
|
} else {
|
|
XP_EQ(initial_offset, o.offset);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
free(buf);
|
|
}
|
|
DEF(AUDIO_GETOOFFS_flush_RDONLY) { test_AUDIO_GETOOFFS_flush(O_RDONLY); }
|
|
DEF(AUDIO_GETOOFFS_flush_WRONLY) { test_AUDIO_GETOOFFS_flush(O_WRONLY); }
|
|
DEF(AUDIO_GETOOFFS_flush_RDWR) { test_AUDIO_GETOOFFS_flush(O_RDWR); }
|
|
|
|
/*
|
|
* Check whether AUDIO_SETINFO(encoding) clears AUDIO_GETOOFFS.
|
|
*/
|
|
void
|
|
test_AUDIO_GETOOFFS_set(int openmode)
|
|
{
|
|
struct audio_info ai;
|
|
audio_offset_t o;
|
|
char *buf;
|
|
int fd;
|
|
int r;
|
|
u_int initial_offset;
|
|
|
|
TEST("AUDIO_GETOOFFS_set_%s", openmode_str[openmode] + 2);
|
|
if (mode2aumode(openmode) == 0) {
|
|
XP_SKIP("Operation not allowed on this hardware property");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
/* Get blocksize. */
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
buf = (char *)malloc(ai.blocksize);
|
|
REQUIRED_IF(buf != NULL);
|
|
memset(buf, 0xff, ai.blocksize);
|
|
|
|
/*
|
|
* On NetBSD7, .offset starts from one block. What is the block??
|
|
* On NetBSD9, .offset starts from zero.
|
|
*/
|
|
if (netbsd < 9) {
|
|
initial_offset = ai.blocksize;
|
|
} else {
|
|
initial_offset = 0;
|
|
}
|
|
|
|
/* Write one block. */
|
|
r = WRITE(fd, buf, ai.blocksize);
|
|
if (mode2play(openmode)) {
|
|
XP_SYS_EQ(ai.blocksize, r);
|
|
} else {
|
|
XP_SYS_NG(EBADF, r);
|
|
}
|
|
r = IOCTL(fd, AUDIO_DRAIN, NULL, "");
|
|
XP_SYS_EQ(0, r);
|
|
|
|
/*
|
|
* Then, change encoding.
|
|
* If we fail to change it, we cannot continue. This may happen
|
|
* on NetBSD7/8.
|
|
*/
|
|
AUDIO_INITINFO(&ai);
|
|
ai.play.encoding = AUDIO_ENCODING_SLINEAR_NE;
|
|
ai.play.precision = 16;
|
|
ai.play.channels = 2;
|
|
ai.play.sample_rate = 48000;
|
|
r = IOCTL(fd, AUDIO_SETINFO, &ai, "slinear16/2ch/48000");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
r = IOCTL(fd, AUDIO_GETBUFINFO, &ai, "");
|
|
REQUIRED_SYS_EQ(0, r);
|
|
if (netbsd < 9) {
|
|
initial_offset = ai.blocksize;
|
|
} else {
|
|
initial_offset = 0;
|
|
}
|
|
|
|
/* Clear counters? */
|
|
r = IOCTL(fd, AUDIO_GETOOFFS, &o, "");
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, o.samples);
|
|
XP_EQ(0, o.deltablks);
|
|
XP_EQ(initial_offset, o.offset);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
free(buf);
|
|
}
|
|
DEF(AUDIO_GETOOFFS_set_RDONLY) { test_AUDIO_GETOOFFS_set(O_RDONLY); }
|
|
DEF(AUDIO_GETOOFFS_set_WRONLY) { test_AUDIO_GETOOFFS_set(O_WRONLY); }
|
|
DEF(AUDIO_GETOOFFS_set_RDWR) { test_AUDIO_GETOOFFS_set(O_RDWR); }
|
|
|
|
/*
|
|
* /dev/audioctl can always be opened while /dev/audio is open.
|
|
*/
|
|
void
|
|
test_audioctl_open_1(int fmode, int cmode)
|
|
{
|
|
int fd;
|
|
int ctl;
|
|
int r;
|
|
|
|
TEST("audioctl_open_1_%s_%s",
|
|
openmode_str[fmode] + 2, openmode_str[cmode] + 2);
|
|
if (hw_canplay() == 0 && fmode == O_WRONLY) {
|
|
XP_SKIP("This test is for playable device");
|
|
return;
|
|
}
|
|
if (hw_canrec() == 0 && fmode == O_RDONLY) {
|
|
XP_SKIP("This test is for recordable device");
|
|
return;
|
|
}
|
|
|
|
fd = OPEN(devaudio, fmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
ctl = OPEN(devaudioctl, cmode);
|
|
XP_SYS_OK(ctl);
|
|
|
|
r = CLOSE(ctl);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(audioctl_open_1_RDONLY_RDONLY) { test_audioctl_open_1(O_RDONLY, O_RDONLY); }
|
|
DEF(audioctl_open_1_RDONLY_RWONLY) { test_audioctl_open_1(O_RDONLY, O_WRONLY); }
|
|
DEF(audioctl_open_1_RDONLY_RDWR) { test_audioctl_open_1(O_RDONLY, O_RDWR); }
|
|
DEF(audioctl_open_1_WRONLY_RDONLY) { test_audioctl_open_1(O_WRONLY, O_RDONLY); }
|
|
DEF(audioctl_open_1_WRONLY_RWONLY) { test_audioctl_open_1(O_WRONLY, O_WRONLY); }
|
|
DEF(audioctl_open_1_WRONLY_RDWR) { test_audioctl_open_1(O_WRONLY, O_RDWR); }
|
|
DEF(audioctl_open_1_RDWR_RDONLY) { test_audioctl_open_1(O_RDWR, O_RDONLY); }
|
|
DEF(audioctl_open_1_RDWR_RWONLY) { test_audioctl_open_1(O_RDWR, O_WRONLY); }
|
|
DEF(audioctl_open_1_RDWR_RDWR) { test_audioctl_open_1(O_RDWR, O_RDWR); }
|
|
|
|
/*
|
|
* /dev/audio can always be opened while /dev/audioctl is open.
|
|
*/
|
|
void
|
|
test_audioctl_open_2(int fmode, int cmode)
|
|
{
|
|
int fd;
|
|
int ctl;
|
|
int r;
|
|
|
|
TEST("audioctl_open_2_%s_%s",
|
|
openmode_str[fmode] + 2, openmode_str[cmode] + 2);
|
|
if (hw_canplay() == 0 && fmode == O_WRONLY) {
|
|
XP_SKIP("This test is for playable device");
|
|
return;
|
|
}
|
|
if (hw_canrec() == 0 && fmode == O_RDONLY) {
|
|
XP_SKIP("This test is for recordable device");
|
|
return;
|
|
}
|
|
|
|
ctl = OPEN(devaudioctl, cmode);
|
|
REQUIRED_SYS_OK(ctl);
|
|
|
|
fd = OPEN(devaudio, fmode);
|
|
XP_SYS_OK(fd);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(ctl);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(audioctl_open_2_RDONLY_RDONLY) { test_audioctl_open_2(O_RDONLY, O_RDONLY); }
|
|
DEF(audioctl_open_2_RDONLY_RWONLY) { test_audioctl_open_2(O_RDONLY, O_WRONLY); }
|
|
DEF(audioctl_open_2_RDONLY_RDWR) { test_audioctl_open_2(O_RDONLY, O_RDWR); }
|
|
DEF(audioctl_open_2_WRONLY_RDONLY) { test_audioctl_open_2(O_WRONLY, O_RDONLY); }
|
|
DEF(audioctl_open_2_WRONLY_RWONLY) { test_audioctl_open_2(O_WRONLY, O_WRONLY); }
|
|
DEF(audioctl_open_2_WRONLY_RDWR) { test_audioctl_open_2(O_WRONLY, O_RDWR); }
|
|
DEF(audioctl_open_2_RDWR_RDONLY) { test_audioctl_open_2(O_RDWR, O_RDONLY); }
|
|
DEF(audioctl_open_2_RDWR_RWONLY) { test_audioctl_open_2(O_RDWR, O_WRONLY); }
|
|
DEF(audioctl_open_2_RDWR_RDWR) { test_audioctl_open_2(O_RDWR, O_RDWR); }
|
|
|
|
/*
|
|
* Open multiple /dev/audioctl.
|
|
*/
|
|
DEF(audioctl_open_simul)
|
|
{
|
|
int ctl0;
|
|
int ctl1;
|
|
int r;
|
|
|
|
TEST("audioctl_open_simul");
|
|
|
|
ctl0 = OPEN(devaudioctl, O_RDWR);
|
|
REQUIRED_SYS_OK(ctl0);
|
|
|
|
ctl1 = OPEN(devaudioctl, O_RDWR);
|
|
XP_SYS_OK(ctl1);
|
|
|
|
r = CLOSE(ctl0);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(ctl1);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* /dev/audioctl can be opened by other user who opens /dev/audioctl,
|
|
* /dev/audioctl can be opened by other user who opens /dev/audio,
|
|
* /dev/audio can be opened by other user who opens /dev/audioctl,
|
|
* regardless of multiuser mode.
|
|
*/
|
|
void
|
|
try_audioctl_open_multiuser(const char *dev1, const char *dev2)
|
|
{
|
|
int fd1;
|
|
int fd2;
|
|
int r;
|
|
uid_t ouid;
|
|
|
|
/*
|
|
* At first, open dev1 as root.
|
|
* And then open dev2 as unprivileged user.
|
|
*/
|
|
|
|
fd1 = OPEN(dev1, O_RDWR);
|
|
REQUIRED_SYS_OK(fd1);
|
|
|
|
ouid = GETUID();
|
|
r = SETEUID(1);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
fd2 = OPEN(dev2, O_RDWR);
|
|
XP_SYS_OK(fd2);
|
|
|
|
/* Close */
|
|
r = CLOSE(fd2);
|
|
XP_SYS_EQ(0, r);
|
|
|
|
r = SETEUID(ouid);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
|
|
r = CLOSE(fd1);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
/*
|
|
* This is a wrapper for audioctl_open_multiuser.
|
|
* XXX XP_* macros are not compatible with on-error-goto, we need try-catch...
|
|
*/
|
|
void
|
|
test_audioctl_open_multiuser(bool multiuser,
|
|
const char *dev1, const char *dev2)
|
|
{
|
|
char mibname[32];
|
|
bool oldval;
|
|
size_t oldlen;
|
|
int r;
|
|
|
|
if (netbsd < 8 && multiuser == 1) {
|
|
XP_SKIP("multiuser is not supported");
|
|
return;
|
|
}
|
|
if (netbsd < 9) {
|
|
/* NetBSD8 has no way (difficult) to determine device name */
|
|
XP_SKIP("NetBSD8 cannot determine device name");
|
|
return;
|
|
}
|
|
if (geteuid() != 0) {
|
|
XP_SKIP("This test must be priviledged user");
|
|
return;
|
|
}
|
|
|
|
/* Get current multiuser mode (and save it) */
|
|
snprintf(mibname, sizeof(mibname), "hw.%s.multiuser", devicename);
|
|
oldlen = sizeof(oldval);
|
|
r = SYSCTLBYNAME(mibname, &oldval, &oldlen, NULL, 0);
|
|
REQUIRED_SYS_EQ(0, r);
|
|
DPRINTF(" > multiuser=%d\n", oldval);
|
|
|
|
/* Change if necessary */
|
|
if (oldval != multiuser) {
|
|
r = SYSCTLBYNAME(mibname, NULL, NULL, &multiuser,
|
|
sizeof(multiuser));
|
|
REQUIRED_SYS_EQ(0, r);
|
|
DPRINTF(" > new multiuser=%d\n", multiuser);
|
|
}
|
|
|
|
/* Do test */
|
|
try_audioctl_open_multiuser(dev1, dev2);
|
|
|
|
/* Restore multiuser mode */
|
|
if (oldval != multiuser) {
|
|
DPRINTF(" > restore multiuser to %d\n", oldval);
|
|
r = SYSCTLBYNAME(mibname, NULL, NULL, &oldval, sizeof(oldval));
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
}
|
|
DEF(audioctl_open_multiuser0_audio1) {
|
|
TEST("audioctl_open_multiuser0_audio1");
|
|
test_audioctl_open_multiuser(false, devaudio, devaudioctl);
|
|
}
|
|
DEF(audioctl_open_multiuser1_audio1) {
|
|
TEST("audioctl_open_multiuser1_audio1");
|
|
test_audioctl_open_multiuser(true, devaudio, devaudioctl);
|
|
}
|
|
DEF(audioctl_open_multiuser0_audio2) {
|
|
TEST("audioctl_open_multiuser0_audio2");
|
|
test_audioctl_open_multiuser(false, devaudioctl, devaudio);
|
|
}
|
|
DEF(audioctl_open_multiuser1_audio2) {
|
|
TEST("audioctl_open_multiuser1_audio2");
|
|
test_audioctl_open_multiuser(true, devaudioctl, devaudio);
|
|
}
|
|
DEF(audioctl_open_multiuser0_audioctl) {
|
|
TEST("audioctl_open_multiuser0_audioctl");
|
|
test_audioctl_open_multiuser(false, devaudioctl, devaudioctl);
|
|
}
|
|
DEF(audioctl_open_multiuser1_audioctl) {
|
|
TEST("audioctl_open_multiuser1_audioctl");
|
|
test_audioctl_open_multiuser(true, devaudioctl, devaudioctl);
|
|
}
|
|
|
|
/*
|
|
* /dev/audioctl cannot be read/written regardless of its open mode.
|
|
*/
|
|
void
|
|
test_audioctl_rw(int openmode)
|
|
{
|
|
char buf[1];
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("audioctl_rw_%s", openmode_str[openmode] + 2);
|
|
|
|
fd = OPEN(devaudioctl, openmode);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
if (mode2play(openmode)) {
|
|
r = WRITE(fd, buf, sizeof(buf));
|
|
XP_SYS_NG(ENODEV, r);
|
|
}
|
|
|
|
if (mode2rec(openmode)) {
|
|
r = READ(fd, buf, sizeof(buf));
|
|
XP_SYS_NG(ENODEV, r);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
DEF(audioctl_rw_RDONLY) { test_audioctl_rw(O_RDONLY); }
|
|
DEF(audioctl_rw_WRONLY) { test_audioctl_rw(O_WRONLY); }
|
|
DEF(audioctl_rw_RDWR) { test_audioctl_rw(O_RDWR); }
|
|
|
|
/*
|
|
* poll(2) for /dev/audioctl should never raise.
|
|
* I'm not sure about consistency between poll(2) and kqueue(2) but
|
|
* anyway I follow it.
|
|
* XXX Omit checking each openmode
|
|
*/
|
|
DEF(audioctl_poll)
|
|
{
|
|
struct pollfd pfd;
|
|
int fd;
|
|
int r;
|
|
|
|
TEST("audioctl_poll");
|
|
|
|
fd = OPEN(devaudioctl, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
pfd.fd = fd;
|
|
pfd.events = POLLOUT;
|
|
r = POLL(&pfd, 1, 100);
|
|
XP_SYS_EQ(0, r);
|
|
XP_EQ(0, pfd.revents);
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
/*
|
|
* kqueue(2) for /dev/audioctl fails.
|
|
* I'm not sure about consistency between poll(2) and kqueue(2) but
|
|
* anyway I follow it.
|
|
* XXX Omit checking each openmode
|
|
*/
|
|
DEF(audioctl_kqueue)
|
|
{
|
|
struct kevent kev;
|
|
int fd;
|
|
int kq;
|
|
int r;
|
|
|
|
TEST("audioctl_kqueue");
|
|
|
|
fd = OPEN(devaudioctl, O_WRONLY);
|
|
REQUIRED_SYS_OK(fd);
|
|
|
|
kq = KQUEUE();
|
|
XP_SYS_OK(kq);
|
|
|
|
EV_SET(&kev, fd, EVFILT_WRITE, EV_ADD, 0, 0, 0);
|
|
r = KEVENT_SET(kq, &kev, 1);
|
|
/*
|
|
* NetBSD7 has a bug. It looks to wanted to treat it as successful
|
|
* but returned 1(== EPERM).
|
|
* On NetBSD9, I decided to return ENODEV.
|
|
*/
|
|
if (netbsd < 8) {
|
|
XP_SYS_NG(1/*EPERM*/, r);
|
|
} else {
|
|
XP_SYS_NG(ENODEV, r);
|
|
}
|
|
|
|
r = CLOSE(fd);
|
|
XP_SYS_EQ(0, r);
|
|
}
|
|
|
|
|
|
/*
|
|
* This table is processed by t_audio.awk!
|
|
* Keep /^\tENT(testname),/ format in order to add to atf.
|
|
*/
|
|
#define ENT(x) { #x, test__ ## x }
|
|
struct testentry testtable[] = {
|
|
ENT(open_mode_RDONLY),
|
|
ENT(open_mode_WRONLY),
|
|
ENT(open_mode_RDWR),
|
|
ENT(open_audio_RDONLY),
|
|
ENT(open_audio_WRONLY),
|
|
ENT(open_audio_RDWR),
|
|
ENT(open_sound_RDONLY),
|
|
ENT(open_sound_WRONLY),
|
|
ENT(open_sound_RDWR),
|
|
ENT(open_audioctl_RDONLY),
|
|
ENT(open_audioctl_WRONLY),
|
|
ENT(open_audioctl_RDWR),
|
|
ENT(open_sound_sticky),
|
|
ENT(open_audioctl_sticky),
|
|
ENT(open_simul_RDONLY_RDONLY),
|
|
ENT(open_simul_RDONLY_WRONLY),
|
|
ENT(open_simul_RDONLY_RDWR),
|
|
ENT(open_simul_WRONLY_RDONLY),
|
|
ENT(open_simul_WRONLY_WRONLY),
|
|
ENT(open_simul_WRONLY_RDWR),
|
|
ENT(open_simul_RDWR_RDONLY),
|
|
ENT(open_simul_RDWR_WRONLY),
|
|
ENT(open_simul_RDWR_RDWR),
|
|
/**/ ENT(open_multiuser_0), // XXX TODO sysctl
|
|
/**/ ENT(open_multiuser_1), // XXX TODO sysctl
|
|
ENT(write_PLAY_ALL),
|
|
ENT(write_PLAY),
|
|
ENT(read),
|
|
ENT(rept_write),
|
|
ENT(rept_read),
|
|
ENT(rdwr_fallback_RDONLY),
|
|
ENT(rdwr_fallback_WRONLY),
|
|
ENT(rdwr_fallback_RDWR),
|
|
ENT(rdwr_two_RDONLY_RDONLY),
|
|
ENT(rdwr_two_RDONLY_WRONLY),
|
|
ENT(rdwr_two_RDONLY_RDWR),
|
|
ENT(rdwr_two_WRONLY_RDONLY),
|
|
ENT(rdwr_two_WRONLY_WRONLY),
|
|
ENT(rdwr_two_WRONLY_RDWR),
|
|
ENT(rdwr_two_RDWR_RDONLY),
|
|
ENT(rdwr_two_RDWR_WRONLY),
|
|
ENT(rdwr_two_RDWR_RDWR),
|
|
ENT(rdwr_simul),
|
|
ENT(drain_incomplete),
|
|
ENT(drain_pause),
|
|
ENT(drain_onrec),
|
|
/**/ ENT(mmap_mode_RDONLY_NONE), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_mode_RDONLY_READ), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_mode_RDONLY_WRITE), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_mode_RDONLY_READWRITE),// XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_mode_WRONLY_NONE), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_mode_WRONLY_READ), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_mode_WRONLY_WRITE), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_mode_WRONLY_READWRITE),// XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_mode_RDWR_NONE), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_mode_RDWR_READ), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_mode_RDWR_WRITE), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_mode_RDWR_READWRITE), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_len_0), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_len_1), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_len_2), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_len_3), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_len_4), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_len_5), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_len_6), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_len_7), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_len_8), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_twice), // XXX rump doesn't support mmap
|
|
/**/ ENT(mmap_multi), // XXX rump doesn't support mmap
|
|
ENT(poll_mode_RDONLY_IN),
|
|
ENT(poll_mode_RDONLY_OUT),
|
|
ENT(poll_mode_RDONLY_INOUT),
|
|
ENT(poll_mode_WRONLY_IN),
|
|
ENT(poll_mode_WRONLY_OUT),
|
|
ENT(poll_mode_WRONLY_INOUT),
|
|
ENT(poll_mode_RDWR_IN),
|
|
ENT(poll_mode_RDWR_OUT),
|
|
ENT(poll_mode_RDWR_INOUT),
|
|
ENT(poll_out_empty),
|
|
ENT(poll_out_full),
|
|
ENT(poll_out_hiwat),
|
|
/**/ ENT(poll_out_unpause), // XXX does not seem to work on rump
|
|
/**/ ENT(poll_out_simul), // XXX does not seem to work on rump
|
|
ENT(poll_in_open_audio),
|
|
ENT(poll_in_open_sound),
|
|
ENT(poll_in_open_audioctl),
|
|
ENT(poll_in_simul),
|
|
ENT(kqueue_mode_RDONLY_READ),
|
|
ENT(kqueue_mode_RDONLY_WRITE),
|
|
ENT(kqueue_mode_WRONLY_READ),
|
|
ENT(kqueue_mode_WRONLY_WRITE),
|
|
ENT(kqueue_mode_RDWR_READ),
|
|
ENT(kqueue_mode_RDWR_WRITE),
|
|
ENT(kqueue_empty),
|
|
ENT(kqueue_full),
|
|
ENT(kqueue_hiwat),
|
|
/**/ ENT(kqueue_unpause), // XXX does not seem to work on rump
|
|
/**/ ENT(kqueue_simul), // XXX does not seem to work on rump
|
|
ENT(ioctl_while_write),
|
|
ENT(FIOASYNC_reset),
|
|
ENT(FIOASYNC_play_signal),
|
|
ENT(FIOASYNC_rec_signal),
|
|
/**/ ENT(FIOASYNC_multi), // XXX does not seem to work on rump
|
|
ENT(AUDIO_WSEEK),
|
|
ENT(AUDIO_SETFD_RDONLY),
|
|
ENT(AUDIO_SETFD_WRONLY),
|
|
ENT(AUDIO_SETFD_RDWR),
|
|
ENT(AUDIO_GETINFO_eof),
|
|
ENT(AUDIO_SETINFO_mode_RDONLY_0),
|
|
ENT(AUDIO_SETINFO_mode_RDONLY_1),
|
|
ENT(AUDIO_SETINFO_mode_RDONLY_2),
|
|
ENT(AUDIO_SETINFO_mode_RDONLY_3),
|
|
ENT(AUDIO_SETINFO_mode_RDONLY_4),
|
|
ENT(AUDIO_SETINFO_mode_RDONLY_5),
|
|
ENT(AUDIO_SETINFO_mode_RDONLY_6),
|
|
ENT(AUDIO_SETINFO_mode_RDONLY_7),
|
|
ENT(AUDIO_SETINFO_mode_RDONLY_8),
|
|
ENT(AUDIO_SETINFO_mode_WRONLY_0),
|
|
ENT(AUDIO_SETINFO_mode_WRONLY_1),
|
|
ENT(AUDIO_SETINFO_mode_WRONLY_2),
|
|
ENT(AUDIO_SETINFO_mode_WRONLY_3),
|
|
ENT(AUDIO_SETINFO_mode_WRONLY_4),
|
|
ENT(AUDIO_SETINFO_mode_WRONLY_5),
|
|
ENT(AUDIO_SETINFO_mode_WRONLY_6),
|
|
ENT(AUDIO_SETINFO_mode_WRONLY_7),
|
|
ENT(AUDIO_SETINFO_mode_WRONLY_8),
|
|
ENT(AUDIO_SETINFO_mode_RDWR_0),
|
|
ENT(AUDIO_SETINFO_mode_RDWR_1),
|
|
ENT(AUDIO_SETINFO_mode_RDWR_2),
|
|
ENT(AUDIO_SETINFO_mode_RDWR_3),
|
|
ENT(AUDIO_SETINFO_mode_RDWR_4),
|
|
ENT(AUDIO_SETINFO_mode_RDWR_5),
|
|
ENT(AUDIO_SETINFO_mode_RDWR_6),
|
|
ENT(AUDIO_SETINFO_mode_RDWR_7),
|
|
ENT(AUDIO_SETINFO_mode_RDWR_8),
|
|
ENT(AUDIO_SETINFO_params_set_RDONLY_0),
|
|
ENT(AUDIO_SETINFO_params_set_RDONLY_1),
|
|
ENT(AUDIO_SETINFO_params_set_WRONLY_0),
|
|
ENT(AUDIO_SETINFO_params_set_WRONLY_1),
|
|
ENT(AUDIO_SETINFO_params_set_WRONLY_2),
|
|
ENT(AUDIO_SETINFO_params_set_WRONLY_3),
|
|
ENT(AUDIO_SETINFO_params_set_RDWR_0),
|
|
ENT(AUDIO_SETINFO_params_set_RDWR_1),
|
|
ENT(AUDIO_SETINFO_params_set_RDWR_2),
|
|
ENT(AUDIO_SETINFO_params_set_RDWR_3),
|
|
ENT(AUDIO_SETINFO_params_simul),
|
|
ENT(AUDIO_SETINFO_channels),
|
|
ENT(AUDIO_SETINFO_sample_rate),
|
|
ENT(AUDIO_SETINFO_sample_rate_0),
|
|
ENT(AUDIO_SETINFO_pause_RDONLY_0),
|
|
ENT(AUDIO_SETINFO_pause_RDONLY_1),
|
|
ENT(AUDIO_SETINFO_pause_WRONLY_0),
|
|
ENT(AUDIO_SETINFO_pause_WRONLY_1),
|
|
ENT(AUDIO_SETINFO_pause_WRONLY_2),
|
|
ENT(AUDIO_SETINFO_pause_WRONLY_3),
|
|
ENT(AUDIO_SETINFO_pause_RDWR_0),
|
|
ENT(AUDIO_SETINFO_pause_RDWR_1),
|
|
ENT(AUDIO_SETINFO_pause_RDWR_2),
|
|
ENT(AUDIO_SETINFO_pause_RDWR_3),
|
|
ENT(AUDIO_SETINFO_gain),
|
|
ENT(AUDIO_SETINFO_gain_balance),
|
|
/**/ ENT(AUDIO_SETINFO_mmap_enc), // XXX rump doesn't support mmap
|
|
/**/ ENT(AUDIO_SETINFO_mmap_pause), // XXX rump doesn't support mmap
|
|
ENT(AUDIO_GETENC_range),
|
|
ENT(AUDIO_GETENC_error),
|
|
ENT(AUDIO_ERROR_RDONLY),
|
|
ENT(AUDIO_ERROR_WRONLY),
|
|
ENT(AUDIO_ERROR_RDWR),
|
|
ENT(AUDIO_GETIOFFS_one_RDONLY),
|
|
ENT(AUDIO_GETIOFFS_one_WRONLY),
|
|
ENT(AUDIO_GETIOFFS_one_RDWR),
|
|
ENT(AUDIO_GETOOFFS_one_RDONLY),
|
|
ENT(AUDIO_GETOOFFS_one_WRONLY),
|
|
ENT(AUDIO_GETOOFFS_one_RDWR),
|
|
ENT(AUDIO_GETOOFFS_wrap_RDONLY),
|
|
ENT(AUDIO_GETOOFFS_wrap_WRONLY),
|
|
ENT(AUDIO_GETOOFFS_wrap_RDWR),
|
|
ENT(AUDIO_GETOOFFS_flush_RDONLY),
|
|
ENT(AUDIO_GETOOFFS_flush_WRONLY),
|
|
ENT(AUDIO_GETOOFFS_flush_RDWR),
|
|
ENT(AUDIO_GETOOFFS_set_RDONLY),
|
|
ENT(AUDIO_GETOOFFS_set_WRONLY),
|
|
ENT(AUDIO_GETOOFFS_set_RDWR),
|
|
ENT(audioctl_open_1_RDONLY_RDONLY),
|
|
ENT(audioctl_open_1_RDONLY_RWONLY),
|
|
ENT(audioctl_open_1_RDONLY_RDWR),
|
|
ENT(audioctl_open_1_WRONLY_RDONLY),
|
|
ENT(audioctl_open_1_WRONLY_RWONLY),
|
|
ENT(audioctl_open_1_WRONLY_RDWR),
|
|
ENT(audioctl_open_1_RDWR_RDONLY),
|
|
ENT(audioctl_open_1_RDWR_RWONLY),
|
|
ENT(audioctl_open_1_RDWR_RDWR),
|
|
ENT(audioctl_open_2_RDONLY_RDONLY),
|
|
ENT(audioctl_open_2_RDONLY_RWONLY),
|
|
ENT(audioctl_open_2_RDONLY_RDWR),
|
|
ENT(audioctl_open_2_WRONLY_RDONLY),
|
|
ENT(audioctl_open_2_WRONLY_RWONLY),
|
|
ENT(audioctl_open_2_WRONLY_RDWR),
|
|
ENT(audioctl_open_2_RDWR_RDONLY),
|
|
ENT(audioctl_open_2_RDWR_RWONLY),
|
|
ENT(audioctl_open_2_RDWR_RDWR),
|
|
ENT(audioctl_open_simul),
|
|
/**/ ENT(audioctl_open_multiuser0_audio1), // XXX TODO sysctl
|
|
/**/ ENT(audioctl_open_multiuser1_audio1), // XXX TODO sysctl
|
|
/**/ ENT(audioctl_open_multiuser0_audio2), // XXX TODO sysctl
|
|
/**/ ENT(audioctl_open_multiuser1_audio2), // XXX TODO sysctl
|
|
/**/ ENT(audioctl_open_multiuser0_audioctl), // XXX TODO sysctl
|
|
/**/ ENT(audioctl_open_multiuser1_audioctl), // XXX TODO sysctl
|
|
ENT(audioctl_rw_RDONLY),
|
|
ENT(audioctl_rw_WRONLY),
|
|
ENT(audioctl_rw_RDWR),
|
|
ENT(audioctl_poll),
|
|
ENT(audioctl_kqueue),
|
|
{.name = NULL},
|
|
};
|