[net-next-2.6.git] / sound / pci / asihpi / hpidebug.h

/*****************************************************************************

    AudioScience HPI driver
    Copyright (C) 1997-2010  AudioScience Inc. <support@audioscience.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of version 2 of the GNU General Public License as
    published by the Free Software Foundation;

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

Debug macros.

*****************************************************************************/

#ifndef _HPIDEBUG_H
#define _HPIDEBUG_H

#include "hpi_internal.h"

/* Define debugging levels.  */
enum { HPI_DEBUG_LEVEL_ERROR = 0,	/* always log errors */
	HPI_DEBUG_LEVEL_WARNING = 1,
	HPI_DEBUG_LEVEL_NOTICE = 2,
	HPI_DEBUG_LEVEL_INFO = 3,
	HPI_DEBUG_LEVEL_DEBUG = 4,
	HPI_DEBUG_LEVEL_VERBOSE = 5	/* same printk level as DEBUG */
};

#define HPI_DEBUG_LEVEL_DEFAULT HPI_DEBUG_LEVEL_NOTICE

/* an OS can define an extra flag string that is appended to
   the start of each message, eg see hpios_linux.h */

#ifdef SOURCEFILE_NAME
#define FILE_LINE  SOURCEFILE_NAME ":" __stringify(__LINE__) " "
#else
#define FILE_LINE  __FILE__ ":" __stringify(__LINE__) " "
#endif

#if defined(HPI_DEBUG) && defined(_WINDOWS)
#define HPI_DEBUGBREAK() debug_break()
#else
#define HPI_DEBUGBREAK()
#endif

#define HPI_DEBUG_ASSERT(expression) \
	do { \
		if (!(expression)) {\
			printk(KERN_ERR  FILE_LINE\
				"ASSERT " __stringify(expression));\
			HPI_DEBUGBREAK();\
		} \
	} while (0)

#define HPI_DEBUG_LOG(level, ...) \
	do { \
		if (hpi_debug_level >= HPI_DEBUG_LEVEL_##level) { \
			printk(HPI_DEBUG_FLAG_##level \
			FILE_LINE  __VA_ARGS__); \
		} \
	} while (0)

void hpi_debug_init(void);
int hpi_debug_level_set(int level);
int hpi_debug_level_get(void);
/* needed by Linux driver for dynamic debug level changes */
extern int hpi_debug_level;

void hpi_debug_message(struct hpi_message *phm, char *sz_fileline);

void hpi_debug_data(u16 *pdata, u32 len);

#define HPI_DEBUG_DATA(pdata, len)                                      \
	do {                                                            \
		if (hpi_debug_level >= HPI_DEBUG_LEVEL_VERBOSE) \
			hpi_debug_data(pdata, len); \
	} while (0)

#define HPI_DEBUG_MESSAGE(level, phm)                                   \
	do {                                                            \
		if (hpi_debug_level >= HPI_DEBUG_LEVEL_##level) {         \
			hpi_debug_message(phm,HPI_DEBUG_FLAG_##level    \
				FILE_LINE __stringify(level));\
		}                                                       \
	} while (0)

#define HPI_DEBUG_RESPONSE(phr)                                         \
	do {                                                            \
		if ((hpi_debug_level >= HPI_DEBUG_LEVEL_DEBUG) && (phr->error))\
			HPI_DEBUG_LOG(ERROR, \
				"HPI response - error# %d\n", \
				phr->error); \
		else if (hpi_debug_level >= HPI_DEBUG_LEVEL_VERBOSE) \
			HPI_DEBUG_LOG(VERBOSE, "HPI response OK\n");\
	} while (0)

#ifndef compile_time_assert
#define compile_time_assert(cond, msg) \
    typedef char msg[(cond) ? 1 : -1]
#endif

	  /* check that size is exactly some number */
#define function_count_check(sym, size) \
    compile_time_assert((sym##_FUNCTION_COUNT) == (size),\
	    strings_match_defs_##sym)

/* These strings should be generated using a macro which defines
   the corresponding symbol values.  */
#define HPI_OBJ_STRINGS \
{                               \
  "HPI_OBJ_SUBSYSTEM",        \
  "HPI_OBJ_ADAPTER",          \
  "HPI_OBJ_OSTREAM",          \
  "HPI_OBJ_ISTREAM",          \
  "HPI_OBJ_MIXER",            \
  "HPI_OBJ_NODE",             \
  "HPI_OBJ_CONTROL",          \
  "HPI_OBJ_NVMEMORY",         \
  "HPI_OBJ_DIGITALIO",        \
  "HPI_OBJ_WATCHDOG",         \
  "HPI_OBJ_CLOCK",            \
  "HPI_OBJ_PROFILE",          \
  "HPI_OBJ_CONTROLEX"         \
}

#define HPI_SUBSYS_STRINGS      \
{                               \
  "HPI_SUBSYS_OPEN",          \
  "HPI_SUBSYS_GET_VERSION",   \
  "HPI_SUBSYS_GET_INFO",      \
  "HPI_SUBSYS_FIND_ADAPTERS", \
  "HPI_SUBSYS_CREATE_ADAPTER",\
  "HPI_SUBSYS_CLOSE",         \
  "HPI_SUBSYS_DELETE_ADAPTER", \
  "HPI_SUBSYS_DRIVER_LOAD", \
  "HPI_SUBSYS_DRIVER_UNLOAD", \
  "HPI_SUBSYS_READ_PORT_8",   \
  "HPI_SUBSYS_WRITE_PORT_8",  \
  "HPI_SUBSYS_GET_NUM_ADAPTERS",\
  "HPI_SUBSYS_GET_ADAPTER",   \
  "HPI_SUBSYS_SET_NETWORK_INTERFACE"\
}
function_count_check(HPI_SUBSYS, 14);

#define HPI_ADAPTER_STRINGS     \
{                               \
  "HPI_ADAPTER_OPEN",         \
  "HPI_ADAPTER_CLOSE",        \
  "HPI_ADAPTER_GET_INFO",     \
  "HPI_ADAPTER_GET_ASSERT",   \
  "HPI_ADAPTER_TEST_ASSERT",    \
  "HPI_ADAPTER_SET_MODE",       \
  "HPI_ADAPTER_GET_MODE",       \
  "HPI_ADAPTER_ENABLE_CAPABILITY",\
  "HPI_ADAPTER_SELFTEST",        \
  "HPI_ADAPTER_FIND_OBJECT",     \
  "HPI_ADAPTER_QUERY_FLASH",     \
  "HPI_ADAPTER_START_FLASH",     \
  "HPI_ADAPTER_PROGRAM_FLASH",   \
  "HPI_ADAPTER_SET_PROPERTY",    \
  "HPI_ADAPTER_GET_PROPERTY",    \
  "HPI_ADAPTER_ENUM_PROPERTY",    \
  "HPI_ADAPTER_MODULE_INFO",    \
  "HPI_ADAPTER_DEBUG_READ"    \
}

function_count_check(HPI_ADAPTER, 18);

#define HPI_OSTREAM_STRINGS     \
{                               \
  "HPI_OSTREAM_OPEN",         \
  "HPI_OSTREAM_CLOSE",        \
  "HPI_OSTREAM_WRITE",        \
  "HPI_OSTREAM_START",        \
  "HPI_OSTREAM_STOP",         \
  "HPI_OSTREAM_RESET",                \
  "HPI_OSTREAM_GET_INFO",     \
  "HPI_OSTREAM_QUERY_FORMAT", \
  "HPI_OSTREAM_DATA",         \
  "HPI_OSTREAM_SET_VELOCITY", \
  "HPI_OSTREAM_SET_PUNCHINOUT", \
  "HPI_OSTREAM_SINEGEN",        \
  "HPI_OSTREAM_ANC_RESET",      \
  "HPI_OSTREAM_ANC_GET_INFO",   \
  "HPI_OSTREAM_ANC_READ",       \
  "HPI_OSTREAM_SET_TIMESCALE",\
  "HPI_OSTREAM_SET_FORMAT", \
  "HPI_OSTREAM_HOSTBUFFER_ALLOC", \
  "HPI_OSTREAM_HOSTBUFFER_FREE", \
  "HPI_OSTREAM_GROUP_ADD",\
  "HPI_OSTREAM_GROUP_GETMAP", \
  "HPI_OSTREAM_GROUP_RESET", \
  "HPI_OSTREAM_HOSTBUFFER_GET_INFO", \
  "HPI_OSTREAM_WAIT_START", \
}
function_count_check(HPI_OSTREAM, 24);

#define HPI_ISTREAM_STRINGS     \
{                               \
  "HPI_ISTREAM_OPEN",         \
  "HPI_ISTREAM_CLOSE",        \
  "HPI_ISTREAM_SET_FORMAT",   \
  "HPI_ISTREAM_READ",         \
  "HPI_ISTREAM_START",        \
  "HPI_ISTREAM_STOP",         \
  "HPI_ISTREAM_RESET",        \
  "HPI_ISTREAM_GET_INFO",     \
  "HPI_ISTREAM_QUERY_FORMAT", \
  "HPI_ISTREAM_ANC_RESET",      \
  "HPI_ISTREAM_ANC_GET_INFO",   \
  "HPI_ISTREAM_ANC_WRITE",   \
  "HPI_ISTREAM_HOSTBUFFER_ALLOC",\
  "HPI_ISTREAM_HOSTBUFFER_FREE", \
  "HPI_ISTREAM_GROUP_ADD", \
  "HPI_ISTREAM_GROUP_GETMAP", \
  "HPI_ISTREAM_GROUP_RESET", \
  "HPI_ISTREAM_HOSTBUFFER_GET_INFO", \
  "HPI_ISTREAM_WAIT_START", \
}
function_count_check(HPI_ISTREAM, 19);

#define HPI_MIXER_STRINGS       \
{                               \
  "HPI_MIXER_OPEN",           \
  "HPI_MIXER_CLOSE",          \
  "HPI_MIXER_GET_INFO",       \
  "HPI_MIXER_GET_NODE_INFO",  \
  "HPI_MIXER_GET_CONTROL",    \
  "HPI_MIXER_SET_CONNECTION", \
  "HPI_MIXER_GET_CONNECTIONS",        \
  "HPI_MIXER_GET_CONTROL_BY_INDEX",   \
  "HPI_MIXER_GET_CONTROL_ARRAY_BY_INDEX",     \
  "HPI_MIXER_GET_CONTROL_MULTIPLE_VALUES",    \
  "HPI_MIXER_STORE",  \
}
function_count_check(HPI_MIXER, 11);

#define HPI_CONTROL_STRINGS     \
{                               \
  "HPI_CONTROL_GET_INFO",     \
  "HPI_CONTROL_GET_STATE",    \
  "HPI_CONTROL_SET_STATE"     \
}
function_count_check(HPI_CONTROL, 3);

#define HPI_NVMEMORY_STRINGS    \
{                               \
  "HPI_NVMEMORY_OPEN",        \
  "HPI_NVMEMORY_READ_BYTE",   \
  "HPI_NVMEMORY_WRITE_BYTE"   \
}
function_count_check(HPI_NVMEMORY, 3);

#define HPI_DIGITALIO_STRINGS   \
{                               \
  "HPI_GPIO_OPEN",            \
  "HPI_GPIO_READ_BIT",        \
  "HPI_GPIO_WRITE_BIT",       \
  "HPI_GPIO_READ_ALL",                \
  "HPI_GPIO_WRITE_STATUS"\
}
function_count_check(HPI_GPIO, 5);

#define HPI_WATCHDOG_STRINGS    \
{                               \
  "HPI_WATCHDOG_OPEN",        \
  "HPI_WATCHDOG_SET_TIME",    \
  "HPI_WATCHDOG_PING"         \
}

#define HPI_CLOCK_STRINGS       \
{                               \
  "HPI_CLOCK_OPEN",           \
  "HPI_CLOCK_SET_TIME",       \
  "HPI_CLOCK_GET_TIME"        \
}

#define HPI_PROFILE_STRINGS     \
{                               \
  "HPI_PROFILE_OPEN_ALL",     \
  "HPI_PROFILE_START_ALL",    \
  "HPI_PROFILE_STOP_ALL",     \
  "HPI_PROFILE_GET",          \
  "HPI_PROFILE_GET_IDLECOUNT",  \
  "HPI_PROFILE_GET_NAME",       \
  "HPI_PROFILE_GET_UTILIZATION" \
}
function_count_check(HPI_PROFILE, 7);

#define HPI_ASYNCEVENT_STRINGS  \
{                               \
  "HPI_ASYNCEVENT_OPEN",\
  "HPI_ASYNCEVENT_CLOSE  ",\
  "HPI_ASYNCEVENT_WAIT",\
  "HPI_ASYNCEVENT_GETCOUNT",\
  "HPI_ASYNCEVENT_GET",\
  "HPI_ASYNCEVENT_SENDEVENTS"\
}
function_count_check(HPI_ASYNCEVENT, 6);

#define HPI_CONTROL_TYPE_STRINGS \
{ \
	"null control", \
	"HPI_CONTROL_CONNECTION", \
	"HPI_CONTROL_VOLUME", \
	"HPI_CONTROL_METER", \
	"HPI_CONTROL_MUTE", \
	"HPI_CONTROL_MULTIPLEXER", \
	"HPI_CONTROL_AESEBU_TRANSMITTER", \
	"HPI_CONTROL_AESEBU_RECEIVER", \
	"HPI_CONTROL_LEVEL", \
	"HPI_CONTROL_TUNER", \
	"HPI_CONTROL_ONOFFSWITCH", \
	"HPI_CONTROL_VOX", \
	"HPI_CONTROL_AES18_TRANSMITTER", \
	"HPI_CONTROL_AES18_RECEIVER", \
	"HPI_CONTROL_AES18_BLOCKGENERATOR", \
	"HPI_CONTROL_CHANNEL_MODE", \
	"HPI_CONTROL_BITSTREAM", \
	"HPI_CONTROL_SAMPLECLOCK", \
	"HPI_CONTROL_MICROPHONE", \
	"HPI_CONTROL_PARAMETRIC_EQ", \
	"HPI_CONTROL_COMPANDER", \
	"HPI_CONTROL_COBRANET", \
	"HPI_CONTROL_TONE_DETECT", \
	"HPI_CONTROL_SILENCE_DETECT", \
	"HPI_CONTROL_PAD", \
	"HPI_CONTROL_SRC" ,\
	"HPI_CONTROL_UNIVERSAL" \
}

compile_time_assert((HPI_CONTROL_LAST_INDEX + 1 == 27),
	controltype_strings_match_defs);

#define HPI_SOURCENODE_STRINGS \
{ \
	"no source", \
	"HPI_SOURCENODE_OSTREAM", \
	"HPI_SOURCENODE_LINEIN", \
	"HPI_SOURCENODE_AESEBU_IN", \
	"HPI_SOURCENODE_TUNER", \
	"HPI_SOURCENODE_RF", \
	"HPI_SOURCENODE_CLOCK_SOURCE", \
	"HPI_SOURCENODE_RAW_BITSTREAM", \
	"HPI_SOURCENODE_MICROPHONE", \
	"HPI_SOURCENODE_COBRANET", \
	"HPI_SOURCENODE_ANALOG", \
	"HPI_SOURCENODE_ADAPTER" \
}

compile_time_assert((HPI_SOURCENODE_LAST_INDEX - HPI_SOURCENODE_NONE + 1) ==
	(12), sourcenode_strings_match_defs);

#define HPI_DESTNODE_STRINGS \
{ \
	"no destination", \
	"HPI_DESTNODE_ISTREAM", \
	"HPI_DESTNODE_LINEOUT", \
	"HPI_DESTNODE_AESEBU_OUT", \
	"HPI_DESTNODE_RF", \
	"HPI_DESTNODE_SPEAKER", \
	"HPI_DESTNODE_COBRANET", \
	"HPI_DESTNODE_ANALOG" \
}
compile_time_assert((HPI_DESTNODE_LAST_INDEX - HPI_DESTNODE_NONE + 1) == (8),
	destnode_strings_match_defs);

#define HPI_CONTROL_CHANNEL_MODE_STRINGS \
{ \
	"XXX HPI_CHANNEL_MODE_ERROR XXX", \
	"HPI_CHANNEL_MODE_NORMAL", \
	"HPI_CHANNEL_MODE_SWAP", \
	"HPI_CHANNEL_MODE_LEFT_ONLY", \
	"HPI_CHANNEL_MODE_RIGHT_ONLY" \
}

#endif				/* _HPIDEBUG_H  */
Commit	Line	Data
719f82d3 EB	1	/*****************************************************************************
	2
	3	AudioScience HPI driver
	4	Copyright (C) 1997-2010 AudioScience Inc. <support@audioscience.com>
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of version 2 of the GNU General Public License as
	8	published by the Free Software Foundation;
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; if not, write to the Free Software
	17	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18
	19	Debug macros.
	20
	21	*****************************************************************************/
	22
	23	#ifndef _HPIDEBUG_H
	24	#define _HPIDEBUG_H
	25
	26	#include "hpi_internal.h"
	27
	28	/* Define debugging levels. */
	29	enum { HPI_DEBUG_LEVEL_ERROR = 0, /* always log errors */
	30	HPI_DEBUG_LEVEL_WARNING = 1,
	31	HPI_DEBUG_LEVEL_NOTICE = 2,
	32	HPI_DEBUG_LEVEL_INFO = 3,
	33	HPI_DEBUG_LEVEL_DEBUG = 4,
	34	HPI_DEBUG_LEVEL_VERBOSE = 5 /* same printk level as DEBUG */
	35	};
	36
	37	#define HPI_DEBUG_LEVEL_DEFAULT HPI_DEBUG_LEVEL_NOTICE
	38
	39	/* an OS can define an extra flag string that is appended to
	40	the start of each message, eg see hpios_linux.h */
	41
	42	#ifdef SOURCEFILE_NAME
	43	#define FILE_LINE SOURCEFILE_NAME ":" __stringify(__LINE__) " "
	44	#else
	45	#define FILE_LINE __FILE__ ":" __stringify(__LINE__) " "
	46	#endif
	47
	48	#if defined(HPI_DEBUG) && defined(_WINDOWS)
	49	#define HPI_DEBUGBREAK() debug_break()
	50	#else
	51	#define HPI_DEBUGBREAK()
	52	#endif
	53
	54	#define HPI_DEBUG_ASSERT(expression) \
	55	do { \
	56	if (!(expression)) {\
	57	printk(KERN_ERR FILE_LINE\
	58	"ASSERT " __stringify(expression));\
	59	HPI_DEBUGBREAK();\
	60	} \
	61	} while (0)
	62
	63	#define HPI_DEBUG_LOG(level, ...) \
	64	do { \
65	if (hpi_debug_level >= HPI_DEBUG_LEVEL_##level) { \
66	printk(HPI_DEBUG_FLAG_##level \
67	FILE_LINE __VA_ARGS__); \
68	} \
69	} while (0)
70
71	void hpi_debug_init(void);
72	int hpi_debug_level_set(int level);
73	int hpi_debug_level_get(void);
74	/* needed by Linux driver for dynamic debug level changes */
75	extern int hpi_debug_level;
76
77	void hpi_debug_message(struct hpi_message phm, char sz_fileline);
78
79	void hpi_debug_data(u16 *pdata, u32 len);
80
81	#define HPI_DEBUG_DATA(pdata, len) \
82	do { \
83	if (hpi_debug_level >= HPI_DEBUG_LEVEL_VERBOSE) \
84	hpi_debug_data(pdata, len); \
85	} while (0)
86
87	#define HPI_DEBUG_MESSAGE(level, phm) \
88	do { \
89	if (hpi_debug_level >= HPI_DEBUG_LEVEL_##level) { \
90	hpi_debug_message(phm,HPI_DEBUG_FLAG_##level \
91	FILE_LINE __stringify(level));\
92	} \
93	} while (0)
94
95	#define HPI_DEBUG_RESPONSE(phr) \
96	do { \
97	if ((hpi_debug_level >= HPI_DEBUG_LEVEL_DEBUG) && (phr->error))\
98	HPI_DEBUG_LOG(ERROR, \
99	"HPI response - error# %d\n", \
100	phr->error); \
101	else if (hpi_debug_level >= HPI_DEBUG_LEVEL_VERBOSE) \
102	HPI_DEBUG_LOG(VERBOSE, "HPI response OK\n");\
103	} while (0)
104
105	#ifndef compile_time_assert
106	#define compile_time_assert(cond, msg) \
107	typedef char msg[(cond) ? 1 : -1]
108	#endif
109
110	/* check that size is exactly some number */
111	#define function_count_check(sym, size) \
112	compile_time_assert((sym##_FUNCTION_COUNT) == (size),\
113	strings_match_defs_##sym)
114
115	/* These strings should be generated using a macro which defines
116	the corresponding symbol values. */
117	#define HPI_OBJ_STRINGS \
118	{ \
119	"HPI_OBJ_SUBSYSTEM", \
120	"HPI_OBJ_ADAPTER", \
121	"HPI_OBJ_OSTREAM", \
122	"HPI_OBJ_ISTREAM", \
123	"HPI_OBJ_MIXER", \
124	"HPI_OBJ_NODE", \
125	"HPI_OBJ_CONTROL", \
126	"HPI_OBJ_NVMEMORY", \
127	"HPI_OBJ_DIGITALIO", \
128	"HPI_OBJ_WATCHDOG", \
129	"HPI_OBJ_CLOCK", \
130	"HPI_OBJ_PROFILE", \
131	"HPI_OBJ_CONTROLEX" \
132	}
133
134	#define HPI_SUBSYS_STRINGS \
135	{ \
136	"HPI_SUBSYS_OPEN", \
137	"HPI_SUBSYS_GET_VERSION", \
138	"HPI_SUBSYS_GET_INFO", \
139	"HPI_SUBSYS_FIND_ADAPTERS", \
140	"HPI_SUBSYS_CREATE_ADAPTER",\
141	"HPI_SUBSYS_CLOSE", \
142	"HPI_SUBSYS_DELETE_ADAPTER", \
143	"HPI_SUBSYS_DRIVER_LOAD", \
144	"HPI_SUBSYS_DRIVER_UNLOAD", \
145	"HPI_SUBSYS_READ_PORT_8", \
146	"HPI_SUBSYS_WRITE_PORT_8", \
147	"HPI_SUBSYS_GET_NUM_ADAPTERS",\
148	"HPI_SUBSYS_GET_ADAPTER", \
149	"HPI_SUBSYS_SET_NETWORK_INTERFACE"\
150	}
151	function_count_check(HPI_SUBSYS, 14);
152
153	#define HPI_ADAPTER_STRINGS \
154	{ \
155	"HPI_ADAPTER_OPEN", \
156	"HPI_ADAPTER_CLOSE", \
157	"HPI_ADAPTER_GET_INFO", \
158	"HPI_ADAPTER_GET_ASSERT", \
159	"HPI_ADAPTER_TEST_ASSERT", \
160	"HPI_ADAPTER_SET_MODE", \
161	"HPI_ADAPTER_GET_MODE", \
162	"HPI_ADAPTER_ENABLE_CAPABILITY",\
163	"HPI_ADAPTER_SELFTEST", \
164	"HPI_ADAPTER_FIND_OBJECT", \
165	"HPI_ADAPTER_QUERY_FLASH", \
166	"HPI_ADAPTER_START_FLASH", \
167	"HPI_ADAPTER_PROGRAM_FLASH", \
168	"HPI_ADAPTER_SET_PROPERTY", \
169	"HPI_ADAPTER_GET_PROPERTY", \
170	"HPI_ADAPTER_ENUM_PROPERTY", \
171	"HPI_ADAPTER_MODULE_INFO", \
172	"HPI_ADAPTER_DEBUG_READ" \
173	}
174
175	function_count_check(HPI_ADAPTER, 18);
176
177	#define HPI_OSTREAM_STRINGS \
178	{ \
179	"HPI_OSTREAM_OPEN", \
180	"HPI_OSTREAM_CLOSE", \
181	"HPI_OSTREAM_WRITE", \
182	"HPI_OSTREAM_START", \
183	"HPI_OSTREAM_STOP", \
184	"HPI_OSTREAM_RESET", \
185	"HPI_OSTREAM_GET_INFO", \
186	"HPI_OSTREAM_QUERY_FORMAT", \
187	"HPI_OSTREAM_DATA", \
188	"HPI_OSTREAM_SET_VELOCITY", \
189	"HPI_OSTREAM_SET_PUNCHINOUT", \
190	"HPI_OSTREAM_SINEGEN", \
191	"HPI_OSTREAM_ANC_RESET", \
192	"HPI_OSTREAM_ANC_GET_INFO", \
193	"HPI_OSTREAM_ANC_READ", \
194	"HPI_OSTREAM_SET_TIMESCALE",\
195	"HPI_OSTREAM_SET_FORMAT", \
196	"HPI_OSTREAM_HOSTBUFFER_ALLOC", \
197	"HPI_OSTREAM_HOSTBUFFER_FREE", \
198	"HPI_OSTREAM_GROUP_ADD",\
199	"HPI_OSTREAM_GROUP_GETMAP", \
200	"HPI_OSTREAM_GROUP_RESET", \
201	"HPI_OSTREAM_HOSTBUFFER_GET_INFO", \
202	"HPI_OSTREAM_WAIT_START", \
203	}
204	function_count_check(HPI_OSTREAM, 24);
205
206	#define HPI_ISTREAM_STRINGS \
207	{ \
208	"HPI_ISTREAM_OPEN", \
209	"HPI_ISTREAM_CLOSE", \
210	"HPI_ISTREAM_SET_FORMAT", \
211	"HPI_ISTREAM_READ", \
212	"HPI_ISTREAM_START", \
213	"HPI_ISTREAM_STOP", \
214	"HPI_ISTREAM_RESET", \
215	"HPI_ISTREAM_GET_INFO", \
216	"HPI_ISTREAM_QUERY_FORMAT", \
217	"HPI_ISTREAM_ANC_RESET", \
218	"HPI_ISTREAM_ANC_GET_INFO", \
219	"HPI_ISTREAM_ANC_WRITE", \
220	"HPI_ISTREAM_HOSTBUFFER_ALLOC",\
221	"HPI_ISTREAM_HOSTBUFFER_FREE", \
222	"HPI_ISTREAM_GROUP_ADD", \
223	"HPI_ISTREAM_GROUP_GETMAP", \
224	"HPI_ISTREAM_GROUP_RESET", \
225	"HPI_ISTREAM_HOSTBUFFER_GET_INFO", \
226	"HPI_ISTREAM_WAIT_START", \
227	}
228	function_count_check(HPI_ISTREAM, 19);
229
230	#define HPI_MIXER_STRINGS \
231	{ \
232	"HPI_MIXER_OPEN", \
233	"HPI_MIXER_CLOSE", \
234	"HPI_MIXER_GET_INFO", \
235	"HPI_MIXER_GET_NODE_INFO", \
236	"HPI_MIXER_GET_CONTROL", \
237	"HPI_MIXER_SET_CONNECTION", \
238	"HPI_MIXER_GET_CONNECTIONS", \
239	"HPI_MIXER_GET_CONTROL_BY_INDEX", \
240	"HPI_MIXER_GET_CONTROL_ARRAY_BY_INDEX", \
241	"HPI_MIXER_GET_CONTROL_MULTIPLE_VALUES", \
242	"HPI_MIXER_STORE", \
243	}
244	function_count_check(HPI_MIXER, 11);
245
246	#define HPI_CONTROL_STRINGS \
247	{ \
248	"HPI_CONTROL_GET_INFO", \
249	"HPI_CONTROL_GET_STATE", \
250	"HPI_CONTROL_SET_STATE" \
251	}
252	function_count_check(HPI_CONTROL, 3);
253
254	#define HPI_NVMEMORY_STRINGS \
255	{ \
256	"HPI_NVMEMORY_OPEN", \
257	"HPI_NVMEMORY_READ_BYTE", \
258	"HPI_NVMEMORY_WRITE_BYTE" \
259	}
260	function_count_check(HPI_NVMEMORY, 3);
261
262	#define HPI_DIGITALIO_STRINGS \
263	{ \
264	"HPI_GPIO_OPEN", \
265	"HPI_GPIO_READ_BIT", \
266	"HPI_GPIO_WRITE_BIT", \
267	"HPI_GPIO_READ_ALL", \
268	"HPI_GPIO_WRITE_STATUS"\
269	}
270	function_count_check(HPI_GPIO, 5);
271
272	#define HPI_WATCHDOG_STRINGS \
273	{ \
274	"HPI_WATCHDOG_OPEN", \
275	"HPI_WATCHDOG_SET_TIME", \
276	"HPI_WATCHDOG_PING" \
277	}
278
279	#define HPI_CLOCK_STRINGS \
280	{ \
281	"HPI_CLOCK_OPEN", \
282	"HPI_CLOCK_SET_TIME", \
283	"HPI_CLOCK_GET_TIME" \
284	}
285
286	#define HPI_PROFILE_STRINGS \
287	{ \
288	"HPI_PROFILE_OPEN_ALL", \
289	"HPI_PROFILE_START_ALL", \
290	"HPI_PROFILE_STOP_ALL", \
291	"HPI_PROFILE_GET", \
292	"HPI_PROFILE_GET_IDLECOUNT", \
293	"HPI_PROFILE_GET_NAME", \
294	"HPI_PROFILE_GET_UTILIZATION" \
295	}
296	function_count_check(HPI_PROFILE, 7);
297
298	#define HPI_ASYNCEVENT_STRINGS \
299	{ \
300	"HPI_ASYNCEVENT_OPEN",\
301	"HPI_ASYNCEVENT_CLOSE ",\
302	"HPI_ASYNCEVENT_WAIT",\
303	"HPI_ASYNCEVENT_GETCOUNT",\
304	"HPI_ASYNCEVENT_GET",\
305	"HPI_ASYNCEVENT_SENDEVENTS"\
306	}
307	function_count_check(HPI_ASYNCEVENT, 6);
308
309	#define HPI_CONTROL_TYPE_STRINGS \
310	{ \
311	"null control", \
312	"HPI_CONTROL_CONNECTION", \
313	"HPI_CONTROL_VOLUME", \
314	"HPI_CONTROL_METER", \
315	"HPI_CONTROL_MUTE", \
316	"HPI_CONTROL_MULTIPLEXER", \
317	"HPI_CONTROL_AESEBU_TRANSMITTER", \
318	"HPI_CONTROL_AESEBU_RECEIVER", \
319	"HPI_CONTROL_LEVEL", \
320	"HPI_CONTROL_TUNER", \
321	"HPI_CONTROL_ONOFFSWITCH", \
322	"HPI_CONTROL_VOX", \
323	"HPI_CONTROL_AES18_TRANSMITTER", \
324	"HPI_CONTROL_AES18_RECEIVER", \
325	"HPI_CONTROL_AES18_BLOCKGENERATOR", \
326	"HPI_CONTROL_CHANNEL_MODE", \
327	"HPI_CONTROL_BITSTREAM", \
328	"HPI_CONTROL_SAMPLECLOCK", \
329	"HPI_CONTROL_MICROPHONE", \
330	"HPI_CONTROL_PARAMETRIC_EQ", \
331	"HPI_CONTROL_COMPANDER", \
332	"HPI_CONTROL_COBRANET", \
333	"HPI_CONTROL_TONE_DETECT", \
334	"HPI_CONTROL_SILENCE_DETECT", \
335	"HPI_CONTROL_PAD", \
336	"HPI_CONTROL_SRC" ,\
337	"HPI_CONTROL_UNIVERSAL" \
338	}
339
340	compile_time_assert((HPI_CONTROL_LAST_INDEX + 1 == 27),
341	controltype_strings_match_defs);
342
343	#define HPI_SOURCENODE_STRINGS \
344	{ \
345	"no source", \
346	"HPI_SOURCENODE_OSTREAM", \
347	"HPI_SOURCENODE_LINEIN", \
348	"HPI_SOURCENODE_AESEBU_IN", \
349	"HPI_SOURCENODE_TUNER", \
350	"HPI_SOURCENODE_RF", \
351	"HPI_SOURCENODE_CLOCK_SOURCE", \
352	"HPI_SOURCENODE_RAW_BITSTREAM", \
353	"HPI_SOURCENODE_MICROPHONE", \
354	"HPI_SOURCENODE_COBRANET", \
355	"HPI_SOURCENODE_ANALOG", \
356	"HPI_SOURCENODE_ADAPTER" \
357	}
358
168f1b07	359	compile_time_assert((HPI_SOURCENODE_LAST_INDEX - HPI_SOURCENODE_NONE + 1) ==
719f82d3 EB	360	(12), sourcenode_strings_match_defs);
	361
	362	#define HPI_DESTNODE_STRINGS \
	363	{ \
	364	"no destination", \
	365	"HPI_DESTNODE_ISTREAM", \
	366	"HPI_DESTNODE_LINEOUT", \
	367	"HPI_DESTNODE_AESEBU_OUT", \
	368	"HPI_DESTNODE_RF", \
	369	"HPI_DESTNODE_SPEAKER", \
	370	"HPI_DESTNODE_COBRANET", \
	371	"HPI_DESTNODE_ANALOG" \
	372	}
168f1b07	373	compile_time_assert((HPI_DESTNODE_LAST_INDEX - HPI_DESTNODE_NONE + 1) == (8),
719f82d3 EB	374	destnode_strings_match_defs);
	375
	376	#define HPI_CONTROL_CHANNEL_MODE_STRINGS \
	377	{ \
	378	"XXX HPI_CHANNEL_MODE_ERROR XXX", \
	379	"HPI_CHANNEL_MODE_NORMAL", \
	380	"HPI_CHANNEL_MODE_SWAP", \
	381	"HPI_CHANNEL_MODE_LEFT_ONLY", \
	382	"HPI_CHANNEL_MODE_RIGHT_ONLY" \
	383	}
	384
	385	#endif /* _HPIDEBUG_H */