xref: /openbmc/linux/sound/pci/asihpi/hpifunc.c (revision 4f2c0a4acffbec01079c28f839422e64ddeff004)
1  // SPDX-License-Identifier: GPL-2.0
2  
3  #include "hpi_internal.h"
4  #include "hpimsginit.h"
5  
6  #include "hpidebug.h"
7  
8  struct hpi_handle {
9  	unsigned int obj_index:12;
10  	unsigned int obj_type:4;
11  	unsigned int adapter_index:14;
12  	unsigned int spare:1;
13  	unsigned int read_only:1;
14  };
15  
16  union handle_word {
17  	struct hpi_handle h;
18  	u32 w;
19  };
20  
hpi_indexes_to_handle(const char c_object,const u16 adapter_index,const u16 object_index)21  u32 hpi_indexes_to_handle(const char c_object, const u16 adapter_index,
22  	const u16 object_index)
23  {
24  	union handle_word handle;
25  
26  	handle.h.adapter_index = adapter_index;
27  	handle.h.spare = 0;
28  	handle.h.read_only = 0;
29  	handle.h.obj_type = c_object;
30  	handle.h.obj_index = object_index;
31  	return handle.w;
32  }
33  
hpi_handle_indexes(const u32 h,u16 * p1,u16 * p2)34  static u16 hpi_handle_indexes(const u32 h, u16 *p1, u16 *p2)
35  {
36  	union handle_word uhandle;
37  	if (!h)
38  		return HPI_ERROR_INVALID_HANDLE;
39  
40  	uhandle.w = h;
41  
42  	*p1 = (u16)uhandle.h.adapter_index;
43  	if (p2)
44  		*p2 = (u16)uhandle.h.obj_index;
45  
46  	return 0;
47  }
48  
hpi_handle_to_indexes(const u32 handle,u16 * pw_adapter_index,u16 * pw_object_index)49  void hpi_handle_to_indexes(const u32 handle, u16 *pw_adapter_index,
50  	u16 *pw_object_index)
51  {
52  	hpi_handle_indexes(handle, pw_adapter_index, pw_object_index);
53  }
54  
hpi_handle_object(const u32 handle)55  char hpi_handle_object(const u32 handle)
56  {
57  	union handle_word uhandle;
58  	uhandle.w = handle;
59  	return (char)uhandle.h.obj_type;
60  }
61  
hpi_format_to_msg(struct hpi_msg_format * pMF,const struct hpi_format * pF)62  void hpi_format_to_msg(struct hpi_msg_format *pMF,
63  	const struct hpi_format *pF)
64  {
65  	pMF->sample_rate = pF->sample_rate;
66  	pMF->bit_rate = pF->bit_rate;
67  	pMF->attributes = pF->attributes;
68  	pMF->channels = pF->channels;
69  	pMF->format = pF->format;
70  }
71  
hpi_msg_to_format(struct hpi_format * pF,struct hpi_msg_format * pMF)72  static void hpi_msg_to_format(struct hpi_format *pF,
73  	struct hpi_msg_format *pMF)
74  {
75  	pF->sample_rate = pMF->sample_rate;
76  	pF->bit_rate = pMF->bit_rate;
77  	pF->attributes = pMF->attributes;
78  	pF->channels = pMF->channels;
79  	pF->format = pMF->format;
80  	pF->mode_legacy = 0;
81  	pF->unused = 0;
82  }
83  
hpi_stream_response_to_legacy(struct hpi_stream_res * pSR)84  void hpi_stream_response_to_legacy(struct hpi_stream_res *pSR)
85  {
86  	pSR->u.legacy_stream_info.auxiliary_data_available =
87  		pSR->u.stream_info.auxiliary_data_available;
88  	pSR->u.legacy_stream_info.state = pSR->u.stream_info.state;
89  }
90  
hpi_send_recvV1(struct hpi_message_header * m,struct hpi_response_header * r)91  static inline void hpi_send_recvV1(struct hpi_message_header *m,
92  	struct hpi_response_header *r)
93  {
94  	hpi_send_recv((struct hpi_message *)m, (struct hpi_response *)r);
95  }
96  
hpi_subsys_get_version_ex(u32 * pversion_ex)97  u16 hpi_subsys_get_version_ex(u32 *pversion_ex)
98  {
99  	struct hpi_message hm;
100  	struct hpi_response hr;
101  
102  	hpi_init_message_response(&hm, &hr, HPI_OBJ_SUBSYSTEM,
103  		HPI_SUBSYS_GET_VERSION);
104  	hpi_send_recv(&hm, &hr);
105  	*pversion_ex = hr.u.s.data;
106  	return hr.error;
107  }
108  
hpi_subsys_get_num_adapters(int * pn_num_adapters)109  u16 hpi_subsys_get_num_adapters(int *pn_num_adapters)
110  {
111  	struct hpi_message hm;
112  	struct hpi_response hr;
113  	hpi_init_message_response(&hm, &hr, HPI_OBJ_SUBSYSTEM,
114  		HPI_SUBSYS_GET_NUM_ADAPTERS);
115  	hpi_send_recv(&hm, &hr);
116  	*pn_num_adapters = (int)hr.u.s.num_adapters;
117  	return hr.error;
118  }
119  
hpi_subsys_get_adapter(int iterator,u32 * padapter_index,u16 * pw_adapter_type)120  u16 hpi_subsys_get_adapter(int iterator, u32 *padapter_index,
121  	u16 *pw_adapter_type)
122  {
123  	struct hpi_message hm;
124  	struct hpi_response hr;
125  	hpi_init_message_response(&hm, &hr, HPI_OBJ_SUBSYSTEM,
126  		HPI_SUBSYS_GET_ADAPTER);
127  	hm.obj_index = (u16)iterator;
128  	hpi_send_recv(&hm, &hr);
129  	*padapter_index = (int)hr.u.s.adapter_index;
130  	*pw_adapter_type = hr.u.s.adapter_type;
131  
132  	return hr.error;
133  }
134  
hpi_adapter_open(u16 adapter_index)135  u16 hpi_adapter_open(u16 adapter_index)
136  {
137  	struct hpi_message hm;
138  	struct hpi_response hr;
139  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
140  		HPI_ADAPTER_OPEN);
141  	hm.adapter_index = adapter_index;
142  
143  	hpi_send_recv(&hm, &hr);
144  
145  	return hr.error;
146  
147  }
148  
hpi_adapter_close(u16 adapter_index)149  u16 hpi_adapter_close(u16 adapter_index)
150  {
151  	struct hpi_message hm;
152  	struct hpi_response hr;
153  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
154  		HPI_ADAPTER_CLOSE);
155  	hm.adapter_index = adapter_index;
156  
157  	hpi_send_recv(&hm, &hr);
158  
159  	return hr.error;
160  }
161  
hpi_adapter_set_mode(u16 adapter_index,u32 adapter_mode)162  u16 hpi_adapter_set_mode(u16 adapter_index, u32 adapter_mode)
163  {
164  	return hpi_adapter_set_mode_ex(adapter_index, adapter_mode,
165  		HPI_ADAPTER_MODE_SET);
166  }
167  
hpi_adapter_set_mode_ex(u16 adapter_index,u32 adapter_mode,u16 query_or_set)168  u16 hpi_adapter_set_mode_ex(u16 adapter_index, u32 adapter_mode,
169  	u16 query_or_set)
170  {
171  	struct hpi_message hm;
172  	struct hpi_response hr;
173  
174  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
175  		HPI_ADAPTER_SET_MODE);
176  	hm.adapter_index = adapter_index;
177  	hm.u.ax.mode.adapter_mode = adapter_mode;
178  	hm.u.ax.mode.query_or_set = query_or_set;
179  	hpi_send_recv(&hm, &hr);
180  	return hr.error;
181  }
182  
hpi_adapter_get_mode(u16 adapter_index,u32 * padapter_mode)183  u16 hpi_adapter_get_mode(u16 adapter_index, u32 *padapter_mode)
184  {
185  	struct hpi_message hm;
186  	struct hpi_response hr;
187  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
188  		HPI_ADAPTER_GET_MODE);
189  	hm.adapter_index = adapter_index;
190  	hpi_send_recv(&hm, &hr);
191  	if (padapter_mode)
192  		*padapter_mode = hr.u.ax.mode.adapter_mode;
193  	return hr.error;
194  }
195  
hpi_adapter_get_info(u16 adapter_index,u16 * pw_num_outstreams,u16 * pw_num_instreams,u16 * pw_version,u32 * pserial_number,u16 * pw_adapter_type)196  u16 hpi_adapter_get_info(u16 adapter_index, u16 *pw_num_outstreams,
197  	u16 *pw_num_instreams, u16 *pw_version, u32 *pserial_number,
198  	u16 *pw_adapter_type)
199  {
200  	struct hpi_message hm;
201  	struct hpi_response hr;
202  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
203  		HPI_ADAPTER_GET_INFO);
204  	hm.adapter_index = adapter_index;
205  
206  	hpi_send_recv(&hm, &hr);
207  
208  	*pw_adapter_type = hr.u.ax.info.adapter_type;
209  	*pw_num_outstreams = hr.u.ax.info.num_outstreams;
210  	*pw_num_instreams = hr.u.ax.info.num_instreams;
211  	*pw_version = hr.u.ax.info.version;
212  	*pserial_number = hr.u.ax.info.serial_number;
213  	return hr.error;
214  }
215  
hpi_adapter_get_module_by_index(u16 adapter_index,u16 module_index,u16 * pw_num_outputs,u16 * pw_num_inputs,u16 * pw_version,u32 * pserial_number,u16 * pw_module_type,u32 * ph_module)216  u16 hpi_adapter_get_module_by_index(u16 adapter_index, u16 module_index,
217  	u16 *pw_num_outputs, u16 *pw_num_inputs, u16 *pw_version,
218  	u32 *pserial_number, u16 *pw_module_type, u32 *ph_module)
219  {
220  	struct hpi_message hm;
221  	struct hpi_response hr;
222  
223  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
224  		HPI_ADAPTER_MODULE_INFO);
225  	hm.adapter_index = adapter_index;
226  	hm.u.ax.module_info.index = module_index;
227  
228  	hpi_send_recv(&hm, &hr);
229  
230  	*pw_module_type = hr.u.ax.info.adapter_type;
231  	*pw_num_outputs = hr.u.ax.info.num_outstreams;
232  	*pw_num_inputs = hr.u.ax.info.num_instreams;
233  	*pw_version = hr.u.ax.info.version;
234  	*pserial_number = hr.u.ax.info.serial_number;
235  	*ph_module = 0;
236  
237  	return hr.error;
238  }
239  
hpi_adapter_set_property(u16 adapter_index,u16 property,u16 parameter1,u16 parameter2)240  u16 hpi_adapter_set_property(u16 adapter_index, u16 property, u16 parameter1,
241  	u16 parameter2)
242  {
243  	struct hpi_message hm;
244  	struct hpi_response hr;
245  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
246  		HPI_ADAPTER_SET_PROPERTY);
247  	hm.adapter_index = adapter_index;
248  	hm.u.ax.property_set.property = property;
249  	hm.u.ax.property_set.parameter1 = parameter1;
250  	hm.u.ax.property_set.parameter2 = parameter2;
251  
252  	hpi_send_recv(&hm, &hr);
253  
254  	return hr.error;
255  }
256  
hpi_adapter_get_property(u16 adapter_index,u16 property,u16 * pw_parameter1,u16 * pw_parameter2)257  u16 hpi_adapter_get_property(u16 adapter_index, u16 property,
258  	u16 *pw_parameter1, u16 *pw_parameter2)
259  {
260  	struct hpi_message hm;
261  	struct hpi_response hr;
262  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
263  		HPI_ADAPTER_GET_PROPERTY);
264  	hm.adapter_index = adapter_index;
265  	hm.u.ax.property_set.property = property;
266  
267  	hpi_send_recv(&hm, &hr);
268  	if (!hr.error) {
269  		if (pw_parameter1)
270  			*pw_parameter1 = hr.u.ax.property_get.parameter1;
271  		if (pw_parameter2)
272  			*pw_parameter2 = hr.u.ax.property_get.parameter2;
273  	}
274  
275  	return hr.error;
276  }
277  
hpi_adapter_enumerate_property(u16 adapter_index,u16 index,u16 what_to_enumerate,u16 property_index,u32 * psetting)278  u16 hpi_adapter_enumerate_property(u16 adapter_index, u16 index,
279  	u16 what_to_enumerate, u16 property_index, u32 *psetting)
280  {
281  	return 0;
282  }
283  
hpi_format_create(struct hpi_format * p_format,u16 channels,u16 format,u32 sample_rate,u32 bit_rate,u32 attributes)284  u16 hpi_format_create(struct hpi_format *p_format, u16 channels, u16 format,
285  	u32 sample_rate, u32 bit_rate, u32 attributes)
286  {
287  	u16 err = 0;
288  	struct hpi_msg_format fmt;
289  
290  	switch (channels) {
291  	case 1:
292  	case 2:
293  	case 4:
294  	case 6:
295  	case 8:
296  	case 16:
297  		break;
298  	default:
299  		err = HPI_ERROR_INVALID_CHANNELS;
300  		return err;
301  	}
302  	fmt.channels = channels;
303  
304  	switch (format) {
305  	case HPI_FORMAT_PCM16_SIGNED:
306  	case HPI_FORMAT_PCM24_SIGNED:
307  	case HPI_FORMAT_PCM32_SIGNED:
308  	case HPI_FORMAT_PCM32_FLOAT:
309  	case HPI_FORMAT_PCM16_BIGENDIAN:
310  	case HPI_FORMAT_PCM8_UNSIGNED:
311  	case HPI_FORMAT_MPEG_L1:
312  	case HPI_FORMAT_MPEG_L2:
313  	case HPI_FORMAT_MPEG_L3:
314  	case HPI_FORMAT_DOLBY_AC2:
315  	case HPI_FORMAT_AA_TAGIT1_HITS:
316  	case HPI_FORMAT_AA_TAGIT1_INSERTS:
317  	case HPI_FORMAT_RAW_BITSTREAM:
318  	case HPI_FORMAT_AA_TAGIT1_HITS_EX1:
319  	case HPI_FORMAT_OEM1:
320  	case HPI_FORMAT_OEM2:
321  		break;
322  	default:
323  		err = HPI_ERROR_INVALID_FORMAT;
324  		return err;
325  	}
326  	fmt.format = format;
327  
328  	if (sample_rate < 8000L) {
329  		err = HPI_ERROR_INCOMPATIBLE_SAMPLERATE;
330  		sample_rate = 8000L;
331  	}
332  	if (sample_rate > 200000L) {
333  		err = HPI_ERROR_INCOMPATIBLE_SAMPLERATE;
334  		sample_rate = 200000L;
335  	}
336  	fmt.sample_rate = sample_rate;
337  
338  	switch (format) {
339  	case HPI_FORMAT_MPEG_L1:
340  	case HPI_FORMAT_MPEG_L2:
341  	case HPI_FORMAT_MPEG_L3:
342  		fmt.bit_rate = bit_rate;
343  		break;
344  	case HPI_FORMAT_PCM16_SIGNED:
345  	case HPI_FORMAT_PCM16_BIGENDIAN:
346  		fmt.bit_rate = channels * sample_rate * 2;
347  		break;
348  	case HPI_FORMAT_PCM32_SIGNED:
349  	case HPI_FORMAT_PCM32_FLOAT:
350  		fmt.bit_rate = channels * sample_rate * 4;
351  		break;
352  	case HPI_FORMAT_PCM8_UNSIGNED:
353  		fmt.bit_rate = channels * sample_rate;
354  		break;
355  	default:
356  		fmt.bit_rate = 0;
357  	}
358  
359  	switch (format) {
360  	case HPI_FORMAT_MPEG_L2:
361  		if ((channels == 1)
362  			&& (attributes != HPI_MPEG_MODE_DEFAULT)) {
363  			attributes = HPI_MPEG_MODE_DEFAULT;
364  			err = HPI_ERROR_INVALID_FORMAT;
365  		} else if (attributes > HPI_MPEG_MODE_DUALCHANNEL) {
366  			attributes = HPI_MPEG_MODE_DEFAULT;
367  			err = HPI_ERROR_INVALID_FORMAT;
368  		}
369  		fmt.attributes = attributes;
370  		break;
371  	default:
372  		fmt.attributes = attributes;
373  	}
374  
375  	hpi_msg_to_format(p_format, &fmt);
376  	return err;
377  }
378  
hpi_stream_estimate_buffer_size(struct hpi_format * p_format,u32 host_polling_rate_in_milli_seconds,u32 * recommended_buffer_size)379  u16 hpi_stream_estimate_buffer_size(struct hpi_format *p_format,
380  	u32 host_polling_rate_in_milli_seconds, u32 *recommended_buffer_size)
381  {
382  
383  	u32 bytes_per_second;
384  	u32 size;
385  	u16 channels;
386  	struct hpi_format *pF = p_format;
387  
388  	channels = pF->channels;
389  
390  	switch (pF->format) {
391  	case HPI_FORMAT_PCM16_BIGENDIAN:
392  	case HPI_FORMAT_PCM16_SIGNED:
393  		bytes_per_second = pF->sample_rate * 2L * channels;
394  		break;
395  	case HPI_FORMAT_PCM24_SIGNED:
396  		bytes_per_second = pF->sample_rate * 3L * channels;
397  		break;
398  	case HPI_FORMAT_PCM32_SIGNED:
399  	case HPI_FORMAT_PCM32_FLOAT:
400  		bytes_per_second = pF->sample_rate * 4L * channels;
401  		break;
402  	case HPI_FORMAT_PCM8_UNSIGNED:
403  		bytes_per_second = pF->sample_rate * 1L * channels;
404  		break;
405  	case HPI_FORMAT_MPEG_L1:
406  	case HPI_FORMAT_MPEG_L2:
407  	case HPI_FORMAT_MPEG_L3:
408  		bytes_per_second = pF->bit_rate / 8L;
409  		break;
410  	case HPI_FORMAT_DOLBY_AC2:
411  
412  		bytes_per_second = 256000L / 8L;
413  		break;
414  	default:
415  		return HPI_ERROR_INVALID_FORMAT;
416  	}
417  	size = (bytes_per_second * host_polling_rate_in_milli_seconds * 2) /
418  		1000L;
419  
420  	*recommended_buffer_size =
421  		roundup_pow_of_two(((size + 4095L) & ~4095L));
422  	return 0;
423  }
424  
hpi_outstream_open(u16 adapter_index,u16 outstream_index,u32 * ph_outstream)425  u16 hpi_outstream_open(u16 adapter_index, u16 outstream_index,
426  	u32 *ph_outstream)
427  {
428  	struct hpi_message hm;
429  	struct hpi_response hr;
430  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
431  		HPI_OSTREAM_OPEN);
432  	hm.adapter_index = adapter_index;
433  	hm.obj_index = outstream_index;
434  
435  	hpi_send_recv(&hm, &hr);
436  
437  	if (hr.error == 0)
438  		*ph_outstream =
439  			hpi_indexes_to_handle(HPI_OBJ_OSTREAM, adapter_index,
440  			outstream_index);
441  	else
442  		*ph_outstream = 0;
443  	return hr.error;
444  }
445  
hpi_outstream_close(u32 h_outstream)446  u16 hpi_outstream_close(u32 h_outstream)
447  {
448  	struct hpi_message hm;
449  	struct hpi_response hr;
450  
451  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
452  		HPI_OSTREAM_HOSTBUFFER_FREE);
453  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
454  		return HPI_ERROR_INVALID_HANDLE;
455  
456  	hpi_send_recv(&hm, &hr);
457  
458  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
459  		HPI_OSTREAM_GROUP_RESET);
460  	hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index);
461  	hpi_send_recv(&hm, &hr);
462  
463  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
464  		HPI_OSTREAM_CLOSE);
465  	hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index);
466  	hpi_send_recv(&hm, &hr);
467  
468  	return hr.error;
469  }
470  
hpi_outstream_get_info_ex(u32 h_outstream,u16 * pw_state,u32 * pbuffer_size,u32 * pdata_to_play,u32 * psamples_played,u32 * pauxiliary_data_to_play)471  u16 hpi_outstream_get_info_ex(u32 h_outstream, u16 *pw_state,
472  	u32 *pbuffer_size, u32 *pdata_to_play, u32 *psamples_played,
473  	u32 *pauxiliary_data_to_play)
474  {
475  	struct hpi_message hm;
476  	struct hpi_response hr;
477  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
478  		HPI_OSTREAM_GET_INFO);
479  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
480  		return HPI_ERROR_INVALID_HANDLE;
481  
482  	hpi_send_recv(&hm, &hr);
483  
484  	if (pw_state)
485  		*pw_state = hr.u.d.u.stream_info.state;
486  	if (pbuffer_size)
487  		*pbuffer_size = hr.u.d.u.stream_info.buffer_size;
488  	if (pdata_to_play)
489  		*pdata_to_play = hr.u.d.u.stream_info.data_available;
490  	if (psamples_played)
491  		*psamples_played = hr.u.d.u.stream_info.samples_transferred;
492  	if (pauxiliary_data_to_play)
493  		*pauxiliary_data_to_play =
494  			hr.u.d.u.stream_info.auxiliary_data_available;
495  	return hr.error;
496  }
497  
hpi_outstream_write_buf(u32 h_outstream,const u8 * pb_data,u32 bytes_to_write,const struct hpi_format * p_format)498  u16 hpi_outstream_write_buf(u32 h_outstream, const u8 *pb_data,
499  	u32 bytes_to_write, const struct hpi_format *p_format)
500  {
501  	struct hpi_message hm;
502  	struct hpi_response hr;
503  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
504  		HPI_OSTREAM_WRITE);
505  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
506  		return HPI_ERROR_INVALID_HANDLE;
507  	hm.u.d.u.data.pb_data = (u8 *)pb_data;
508  	hm.u.d.u.data.data_size = bytes_to_write;
509  
510  	hpi_format_to_msg(&hm.u.d.u.data.format, p_format);
511  
512  	hpi_send_recv(&hm, &hr);
513  
514  	return hr.error;
515  }
516  
hpi_outstream_start(u32 h_outstream)517  u16 hpi_outstream_start(u32 h_outstream)
518  {
519  	struct hpi_message hm;
520  	struct hpi_response hr;
521  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
522  		HPI_OSTREAM_START);
523  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
524  		return HPI_ERROR_INVALID_HANDLE;
525  
526  	hpi_send_recv(&hm, &hr);
527  
528  	return hr.error;
529  }
530  
hpi_outstream_wait_start(u32 h_outstream)531  u16 hpi_outstream_wait_start(u32 h_outstream)
532  {
533  	struct hpi_message hm;
534  	struct hpi_response hr;
535  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
536  		HPI_OSTREAM_WAIT_START);
537  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
538  		return HPI_ERROR_INVALID_HANDLE;
539  
540  	hpi_send_recv(&hm, &hr);
541  
542  	return hr.error;
543  }
544  
hpi_outstream_stop(u32 h_outstream)545  u16 hpi_outstream_stop(u32 h_outstream)
546  {
547  	struct hpi_message hm;
548  	struct hpi_response hr;
549  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
550  		HPI_OSTREAM_STOP);
551  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
552  		return HPI_ERROR_INVALID_HANDLE;
553  
554  	hpi_send_recv(&hm, &hr);
555  
556  	return hr.error;
557  }
558  
hpi_outstream_sinegen(u32 h_outstream)559  u16 hpi_outstream_sinegen(u32 h_outstream)
560  {
561  	struct hpi_message hm;
562  	struct hpi_response hr;
563  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
564  		HPI_OSTREAM_SINEGEN);
565  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
566  		return HPI_ERROR_INVALID_HANDLE;
567  
568  	hpi_send_recv(&hm, &hr);
569  
570  	return hr.error;
571  }
572  
hpi_outstream_reset(u32 h_outstream)573  u16 hpi_outstream_reset(u32 h_outstream)
574  {
575  	struct hpi_message hm;
576  	struct hpi_response hr;
577  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
578  		HPI_OSTREAM_RESET);
579  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
580  		return HPI_ERROR_INVALID_HANDLE;
581  
582  	hpi_send_recv(&hm, &hr);
583  
584  	return hr.error;
585  }
586  
hpi_outstream_query_format(u32 h_outstream,struct hpi_format * p_format)587  u16 hpi_outstream_query_format(u32 h_outstream, struct hpi_format *p_format)
588  {
589  	struct hpi_message hm;
590  	struct hpi_response hr;
591  
592  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
593  		HPI_OSTREAM_QUERY_FORMAT);
594  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
595  		return HPI_ERROR_INVALID_HANDLE;
596  
597  	hpi_format_to_msg(&hm.u.d.u.data.format, p_format);
598  
599  	hpi_send_recv(&hm, &hr);
600  
601  	return hr.error;
602  }
603  
hpi_outstream_set_format(u32 h_outstream,struct hpi_format * p_format)604  u16 hpi_outstream_set_format(u32 h_outstream, struct hpi_format *p_format)
605  {
606  	struct hpi_message hm;
607  	struct hpi_response hr;
608  
609  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
610  		HPI_OSTREAM_SET_FORMAT);
611  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
612  		return HPI_ERROR_INVALID_HANDLE;
613  
614  	hpi_format_to_msg(&hm.u.d.u.data.format, p_format);
615  
616  	hpi_send_recv(&hm, &hr);
617  
618  	return hr.error;
619  }
620  
hpi_outstream_set_velocity(u32 h_outstream,short velocity)621  u16 hpi_outstream_set_velocity(u32 h_outstream, short velocity)
622  {
623  	struct hpi_message hm;
624  	struct hpi_response hr;
625  
626  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
627  		HPI_OSTREAM_SET_VELOCITY);
628  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
629  		return HPI_ERROR_INVALID_HANDLE;
630  	hm.u.d.u.velocity = velocity;
631  
632  	hpi_send_recv(&hm, &hr);
633  
634  	return hr.error;
635  }
636  
hpi_outstream_set_punch_in_out(u32 h_outstream,u32 punch_in_sample,u32 punch_out_sample)637  u16 hpi_outstream_set_punch_in_out(u32 h_outstream, u32 punch_in_sample,
638  	u32 punch_out_sample)
639  {
640  	struct hpi_message hm;
641  	struct hpi_response hr;
642  
643  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
644  		HPI_OSTREAM_SET_PUNCHINOUT);
645  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
646  		return HPI_ERROR_INVALID_HANDLE;
647  
648  	hm.u.d.u.pio.punch_in_sample = punch_in_sample;
649  	hm.u.d.u.pio.punch_out_sample = punch_out_sample;
650  
651  	hpi_send_recv(&hm, &hr);
652  
653  	return hr.error;
654  }
655  
hpi_outstream_ancillary_reset(u32 h_outstream,u16 mode)656  u16 hpi_outstream_ancillary_reset(u32 h_outstream, u16 mode)
657  {
658  	struct hpi_message hm;
659  	struct hpi_response hr;
660  
661  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
662  		HPI_OSTREAM_ANC_RESET);
663  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
664  		return HPI_ERROR_INVALID_HANDLE;
665  	hm.u.d.u.data.format.channels = mode;
666  	hpi_send_recv(&hm, &hr);
667  	return hr.error;
668  }
669  
hpi_outstream_ancillary_get_info(u32 h_outstream,u32 * pframes_available)670  u16 hpi_outstream_ancillary_get_info(u32 h_outstream, u32 *pframes_available)
671  {
672  	struct hpi_message hm;
673  	struct hpi_response hr;
674  
675  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
676  		HPI_OSTREAM_ANC_GET_INFO);
677  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
678  		return HPI_ERROR_INVALID_HANDLE;
679  	hpi_send_recv(&hm, &hr);
680  	if (hr.error == 0) {
681  		if (pframes_available)
682  			*pframes_available =
683  				hr.u.d.u.stream_info.data_available /
684  				sizeof(struct hpi_anc_frame);
685  	}
686  	return hr.error;
687  }
688  
hpi_outstream_ancillary_read(u32 h_outstream,struct hpi_anc_frame * p_anc_frame_buffer,u32 anc_frame_buffer_size_in_bytes,u32 number_of_ancillary_frames_to_read)689  u16 hpi_outstream_ancillary_read(u32 h_outstream,
690  	struct hpi_anc_frame *p_anc_frame_buffer,
691  	u32 anc_frame_buffer_size_in_bytes,
692  	u32 number_of_ancillary_frames_to_read)
693  {
694  	struct hpi_message hm;
695  	struct hpi_response hr;
696  
697  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
698  		HPI_OSTREAM_ANC_READ);
699  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
700  		return HPI_ERROR_INVALID_HANDLE;
701  	hm.u.d.u.data.pb_data = (u8 *)p_anc_frame_buffer;
702  	hm.u.d.u.data.data_size =
703  		number_of_ancillary_frames_to_read *
704  		sizeof(struct hpi_anc_frame);
705  	if (hm.u.d.u.data.data_size <= anc_frame_buffer_size_in_bytes)
706  		hpi_send_recv(&hm, &hr);
707  	else
708  		hr.error = HPI_ERROR_INVALID_DATASIZE;
709  	return hr.error;
710  }
711  
hpi_outstream_set_time_scale(u32 h_outstream,u32 time_scale)712  u16 hpi_outstream_set_time_scale(u32 h_outstream, u32 time_scale)
713  {
714  	struct hpi_message hm;
715  	struct hpi_response hr;
716  
717  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
718  		HPI_OSTREAM_SET_TIMESCALE);
719  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
720  		return HPI_ERROR_INVALID_HANDLE;
721  
722  	hm.u.d.u.time_scale = time_scale;
723  
724  	hpi_send_recv(&hm, &hr);
725  
726  	return hr.error;
727  }
728  
hpi_outstream_host_buffer_allocate(u32 h_outstream,u32 size_in_bytes)729  u16 hpi_outstream_host_buffer_allocate(u32 h_outstream, u32 size_in_bytes)
730  {
731  	struct hpi_message hm;
732  	struct hpi_response hr;
733  
734  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
735  		HPI_OSTREAM_HOSTBUFFER_ALLOC);
736  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
737  		return HPI_ERROR_INVALID_HANDLE;
738  	hm.u.d.u.data.data_size = size_in_bytes;
739  	hpi_send_recv(&hm, &hr);
740  	return hr.error;
741  }
742  
hpi_outstream_host_buffer_get_info(u32 h_outstream,u8 ** pp_buffer,struct hpi_hostbuffer_status ** pp_status)743  u16 hpi_outstream_host_buffer_get_info(u32 h_outstream, u8 **pp_buffer,
744  	struct hpi_hostbuffer_status **pp_status)
745  {
746  	struct hpi_message hm;
747  	struct hpi_response hr;
748  
749  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
750  		HPI_OSTREAM_HOSTBUFFER_GET_INFO);
751  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
752  		return HPI_ERROR_INVALID_HANDLE;
753  	hpi_send_recv(&hm, &hr);
754  
755  	if (hr.error == 0) {
756  		if (pp_buffer)
757  			*pp_buffer = hr.u.d.u.hostbuffer_info.p_buffer;
758  		if (pp_status)
759  			*pp_status = hr.u.d.u.hostbuffer_info.p_status;
760  	}
761  	return hr.error;
762  }
763  
hpi_outstream_host_buffer_free(u32 h_outstream)764  u16 hpi_outstream_host_buffer_free(u32 h_outstream)
765  {
766  	struct hpi_message hm;
767  	struct hpi_response hr;
768  
769  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
770  		HPI_OSTREAM_HOSTBUFFER_FREE);
771  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
772  		return HPI_ERROR_INVALID_HANDLE;
773  	hpi_send_recv(&hm, &hr);
774  	return hr.error;
775  }
776  
hpi_outstream_group_add(u32 h_outstream,u32 h_stream)777  u16 hpi_outstream_group_add(u32 h_outstream, u32 h_stream)
778  {
779  	struct hpi_message hm;
780  	struct hpi_response hr;
781  	u16 adapter;
782  	char c_obj_type;
783  
784  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
785  		HPI_OSTREAM_GROUP_ADD);
786  
787  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
788  		return HPI_ERROR_INVALID_HANDLE;
789  
790  	if (hpi_handle_indexes(h_stream, &adapter,
791  			&hm.u.d.u.stream.stream_index))
792  		return HPI_ERROR_INVALID_HANDLE;
793  
794  	c_obj_type = hpi_handle_object(h_stream);
795  	switch (c_obj_type) {
796  	case HPI_OBJ_OSTREAM:
797  	case HPI_OBJ_ISTREAM:
798  		hm.u.d.u.stream.object_type = c_obj_type;
799  		break;
800  	default:
801  		return HPI_ERROR_INVALID_OBJ;
802  	}
803  	if (adapter != hm.adapter_index)
804  		return HPI_ERROR_NO_INTERADAPTER_GROUPS;
805  
806  	hpi_send_recv(&hm, &hr);
807  	return hr.error;
808  }
809  
hpi_outstream_group_get_map(u32 h_outstream,u32 * poutstream_map,u32 * pinstream_map)810  u16 hpi_outstream_group_get_map(u32 h_outstream, u32 *poutstream_map,
811  	u32 *pinstream_map)
812  {
813  	struct hpi_message hm;
814  	struct hpi_response hr;
815  
816  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
817  		HPI_OSTREAM_GROUP_GETMAP);
818  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
819  		return HPI_ERROR_INVALID_HANDLE;
820  	hpi_send_recv(&hm, &hr);
821  
822  	if (poutstream_map)
823  		*poutstream_map = hr.u.d.u.group_info.outstream_group_map;
824  	if (pinstream_map)
825  		*pinstream_map = hr.u.d.u.group_info.instream_group_map;
826  
827  	return hr.error;
828  }
829  
hpi_outstream_group_reset(u32 h_outstream)830  u16 hpi_outstream_group_reset(u32 h_outstream)
831  {
832  	struct hpi_message hm;
833  	struct hpi_response hr;
834  
835  	hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
836  		HPI_OSTREAM_GROUP_RESET);
837  	if (hpi_handle_indexes(h_outstream, &hm.adapter_index, &hm.obj_index))
838  		return HPI_ERROR_INVALID_HANDLE;
839  	hpi_send_recv(&hm, &hr);
840  	return hr.error;
841  }
842  
hpi_instream_open(u16 adapter_index,u16 instream_index,u32 * ph_instream)843  u16 hpi_instream_open(u16 adapter_index, u16 instream_index, u32 *ph_instream)
844  {
845  	struct hpi_message hm;
846  	struct hpi_response hr;
847  
848  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
849  		HPI_ISTREAM_OPEN);
850  	hm.adapter_index = adapter_index;
851  	hm.obj_index = instream_index;
852  
853  	hpi_send_recv(&hm, &hr);
854  
855  	if (hr.error == 0)
856  		*ph_instream =
857  			hpi_indexes_to_handle(HPI_OBJ_ISTREAM, adapter_index,
858  			instream_index);
859  	else
860  		*ph_instream = 0;
861  
862  	return hr.error;
863  }
864  
hpi_instream_close(u32 h_instream)865  u16 hpi_instream_close(u32 h_instream)
866  {
867  	struct hpi_message hm;
868  	struct hpi_response hr;
869  
870  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
871  		HPI_ISTREAM_HOSTBUFFER_FREE);
872  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
873  		return HPI_ERROR_INVALID_HANDLE;
874  	hpi_send_recv(&hm, &hr);
875  
876  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
877  		HPI_ISTREAM_GROUP_RESET);
878  	hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index);
879  	hpi_send_recv(&hm, &hr);
880  
881  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
882  		HPI_ISTREAM_CLOSE);
883  	hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index);
884  	hpi_send_recv(&hm, &hr);
885  
886  	return hr.error;
887  }
888  
hpi_instream_query_format(u32 h_instream,const struct hpi_format * p_format)889  u16 hpi_instream_query_format(u32 h_instream,
890  	const struct hpi_format *p_format)
891  {
892  	struct hpi_message hm;
893  	struct hpi_response hr;
894  
895  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
896  		HPI_ISTREAM_QUERY_FORMAT);
897  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
898  		return HPI_ERROR_INVALID_HANDLE;
899  	hpi_format_to_msg(&hm.u.d.u.data.format, p_format);
900  
901  	hpi_send_recv(&hm, &hr);
902  
903  	return hr.error;
904  }
905  
hpi_instream_set_format(u32 h_instream,const struct hpi_format * p_format)906  u16 hpi_instream_set_format(u32 h_instream, const struct hpi_format *p_format)
907  {
908  	struct hpi_message hm;
909  	struct hpi_response hr;
910  
911  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
912  		HPI_ISTREAM_SET_FORMAT);
913  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
914  		return HPI_ERROR_INVALID_HANDLE;
915  	hpi_format_to_msg(&hm.u.d.u.data.format, p_format);
916  
917  	hpi_send_recv(&hm, &hr);
918  
919  	return hr.error;
920  }
921  
hpi_instream_read_buf(u32 h_instream,u8 * pb_data,u32 bytes_to_read)922  u16 hpi_instream_read_buf(u32 h_instream, u8 *pb_data, u32 bytes_to_read)
923  {
924  	struct hpi_message hm;
925  	struct hpi_response hr;
926  
927  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
928  		HPI_ISTREAM_READ);
929  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
930  		return HPI_ERROR_INVALID_HANDLE;
931  	hm.u.d.u.data.data_size = bytes_to_read;
932  	hm.u.d.u.data.pb_data = pb_data;
933  
934  	hpi_send_recv(&hm, &hr);
935  
936  	return hr.error;
937  }
938  
hpi_instream_start(u32 h_instream)939  u16 hpi_instream_start(u32 h_instream)
940  {
941  	struct hpi_message hm;
942  	struct hpi_response hr;
943  
944  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
945  		HPI_ISTREAM_START);
946  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
947  		return HPI_ERROR_INVALID_HANDLE;
948  
949  	hpi_send_recv(&hm, &hr);
950  
951  	return hr.error;
952  }
953  
hpi_instream_wait_start(u32 h_instream)954  u16 hpi_instream_wait_start(u32 h_instream)
955  {
956  	struct hpi_message hm;
957  	struct hpi_response hr;
958  
959  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
960  		HPI_ISTREAM_WAIT_START);
961  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
962  		return HPI_ERROR_INVALID_HANDLE;
963  
964  	hpi_send_recv(&hm, &hr);
965  
966  	return hr.error;
967  }
968  
hpi_instream_stop(u32 h_instream)969  u16 hpi_instream_stop(u32 h_instream)
970  {
971  	struct hpi_message hm;
972  	struct hpi_response hr;
973  
974  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
975  		HPI_ISTREAM_STOP);
976  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
977  		return HPI_ERROR_INVALID_HANDLE;
978  
979  	hpi_send_recv(&hm, &hr);
980  
981  	return hr.error;
982  }
983  
hpi_instream_reset(u32 h_instream)984  u16 hpi_instream_reset(u32 h_instream)
985  {
986  	struct hpi_message hm;
987  	struct hpi_response hr;
988  
989  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
990  		HPI_ISTREAM_RESET);
991  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
992  		return HPI_ERROR_INVALID_HANDLE;
993  
994  	hpi_send_recv(&hm, &hr);
995  
996  	return hr.error;
997  }
998  
hpi_instream_get_info_ex(u32 h_instream,u16 * pw_state,u32 * pbuffer_size,u32 * pdata_recorded,u32 * psamples_recorded,u32 * pauxiliary_data_recorded)999  u16 hpi_instream_get_info_ex(u32 h_instream, u16 *pw_state, u32 *pbuffer_size,
1000  	u32 *pdata_recorded, u32 *psamples_recorded,
1001  	u32 *pauxiliary_data_recorded)
1002  {
1003  	struct hpi_message hm;
1004  	struct hpi_response hr;
1005  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
1006  		HPI_ISTREAM_GET_INFO);
1007  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
1008  		return HPI_ERROR_INVALID_HANDLE;
1009  
1010  	hpi_send_recv(&hm, &hr);
1011  
1012  	if (pw_state)
1013  		*pw_state = hr.u.d.u.stream_info.state;
1014  	if (pbuffer_size)
1015  		*pbuffer_size = hr.u.d.u.stream_info.buffer_size;
1016  	if (pdata_recorded)
1017  		*pdata_recorded = hr.u.d.u.stream_info.data_available;
1018  	if (psamples_recorded)
1019  		*psamples_recorded = hr.u.d.u.stream_info.samples_transferred;
1020  	if (pauxiliary_data_recorded)
1021  		*pauxiliary_data_recorded =
1022  			hr.u.d.u.stream_info.auxiliary_data_available;
1023  	return hr.error;
1024  }
1025  
hpi_instream_ancillary_reset(u32 h_instream,u16 bytes_per_frame,u16 mode,u16 alignment,u16 idle_bit)1026  u16 hpi_instream_ancillary_reset(u32 h_instream, u16 bytes_per_frame,
1027  	u16 mode, u16 alignment, u16 idle_bit)
1028  {
1029  	struct hpi_message hm;
1030  	struct hpi_response hr;
1031  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
1032  		HPI_ISTREAM_ANC_RESET);
1033  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
1034  		return HPI_ERROR_INVALID_HANDLE;
1035  	hm.u.d.u.data.format.attributes = bytes_per_frame;
1036  	hm.u.d.u.data.format.format = (mode << 8) | (alignment & 0xff);
1037  	hm.u.d.u.data.format.channels = idle_bit;
1038  	hpi_send_recv(&hm, &hr);
1039  	return hr.error;
1040  }
1041  
hpi_instream_ancillary_get_info(u32 h_instream,u32 * pframe_space)1042  u16 hpi_instream_ancillary_get_info(u32 h_instream, u32 *pframe_space)
1043  {
1044  	struct hpi_message hm;
1045  	struct hpi_response hr;
1046  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
1047  		HPI_ISTREAM_ANC_GET_INFO);
1048  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
1049  		return HPI_ERROR_INVALID_HANDLE;
1050  	hpi_send_recv(&hm, &hr);
1051  	if (pframe_space)
1052  		*pframe_space =
1053  			(hr.u.d.u.stream_info.buffer_size -
1054  			hr.u.d.u.stream_info.data_available) /
1055  			sizeof(struct hpi_anc_frame);
1056  	return hr.error;
1057  }
1058  
hpi_instream_ancillary_write(u32 h_instream,const struct hpi_anc_frame * p_anc_frame_buffer,u32 anc_frame_buffer_size_in_bytes,u32 number_of_ancillary_frames_to_write)1059  u16 hpi_instream_ancillary_write(u32 h_instream,
1060  	const struct hpi_anc_frame *p_anc_frame_buffer,
1061  	u32 anc_frame_buffer_size_in_bytes,
1062  	u32 number_of_ancillary_frames_to_write)
1063  {
1064  	struct hpi_message hm;
1065  	struct hpi_response hr;
1066  
1067  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
1068  		HPI_ISTREAM_ANC_WRITE);
1069  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
1070  		return HPI_ERROR_INVALID_HANDLE;
1071  	hm.u.d.u.data.pb_data = (u8 *)p_anc_frame_buffer;
1072  	hm.u.d.u.data.data_size =
1073  		number_of_ancillary_frames_to_write *
1074  		sizeof(struct hpi_anc_frame);
1075  	if (hm.u.d.u.data.data_size <= anc_frame_buffer_size_in_bytes)
1076  		hpi_send_recv(&hm, &hr);
1077  	else
1078  		hr.error = HPI_ERROR_INVALID_DATASIZE;
1079  	return hr.error;
1080  }
1081  
hpi_instream_host_buffer_allocate(u32 h_instream,u32 size_in_bytes)1082  u16 hpi_instream_host_buffer_allocate(u32 h_instream, u32 size_in_bytes)
1083  {
1084  
1085  	struct hpi_message hm;
1086  	struct hpi_response hr;
1087  
1088  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
1089  		HPI_ISTREAM_HOSTBUFFER_ALLOC);
1090  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
1091  		return HPI_ERROR_INVALID_HANDLE;
1092  	hm.u.d.u.data.data_size = size_in_bytes;
1093  	hpi_send_recv(&hm, &hr);
1094  	return hr.error;
1095  }
1096  
hpi_instream_host_buffer_get_info(u32 h_instream,u8 ** pp_buffer,struct hpi_hostbuffer_status ** pp_status)1097  u16 hpi_instream_host_buffer_get_info(u32 h_instream, u8 **pp_buffer,
1098  	struct hpi_hostbuffer_status **pp_status)
1099  {
1100  	struct hpi_message hm;
1101  	struct hpi_response hr;
1102  
1103  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
1104  		HPI_ISTREAM_HOSTBUFFER_GET_INFO);
1105  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
1106  		return HPI_ERROR_INVALID_HANDLE;
1107  	hpi_send_recv(&hm, &hr);
1108  
1109  	if (hr.error == 0) {
1110  		if (pp_buffer)
1111  			*pp_buffer = hr.u.d.u.hostbuffer_info.p_buffer;
1112  		if (pp_status)
1113  			*pp_status = hr.u.d.u.hostbuffer_info.p_status;
1114  	}
1115  	return hr.error;
1116  }
1117  
hpi_instream_host_buffer_free(u32 h_instream)1118  u16 hpi_instream_host_buffer_free(u32 h_instream)
1119  {
1120  
1121  	struct hpi_message hm;
1122  	struct hpi_response hr;
1123  
1124  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
1125  		HPI_ISTREAM_HOSTBUFFER_FREE);
1126  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
1127  		return HPI_ERROR_INVALID_HANDLE;
1128  	hpi_send_recv(&hm, &hr);
1129  	return hr.error;
1130  }
1131  
hpi_instream_group_add(u32 h_instream,u32 h_stream)1132  u16 hpi_instream_group_add(u32 h_instream, u32 h_stream)
1133  {
1134  	struct hpi_message hm;
1135  	struct hpi_response hr;
1136  	u16 adapter;
1137  	char c_obj_type;
1138  
1139  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
1140  		HPI_ISTREAM_GROUP_ADD);
1141  	hr.error = 0;
1142  
1143  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
1144  		return HPI_ERROR_INVALID_HANDLE;
1145  
1146  	if (hpi_handle_indexes(h_stream, &adapter,
1147  			&hm.u.d.u.stream.stream_index))
1148  		return HPI_ERROR_INVALID_HANDLE;
1149  
1150  	c_obj_type = hpi_handle_object(h_stream);
1151  
1152  	switch (c_obj_type) {
1153  	case HPI_OBJ_OSTREAM:
1154  	case HPI_OBJ_ISTREAM:
1155  		hm.u.d.u.stream.object_type = c_obj_type;
1156  		break;
1157  	default:
1158  		return HPI_ERROR_INVALID_OBJ;
1159  	}
1160  
1161  	if (adapter != hm.adapter_index)
1162  		return HPI_ERROR_NO_INTERADAPTER_GROUPS;
1163  
1164  	hpi_send_recv(&hm, &hr);
1165  	return hr.error;
1166  }
1167  
hpi_instream_group_get_map(u32 h_instream,u32 * poutstream_map,u32 * pinstream_map)1168  u16 hpi_instream_group_get_map(u32 h_instream, u32 *poutstream_map,
1169  	u32 *pinstream_map)
1170  {
1171  	struct hpi_message hm;
1172  	struct hpi_response hr;
1173  
1174  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
1175  		HPI_ISTREAM_HOSTBUFFER_FREE);
1176  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
1177  		return HPI_ERROR_INVALID_HANDLE;
1178  	hpi_send_recv(&hm, &hr);
1179  
1180  	if (poutstream_map)
1181  		*poutstream_map = hr.u.d.u.group_info.outstream_group_map;
1182  	if (pinstream_map)
1183  		*pinstream_map = hr.u.d.u.group_info.instream_group_map;
1184  
1185  	return hr.error;
1186  }
1187  
hpi_instream_group_reset(u32 h_instream)1188  u16 hpi_instream_group_reset(u32 h_instream)
1189  {
1190  	struct hpi_message hm;
1191  	struct hpi_response hr;
1192  
1193  	hpi_init_message_response(&hm, &hr, HPI_OBJ_ISTREAM,
1194  		HPI_ISTREAM_GROUP_RESET);
1195  	if (hpi_handle_indexes(h_instream, &hm.adapter_index, &hm.obj_index))
1196  		return HPI_ERROR_INVALID_HANDLE;
1197  	hpi_send_recv(&hm, &hr);
1198  	return hr.error;
1199  }
1200  
hpi_mixer_open(u16 adapter_index,u32 * ph_mixer)1201  u16 hpi_mixer_open(u16 adapter_index, u32 *ph_mixer)
1202  {
1203  	struct hpi_message hm;
1204  	struct hpi_response hr;
1205  	hpi_init_message_response(&hm, &hr, HPI_OBJ_MIXER, HPI_MIXER_OPEN);
1206  	hm.adapter_index = adapter_index;
1207  
1208  	hpi_send_recv(&hm, &hr);
1209  
1210  	if (hr.error == 0)
1211  		*ph_mixer =
1212  			hpi_indexes_to_handle(HPI_OBJ_MIXER, adapter_index,
1213  			0);
1214  	else
1215  		*ph_mixer = 0;
1216  	return hr.error;
1217  }
1218  
hpi_mixer_close(u32 h_mixer)1219  u16 hpi_mixer_close(u32 h_mixer)
1220  {
1221  	struct hpi_message hm;
1222  	struct hpi_response hr;
1223  
1224  	hpi_init_message_response(&hm, &hr, HPI_OBJ_MIXER, HPI_MIXER_CLOSE);
1225  	if (hpi_handle_indexes(h_mixer, &hm.adapter_index, NULL))
1226  		return HPI_ERROR_INVALID_HANDLE;
1227  
1228  	hpi_send_recv(&hm, &hr);
1229  	return hr.error;
1230  }
1231  
hpi_mixer_get_control(u32 h_mixer,u16 src_node_type,u16 src_node_type_index,u16 dst_node_type,u16 dst_node_type_index,u16 control_type,u32 * ph_control)1232  u16 hpi_mixer_get_control(u32 h_mixer, u16 src_node_type,
1233  	u16 src_node_type_index, u16 dst_node_type, u16 dst_node_type_index,
1234  	u16 control_type, u32 *ph_control)
1235  {
1236  	struct hpi_message hm;
1237  	struct hpi_response hr;
1238  	hpi_init_message_response(&hm, &hr, HPI_OBJ_MIXER,
1239  		HPI_MIXER_GET_CONTROL);
1240  	if (hpi_handle_indexes(h_mixer, &hm.adapter_index, NULL))
1241  		return HPI_ERROR_INVALID_HANDLE;
1242  	hm.u.m.node_type1 = src_node_type;
1243  	hm.u.m.node_index1 = src_node_type_index;
1244  	hm.u.m.node_type2 = dst_node_type;
1245  	hm.u.m.node_index2 = dst_node_type_index;
1246  	hm.u.m.control_type = control_type;
1247  
1248  	hpi_send_recv(&hm, &hr);
1249  
1250  	if (hr.error == 0)
1251  		*ph_control =
1252  			hpi_indexes_to_handle(HPI_OBJ_CONTROL,
1253  			hm.adapter_index, hr.u.m.control_index);
1254  	else
1255  		*ph_control = 0;
1256  	return hr.error;
1257  }
1258  
hpi_mixer_get_control_by_index(u32 h_mixer,u16 control_index,u16 * pw_src_node_type,u16 * pw_src_node_index,u16 * pw_dst_node_type,u16 * pw_dst_node_index,u16 * pw_control_type,u32 * ph_control)1259  u16 hpi_mixer_get_control_by_index(u32 h_mixer, u16 control_index,
1260  	u16 *pw_src_node_type, u16 *pw_src_node_index, u16 *pw_dst_node_type,
1261  	u16 *pw_dst_node_index, u16 *pw_control_type, u32 *ph_control)
1262  {
1263  	struct hpi_message hm;
1264  	struct hpi_response hr;
1265  	hpi_init_message_response(&hm, &hr, HPI_OBJ_MIXER,
1266  		HPI_MIXER_GET_CONTROL_BY_INDEX);
1267  	if (hpi_handle_indexes(h_mixer, &hm.adapter_index, NULL))
1268  		return HPI_ERROR_INVALID_HANDLE;
1269  	hm.u.m.control_index = control_index;
1270  	hpi_send_recv(&hm, &hr);
1271  
1272  	if (pw_src_node_type) {
1273  		*pw_src_node_type =
1274  			hr.u.m.src_node_type + HPI_SOURCENODE_NONE;
1275  		*pw_src_node_index = hr.u.m.src_node_index;
1276  		*pw_dst_node_type = hr.u.m.dst_node_type + HPI_DESTNODE_NONE;
1277  		*pw_dst_node_index = hr.u.m.dst_node_index;
1278  	}
1279  	if (pw_control_type)
1280  		*pw_control_type = hr.u.m.control_index;
1281  
1282  	if (ph_control) {
1283  		if (hr.error == 0)
1284  			*ph_control =
1285  				hpi_indexes_to_handle(HPI_OBJ_CONTROL,
1286  				hm.adapter_index, control_index);
1287  		else
1288  			*ph_control = 0;
1289  	}
1290  	return hr.error;
1291  }
1292  
hpi_mixer_store(u32 h_mixer,enum HPI_MIXER_STORE_COMMAND command,u16 index)1293  u16 hpi_mixer_store(u32 h_mixer, enum HPI_MIXER_STORE_COMMAND command,
1294  	u16 index)
1295  {
1296  	struct hpi_message hm;
1297  	struct hpi_response hr;
1298  	hpi_init_message_response(&hm, &hr, HPI_OBJ_MIXER, HPI_MIXER_STORE);
1299  	if (hpi_handle_indexes(h_mixer, &hm.adapter_index, NULL))
1300  		return HPI_ERROR_INVALID_HANDLE;
1301  	hm.u.mx.store.command = command;
1302  	hm.u.mx.store.index = index;
1303  	hpi_send_recv(&hm, &hr);
1304  	return hr.error;
1305  }
1306  
1307  static
hpi_control_param_set(const u32 h_control,const u16 attrib,const u32 param1,const u32 param2)1308  u16 hpi_control_param_set(const u32 h_control, const u16 attrib,
1309  	const u32 param1, const u32 param2)
1310  {
1311  	struct hpi_message hm;
1312  	struct hpi_response hr;
1313  
1314  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1315  		HPI_CONTROL_SET_STATE);
1316  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1317  		return HPI_ERROR_INVALID_HANDLE;
1318  	hm.u.c.attribute = attrib;
1319  	hm.u.c.param1 = param1;
1320  	hm.u.c.param2 = param2;
1321  	hpi_send_recv(&hm, &hr);
1322  	return hr.error;
1323  }
1324  
hpi_control_log_set2(u32 h_control,u16 attrib,short sv0,short sv1)1325  static u16 hpi_control_log_set2(u32 h_control, u16 attrib, short sv0,
1326  	short sv1)
1327  {
1328  	struct hpi_message hm;
1329  	struct hpi_response hr;
1330  
1331  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1332  		HPI_CONTROL_SET_STATE);
1333  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1334  		return HPI_ERROR_INVALID_HANDLE;
1335  	hm.u.c.attribute = attrib;
1336  	hm.u.c.an_log_value[0] = sv0;
1337  	hm.u.c.an_log_value[1] = sv1;
1338  	hpi_send_recv(&hm, &hr);
1339  	return hr.error;
1340  }
1341  
1342  static
hpi_control_param_get(const u32 h_control,const u16 attrib,u32 param1,u32 param2,u32 * pparam1,u32 * pparam2)1343  u16 hpi_control_param_get(const u32 h_control, const u16 attrib, u32 param1,
1344  	u32 param2, u32 *pparam1, u32 *pparam2)
1345  {
1346  	struct hpi_message hm;
1347  	struct hpi_response hr;
1348  
1349  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1350  		HPI_CONTROL_GET_STATE);
1351  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1352  		return HPI_ERROR_INVALID_HANDLE;
1353  	hm.u.c.attribute = attrib;
1354  	hm.u.c.param1 = param1;
1355  	hm.u.c.param2 = param2;
1356  	hpi_send_recv(&hm, &hr);
1357  
1358  	*pparam1 = hr.u.c.param1;
1359  	if (pparam2)
1360  		*pparam2 = hr.u.c.param2;
1361  
1362  	return hr.error;
1363  }
1364  
1365  #define hpi_control_param1_get(h, a, p1) \
1366  		hpi_control_param_get(h, a, 0, 0, p1, NULL)
1367  #define hpi_control_param2_get(h, a, p1, p2) \
1368  		hpi_control_param_get(h, a, 0, 0, p1, p2)
1369  
hpi_control_log_get2(u32 h_control,u16 attrib,short * sv0,short * sv1)1370  static u16 hpi_control_log_get2(u32 h_control, u16 attrib, short *sv0,
1371  	short *sv1)
1372  {
1373  	struct hpi_message hm;
1374  	struct hpi_response hr;
1375  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1376  		HPI_CONTROL_GET_STATE);
1377  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1378  		return HPI_ERROR_INVALID_HANDLE;
1379  	hm.u.c.attribute = attrib;
1380  
1381  	hpi_send_recv(&hm, &hr);
1382  	*sv0 = hr.u.c.an_log_value[0];
1383  	if (sv1)
1384  		*sv1 = hr.u.c.an_log_value[1];
1385  	return hr.error;
1386  }
1387  
1388  static
hpi_control_query(const u32 h_control,const u16 attrib,const u32 index,const u32 param,u32 * psetting)1389  u16 hpi_control_query(const u32 h_control, const u16 attrib, const u32 index,
1390  	const u32 param, u32 *psetting)
1391  {
1392  	struct hpi_message hm;
1393  	struct hpi_response hr;
1394  
1395  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1396  		HPI_CONTROL_GET_INFO);
1397  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1398  		return HPI_ERROR_INVALID_HANDLE;
1399  
1400  	hm.u.c.attribute = attrib;
1401  	hm.u.c.param1 = index;
1402  	hm.u.c.param2 = param;
1403  
1404  	hpi_send_recv(&hm, &hr);
1405  	*psetting = hr.u.c.param1;
1406  
1407  	return hr.error;
1408  }
1409  
hpi_control_get_string(const u32 h_control,const u16 attribute,char * psz_string,const u32 string_length)1410  static u16 hpi_control_get_string(const u32 h_control, const u16 attribute,
1411  	char *psz_string, const u32 string_length)
1412  {
1413  	unsigned int sub_string_index = 0, j = 0;
1414  	char c = 0;
1415  	unsigned int n = 0;
1416  	u16 err = 0;
1417  
1418  	if ((string_length < 1) || (string_length > 256))
1419  		return HPI_ERROR_INVALID_CONTROL_VALUE;
1420  	for (sub_string_index = 0; sub_string_index < string_length;
1421  		sub_string_index += 8) {
1422  		struct hpi_message hm;
1423  		struct hpi_response hr;
1424  
1425  		hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1426  			HPI_CONTROL_GET_STATE);
1427  		if (hpi_handle_indexes(h_control, &hm.adapter_index,
1428  				&hm.obj_index))
1429  			return HPI_ERROR_INVALID_HANDLE;
1430  		hm.u.c.attribute = attribute;
1431  		hm.u.c.param1 = sub_string_index;
1432  		hm.u.c.param2 = 0;
1433  		hpi_send_recv(&hm, &hr);
1434  
1435  		if (sub_string_index == 0
1436  			&& (hr.u.cu.chars8.remaining_chars + 8) >
1437  			string_length)
1438  			return HPI_ERROR_INVALID_CONTROL_VALUE;
1439  
1440  		if (hr.error) {
1441  			err = hr.error;
1442  			break;
1443  		}
1444  		for (j = 0; j < 8; j++) {
1445  			c = hr.u.cu.chars8.sz_data[j];
1446  			psz_string[sub_string_index + j] = c;
1447  			n++;
1448  			if (n >= string_length) {
1449  				psz_string[string_length - 1] = 0;
1450  				err = HPI_ERROR_INVALID_CONTROL_VALUE;
1451  				break;
1452  			}
1453  			if (c == 0)
1454  				break;
1455  		}
1456  
1457  		if ((hr.u.cu.chars8.remaining_chars == 0)
1458  			&& ((sub_string_index + j) < string_length)
1459  			&& (c != 0)) {
1460  			c = 0;
1461  			psz_string[sub_string_index + j] = c;
1462  		}
1463  		if (c == 0)
1464  			break;
1465  	}
1466  	return err;
1467  }
1468  
hpi_aesebu_receiver_query_format(const u32 h_aes_rx,const u32 index,u16 * pw_format)1469  u16 hpi_aesebu_receiver_query_format(const u32 h_aes_rx, const u32 index,
1470  	u16 *pw_format)
1471  {
1472  	u32 qr;
1473  	u16 err;
1474  
1475  	err = hpi_control_query(h_aes_rx, HPI_AESEBURX_FORMAT, index, 0, &qr);
1476  	*pw_format = (u16)qr;
1477  	return err;
1478  }
1479  
hpi_aesebu_receiver_set_format(u32 h_control,u16 format)1480  u16 hpi_aesebu_receiver_set_format(u32 h_control, u16 format)
1481  {
1482  	return hpi_control_param_set(h_control, HPI_AESEBURX_FORMAT, format,
1483  		0);
1484  }
1485  
hpi_aesebu_receiver_get_format(u32 h_control,u16 * pw_format)1486  u16 hpi_aesebu_receiver_get_format(u32 h_control, u16 *pw_format)
1487  {
1488  	u16 err;
1489  	u32 param;
1490  
1491  	err = hpi_control_param1_get(h_control, HPI_AESEBURX_FORMAT, &param);
1492  	if (!err && pw_format)
1493  		*pw_format = (u16)param;
1494  
1495  	return err;
1496  }
1497  
hpi_aesebu_receiver_get_sample_rate(u32 h_control,u32 * psample_rate)1498  u16 hpi_aesebu_receiver_get_sample_rate(u32 h_control, u32 *psample_rate)
1499  {
1500  	return hpi_control_param1_get(h_control, HPI_AESEBURX_SAMPLERATE,
1501  		psample_rate);
1502  }
1503  
hpi_aesebu_receiver_get_user_data(u32 h_control,u16 index,u16 * pw_data)1504  u16 hpi_aesebu_receiver_get_user_data(u32 h_control, u16 index, u16 *pw_data)
1505  {
1506  	struct hpi_message hm;
1507  	struct hpi_response hr;
1508  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1509  		HPI_CONTROL_GET_STATE);
1510  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1511  		return HPI_ERROR_INVALID_HANDLE;
1512  	hm.u.c.attribute = HPI_AESEBURX_USERDATA;
1513  	hm.u.c.param1 = index;
1514  
1515  	hpi_send_recv(&hm, &hr);
1516  
1517  	if (pw_data)
1518  		*pw_data = (u16)hr.u.c.param2;
1519  	return hr.error;
1520  }
1521  
hpi_aesebu_receiver_get_channel_status(u32 h_control,u16 index,u16 * pw_data)1522  u16 hpi_aesebu_receiver_get_channel_status(u32 h_control, u16 index,
1523  	u16 *pw_data)
1524  {
1525  	struct hpi_message hm;
1526  	struct hpi_response hr;
1527  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1528  		HPI_CONTROL_GET_STATE);
1529  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1530  		return HPI_ERROR_INVALID_HANDLE;
1531  	hm.u.c.attribute = HPI_AESEBURX_CHANNELSTATUS;
1532  	hm.u.c.param1 = index;
1533  
1534  	hpi_send_recv(&hm, &hr);
1535  
1536  	if (pw_data)
1537  		*pw_data = (u16)hr.u.c.param2;
1538  	return hr.error;
1539  }
1540  
hpi_aesebu_receiver_get_error_status(u32 h_control,u16 * pw_error_data)1541  u16 hpi_aesebu_receiver_get_error_status(u32 h_control, u16 *pw_error_data)
1542  {
1543  	u32 error_data = 0;
1544  	u16 err = 0;
1545  
1546  	err = hpi_control_param1_get(h_control, HPI_AESEBURX_ERRORSTATUS,
1547  		&error_data);
1548  	if (pw_error_data)
1549  		*pw_error_data = (u16)error_data;
1550  	return err;
1551  }
1552  
hpi_aesebu_transmitter_set_sample_rate(u32 h_control,u32 sample_rate)1553  u16 hpi_aesebu_transmitter_set_sample_rate(u32 h_control, u32 sample_rate)
1554  {
1555  	return hpi_control_param_set(h_control, HPI_AESEBUTX_SAMPLERATE,
1556  		sample_rate, 0);
1557  }
1558  
hpi_aesebu_transmitter_set_user_data(u32 h_control,u16 index,u16 data)1559  u16 hpi_aesebu_transmitter_set_user_data(u32 h_control, u16 index, u16 data)
1560  {
1561  	return hpi_control_param_set(h_control, HPI_AESEBUTX_USERDATA, index,
1562  		data);
1563  }
1564  
hpi_aesebu_transmitter_set_channel_status(u32 h_control,u16 index,u16 data)1565  u16 hpi_aesebu_transmitter_set_channel_status(u32 h_control, u16 index,
1566  	u16 data)
1567  {
1568  	return hpi_control_param_set(h_control, HPI_AESEBUTX_CHANNELSTATUS,
1569  		index, data);
1570  }
1571  
hpi_aesebu_transmitter_get_channel_status(u32 h_control,u16 index,u16 * pw_data)1572  u16 hpi_aesebu_transmitter_get_channel_status(u32 h_control, u16 index,
1573  	u16 *pw_data)
1574  {
1575  	return HPI_ERROR_INVALID_OPERATION;
1576  }
1577  
hpi_aesebu_transmitter_query_format(const u32 h_aes_tx,const u32 index,u16 * pw_format)1578  u16 hpi_aesebu_transmitter_query_format(const u32 h_aes_tx, const u32 index,
1579  	u16 *pw_format)
1580  {
1581  	u32 qr;
1582  	u16 err;
1583  
1584  	err = hpi_control_query(h_aes_tx, HPI_AESEBUTX_FORMAT, index, 0, &qr);
1585  	*pw_format = (u16)qr;
1586  	return err;
1587  }
1588  
hpi_aesebu_transmitter_set_format(u32 h_control,u16 output_format)1589  u16 hpi_aesebu_transmitter_set_format(u32 h_control, u16 output_format)
1590  {
1591  	return hpi_control_param_set(h_control, HPI_AESEBUTX_FORMAT,
1592  		output_format, 0);
1593  }
1594  
hpi_aesebu_transmitter_get_format(u32 h_control,u16 * pw_output_format)1595  u16 hpi_aesebu_transmitter_get_format(u32 h_control, u16 *pw_output_format)
1596  {
1597  	u16 err;
1598  	u32 param;
1599  
1600  	err = hpi_control_param1_get(h_control, HPI_AESEBUTX_FORMAT, &param);
1601  	if (!err && pw_output_format)
1602  		*pw_output_format = (u16)param;
1603  
1604  	return err;
1605  }
1606  
hpi_bitstream_set_clock_edge(u32 h_control,u16 edge_type)1607  u16 hpi_bitstream_set_clock_edge(u32 h_control, u16 edge_type)
1608  {
1609  	return hpi_control_param_set(h_control, HPI_BITSTREAM_CLOCK_EDGE,
1610  		edge_type, 0);
1611  }
1612  
hpi_bitstream_set_data_polarity(u32 h_control,u16 polarity)1613  u16 hpi_bitstream_set_data_polarity(u32 h_control, u16 polarity)
1614  {
1615  	return hpi_control_param_set(h_control, HPI_BITSTREAM_DATA_POLARITY,
1616  		polarity, 0);
1617  }
1618  
hpi_bitstream_get_activity(u32 h_control,u16 * pw_clk_activity,u16 * pw_data_activity)1619  u16 hpi_bitstream_get_activity(u32 h_control, u16 *pw_clk_activity,
1620  	u16 *pw_data_activity)
1621  {
1622  	struct hpi_message hm;
1623  	struct hpi_response hr;
1624  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1625  		HPI_CONTROL_GET_STATE);
1626  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1627  		return HPI_ERROR_INVALID_HANDLE;
1628  	hm.u.c.attribute = HPI_BITSTREAM_ACTIVITY;
1629  	hpi_send_recv(&hm, &hr);
1630  	if (pw_clk_activity)
1631  		*pw_clk_activity = (u16)hr.u.c.param1;
1632  	if (pw_data_activity)
1633  		*pw_data_activity = (u16)hr.u.c.param2;
1634  	return hr.error;
1635  }
1636  
hpi_channel_mode_query_mode(const u32 h_mode,const u32 index,u16 * pw_mode)1637  u16 hpi_channel_mode_query_mode(const u32 h_mode, const u32 index,
1638  	u16 *pw_mode)
1639  {
1640  	u32 qr;
1641  	u16 err;
1642  
1643  	err = hpi_control_query(h_mode, HPI_CHANNEL_MODE_MODE, index, 0, &qr);
1644  	*pw_mode = (u16)qr;
1645  	return err;
1646  }
1647  
hpi_channel_mode_set(u32 h_control,u16 mode)1648  u16 hpi_channel_mode_set(u32 h_control, u16 mode)
1649  {
1650  	return hpi_control_param_set(h_control, HPI_CHANNEL_MODE_MODE, mode,
1651  		0);
1652  }
1653  
hpi_channel_mode_get(u32 h_control,u16 * mode)1654  u16 hpi_channel_mode_get(u32 h_control, u16 *mode)
1655  {
1656  	u32 mode32 = 0;
1657  	u16 err = hpi_control_param1_get(h_control,
1658  		HPI_CHANNEL_MODE_MODE, &mode32);
1659  	if (mode)
1660  		*mode = (u16)mode32;
1661  	return err;
1662  }
1663  
hpi_cobranet_hmi_write(u32 h_control,u32 hmi_address,u32 byte_count,u8 * pb_data)1664  u16 hpi_cobranet_hmi_write(u32 h_control, u32 hmi_address, u32 byte_count,
1665  	u8 *pb_data)
1666  {
1667  	struct hpi_msg_cobranet_hmiwrite hm;
1668  	struct hpi_response_header hr;
1669  
1670  	hpi_init_message_responseV1(&hm.h, sizeof(hm), &hr, sizeof(hr),
1671  		HPI_OBJ_CONTROL, HPI_CONTROL_SET_STATE);
1672  
1673  	if (hpi_handle_indexes(h_control, &hm.h.adapter_index,
1674  			&hm.h.obj_index))
1675  		return HPI_ERROR_INVALID_HANDLE;
1676  
1677  	if (byte_count > sizeof(hm.bytes))
1678  		return HPI_ERROR_MESSAGE_BUFFER_TOO_SMALL;
1679  
1680  	hm.p.attribute = HPI_COBRANET_SET;
1681  	hm.p.byte_count = byte_count;
1682  	hm.p.hmi_address = hmi_address;
1683  	memcpy(hm.bytes, pb_data, byte_count);
1684  	hm.h.size = (u16)(sizeof(hm.h) + sizeof(hm.p) + byte_count);
1685  
1686  	hpi_send_recvV1(&hm.h, &hr);
1687  	return hr.error;
1688  }
1689  
hpi_cobranet_hmi_read(u32 h_control,u32 hmi_address,u32 max_byte_count,u32 * pbyte_count,u8 * pb_data)1690  u16 hpi_cobranet_hmi_read(u32 h_control, u32 hmi_address, u32 max_byte_count,
1691  	u32 *pbyte_count, u8 *pb_data)
1692  {
1693  	struct hpi_msg_cobranet_hmiread hm;
1694  	struct hpi_res_cobranet_hmiread hr;
1695  
1696  	hpi_init_message_responseV1(&hm.h, sizeof(hm), &hr.h, sizeof(hr),
1697  		HPI_OBJ_CONTROL, HPI_CONTROL_GET_STATE);
1698  
1699  	if (hpi_handle_indexes(h_control, &hm.h.adapter_index,
1700  			&hm.h.obj_index))
1701  		return HPI_ERROR_INVALID_HANDLE;
1702  
1703  	if (max_byte_count > sizeof(hr.bytes))
1704  		return HPI_ERROR_RESPONSE_BUFFER_TOO_SMALL;
1705  
1706  	hm.p.attribute = HPI_COBRANET_GET;
1707  	hm.p.byte_count = max_byte_count;
1708  	hm.p.hmi_address = hmi_address;
1709  
1710  	hpi_send_recvV1(&hm.h, &hr.h);
1711  
1712  	if (!hr.h.error && pb_data) {
1713  		if (hr.byte_count > sizeof(hr.bytes))
1714  
1715  			return HPI_ERROR_RESPONSE_BUFFER_TOO_SMALL;
1716  
1717  		*pbyte_count = hr.byte_count;
1718  
1719  		if (hr.byte_count < max_byte_count)
1720  			max_byte_count = *pbyte_count;
1721  
1722  		memcpy(pb_data, hr.bytes, max_byte_count);
1723  	}
1724  	return hr.h.error;
1725  }
1726  
hpi_cobranet_hmi_get_status(u32 h_control,u32 * pstatus,u32 * preadable_size,u32 * pwriteable_size)1727  u16 hpi_cobranet_hmi_get_status(u32 h_control, u32 *pstatus,
1728  	u32 *preadable_size, u32 *pwriteable_size)
1729  {
1730  	struct hpi_message hm;
1731  	struct hpi_response hr;
1732  
1733  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1734  		HPI_CONTROL_GET_STATE);
1735  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1736  		return HPI_ERROR_INVALID_HANDLE;
1737  
1738  	hm.u.c.attribute = HPI_COBRANET_GET_STATUS;
1739  
1740  	hpi_send_recv(&hm, &hr);
1741  	if (!hr.error) {
1742  		if (pstatus)
1743  			*pstatus = hr.u.cu.cobranet.status.status;
1744  		if (preadable_size)
1745  			*preadable_size =
1746  				hr.u.cu.cobranet.status.readable_size;
1747  		if (pwriteable_size)
1748  			*pwriteable_size =
1749  				hr.u.cu.cobranet.status.writeable_size;
1750  	}
1751  	return hr.error;
1752  }
1753  
hpi_cobranet_get_ip_address(u32 h_control,u32 * pdw_ip_address)1754  u16 hpi_cobranet_get_ip_address(u32 h_control, u32 *pdw_ip_address)
1755  {
1756  	u32 byte_count;
1757  	u32 iP;
1758  	u16 err;
1759  
1760  	err = hpi_cobranet_hmi_read(h_control,
1761  		HPI_COBRANET_HMI_cobra_ip_mon_currentIP, 4, &byte_count,
1762  		(u8 *)&iP);
1763  
1764  	*pdw_ip_address =
1765  		((iP & 0xff000000) >> 8) | ((iP & 0x00ff0000) << 8) | ((iP &
1766  			0x0000ff00) >> 8) | ((iP & 0x000000ff) << 8);
1767  
1768  	if (err)
1769  		*pdw_ip_address = 0;
1770  
1771  	return err;
1772  
1773  }
1774  
hpi_cobranet_set_ip_address(u32 h_control,u32 dw_ip_address)1775  u16 hpi_cobranet_set_ip_address(u32 h_control, u32 dw_ip_address)
1776  {
1777  	u32 iP;
1778  	u16 err;
1779  
1780  	iP = ((dw_ip_address & 0xff000000) >> 8) | ((dw_ip_address &
1781  			0x00ff0000) << 8) | ((dw_ip_address & 0x0000ff00) >>
1782  		8) | ((dw_ip_address & 0x000000ff) << 8);
1783  
1784  	err = hpi_cobranet_hmi_write(h_control,
1785  		HPI_COBRANET_HMI_cobra_ip_mon_currentIP, 4, (u8 *)&iP);
1786  
1787  	return err;
1788  
1789  }
1790  
hpi_cobranet_get_static_ip_address(u32 h_control,u32 * pdw_ip_address)1791  u16 hpi_cobranet_get_static_ip_address(u32 h_control, u32 *pdw_ip_address)
1792  {
1793  	u32 byte_count;
1794  	u32 iP;
1795  	u16 err;
1796  	err = hpi_cobranet_hmi_read(h_control,
1797  		HPI_COBRANET_HMI_cobra_ip_mon_staticIP, 4, &byte_count,
1798  		(u8 *)&iP);
1799  
1800  	*pdw_ip_address =
1801  		((iP & 0xff000000) >> 8) | ((iP & 0x00ff0000) << 8) | ((iP &
1802  			0x0000ff00) >> 8) | ((iP & 0x000000ff) << 8);
1803  
1804  	if (err)
1805  		*pdw_ip_address = 0;
1806  
1807  	return err;
1808  
1809  }
1810  
hpi_cobranet_set_static_ip_address(u32 h_control,u32 dw_ip_address)1811  u16 hpi_cobranet_set_static_ip_address(u32 h_control, u32 dw_ip_address)
1812  {
1813  	u32 iP;
1814  	u16 err;
1815  
1816  	iP = ((dw_ip_address & 0xff000000) >> 8) | ((dw_ip_address &
1817  			0x00ff0000) << 8) | ((dw_ip_address & 0x0000ff00) >>
1818  		8) | ((dw_ip_address & 0x000000ff) << 8);
1819  
1820  	err = hpi_cobranet_hmi_write(h_control,
1821  		HPI_COBRANET_HMI_cobra_ip_mon_staticIP, 4, (u8 *)&iP);
1822  
1823  	return err;
1824  
1825  }
1826  
hpi_cobranet_get_macaddress(u32 h_control,u32 * p_mac_msbs,u32 * p_mac_lsbs)1827  u16 hpi_cobranet_get_macaddress(u32 h_control, u32 *p_mac_msbs,
1828  	u32 *p_mac_lsbs)
1829  {
1830  	u32 byte_count;
1831  	u16 err;
1832  	u32 mac;
1833  
1834  	err = hpi_cobranet_hmi_read(h_control,
1835  		HPI_COBRANET_HMI_cobra_if_phy_address, 4, &byte_count,
1836  		(u8 *)&mac);
1837  
1838  	if (!err) {
1839  		*p_mac_msbs =
1840  			((mac & 0xff000000) >> 8) | ((mac & 0x00ff0000) << 8)
1841  			| ((mac & 0x0000ff00) >> 8) | ((mac & 0x000000ff) <<
1842  			8);
1843  
1844  		err = hpi_cobranet_hmi_read(h_control,
1845  			HPI_COBRANET_HMI_cobra_if_phy_address + 1, 4,
1846  			&byte_count, (u8 *)&mac);
1847  	}
1848  
1849  	if (!err) {
1850  		*p_mac_lsbs =
1851  			((mac & 0xff000000) >> 8) | ((mac & 0x00ff0000) << 8)
1852  			| ((mac & 0x0000ff00) >> 8) | ((mac & 0x000000ff) <<
1853  			8);
1854  	} else {
1855  		*p_mac_msbs = 0;
1856  		*p_mac_lsbs = 0;
1857  	}
1858  
1859  	return err;
1860  }
1861  
hpi_compander_set_enable(u32 h_control,u32 enable)1862  u16 hpi_compander_set_enable(u32 h_control, u32 enable)
1863  {
1864  	return hpi_control_param_set(h_control, HPI_GENERIC_ENABLE, enable,
1865  		0);
1866  }
1867  
hpi_compander_get_enable(u32 h_control,u32 * enable)1868  u16 hpi_compander_get_enable(u32 h_control, u32 *enable)
1869  {
1870  	return hpi_control_param1_get(h_control, HPI_GENERIC_ENABLE, enable);
1871  }
1872  
hpi_compander_set_makeup_gain(u32 h_control,short makeup_gain0_01dB)1873  u16 hpi_compander_set_makeup_gain(u32 h_control, short makeup_gain0_01dB)
1874  {
1875  	return hpi_control_log_set2(h_control, HPI_COMPANDER_MAKEUPGAIN,
1876  		makeup_gain0_01dB, 0);
1877  }
1878  
hpi_compander_get_makeup_gain(u32 h_control,short * makeup_gain0_01dB)1879  u16 hpi_compander_get_makeup_gain(u32 h_control, short *makeup_gain0_01dB)
1880  {
1881  	return hpi_control_log_get2(h_control, HPI_COMPANDER_MAKEUPGAIN,
1882  		makeup_gain0_01dB, NULL);
1883  }
1884  
hpi_compander_set_attack_time_constant(u32 h_control,unsigned int index,u32 attack)1885  u16 hpi_compander_set_attack_time_constant(u32 h_control, unsigned int index,
1886  	u32 attack)
1887  {
1888  	return hpi_control_param_set(h_control, HPI_COMPANDER_ATTACK, attack,
1889  		index);
1890  }
1891  
hpi_compander_get_attack_time_constant(u32 h_control,unsigned int index,u32 * attack)1892  u16 hpi_compander_get_attack_time_constant(u32 h_control, unsigned int index,
1893  	u32 *attack)
1894  {
1895  	return hpi_control_param_get(h_control, HPI_COMPANDER_ATTACK, 0,
1896  		index, attack, NULL);
1897  }
1898  
hpi_compander_set_decay_time_constant(u32 h_control,unsigned int index,u32 decay)1899  u16 hpi_compander_set_decay_time_constant(u32 h_control, unsigned int index,
1900  	u32 decay)
1901  {
1902  	return hpi_control_param_set(h_control, HPI_COMPANDER_DECAY, decay,
1903  		index);
1904  }
1905  
hpi_compander_get_decay_time_constant(u32 h_control,unsigned int index,u32 * decay)1906  u16 hpi_compander_get_decay_time_constant(u32 h_control, unsigned int index,
1907  	u32 *decay)
1908  {
1909  	return hpi_control_param_get(h_control, HPI_COMPANDER_DECAY, 0, index,
1910  		decay, NULL);
1911  
1912  }
1913  
hpi_compander_set_threshold(u32 h_control,unsigned int index,short threshold0_01dB)1914  u16 hpi_compander_set_threshold(u32 h_control, unsigned int index,
1915  	short threshold0_01dB)
1916  {
1917  	struct hpi_message hm;
1918  	struct hpi_response hr;
1919  
1920  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1921  		HPI_CONTROL_SET_STATE);
1922  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1923  		return HPI_ERROR_INVALID_HANDLE;
1924  	hm.u.c.attribute = HPI_COMPANDER_THRESHOLD;
1925  	hm.u.c.param2 = index;
1926  	hm.u.c.an_log_value[0] = threshold0_01dB;
1927  
1928  	hpi_send_recv(&hm, &hr);
1929  
1930  	return hr.error;
1931  }
1932  
hpi_compander_get_threshold(u32 h_control,unsigned int index,short * threshold0_01dB)1933  u16 hpi_compander_get_threshold(u32 h_control, unsigned int index,
1934  	short *threshold0_01dB)
1935  {
1936  	struct hpi_message hm;
1937  	struct hpi_response hr;
1938  
1939  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1940  		HPI_CONTROL_GET_STATE);
1941  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1942  		return HPI_ERROR_INVALID_HANDLE;
1943  	hm.u.c.attribute = HPI_COMPANDER_THRESHOLD;
1944  	hm.u.c.param2 = index;
1945  
1946  	hpi_send_recv(&hm, &hr);
1947  	*threshold0_01dB = hr.u.c.an_log_value[0];
1948  
1949  	return hr.error;
1950  }
1951  
hpi_compander_set_ratio(u32 h_control,u32 index,u32 ratio100)1952  u16 hpi_compander_set_ratio(u32 h_control, u32 index, u32 ratio100)
1953  {
1954  	return hpi_control_param_set(h_control, HPI_COMPANDER_RATIO, ratio100,
1955  		index);
1956  }
1957  
hpi_compander_get_ratio(u32 h_control,u32 index,u32 * ratio100)1958  u16 hpi_compander_get_ratio(u32 h_control, u32 index, u32 *ratio100)
1959  {
1960  	return hpi_control_param_get(h_control, HPI_COMPANDER_RATIO, 0, index,
1961  		ratio100, NULL);
1962  }
1963  
hpi_level_query_range(u32 h_control,short * min_gain_01dB,short * max_gain_01dB,short * step_gain_01dB)1964  u16 hpi_level_query_range(u32 h_control, short *min_gain_01dB,
1965  	short *max_gain_01dB, short *step_gain_01dB)
1966  {
1967  	struct hpi_message hm;
1968  	struct hpi_response hr;
1969  
1970  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
1971  		HPI_CONTROL_GET_STATE);
1972  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
1973  		return HPI_ERROR_INVALID_HANDLE;
1974  	hm.u.c.attribute = HPI_LEVEL_RANGE;
1975  
1976  	hpi_send_recv(&hm, &hr);
1977  	if (hr.error) {
1978  		hr.u.c.an_log_value[0] = 0;
1979  		hr.u.c.an_log_value[1] = 0;
1980  		hr.u.c.param1 = 0;
1981  	}
1982  	if (min_gain_01dB)
1983  		*min_gain_01dB = hr.u.c.an_log_value[0];
1984  	if (max_gain_01dB)
1985  		*max_gain_01dB = hr.u.c.an_log_value[1];
1986  	if (step_gain_01dB)
1987  		*step_gain_01dB = (short)hr.u.c.param1;
1988  	return hr.error;
1989  }
1990  
hpi_level_set_gain(u32 h_control,short an_gain0_01dB[HPI_MAX_CHANNELS])1991  u16 hpi_level_set_gain(u32 h_control, short an_gain0_01dB[HPI_MAX_CHANNELS]
1992  	)
1993  {
1994  	return hpi_control_log_set2(h_control, HPI_LEVEL_GAIN,
1995  		an_gain0_01dB[0], an_gain0_01dB[1]);
1996  }
1997  
hpi_level_get_gain(u32 h_control,short an_gain0_01dB[HPI_MAX_CHANNELS])1998  u16 hpi_level_get_gain(u32 h_control, short an_gain0_01dB[HPI_MAX_CHANNELS]
1999  	)
2000  {
2001  	return hpi_control_log_get2(h_control, HPI_LEVEL_GAIN,
2002  		&an_gain0_01dB[0], &an_gain0_01dB[1]);
2003  }
2004  
hpi_meter_query_channels(const u32 h_meter,u32 * p_channels)2005  u16 hpi_meter_query_channels(const u32 h_meter, u32 *p_channels)
2006  {
2007  	return hpi_control_query(h_meter, HPI_METER_NUM_CHANNELS, 0, 0,
2008  		p_channels);
2009  }
2010  
hpi_meter_get_peak(u32 h_control,short an_peakdB[HPI_MAX_CHANNELS])2011  u16 hpi_meter_get_peak(u32 h_control, short an_peakdB[HPI_MAX_CHANNELS]
2012  	)
2013  {
2014  	short i = 0;
2015  
2016  	struct hpi_message hm;
2017  	struct hpi_response hr;
2018  
2019  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2020  		HPI_CONTROL_GET_STATE);
2021  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2022  		return HPI_ERROR_INVALID_HANDLE;
2023  	hm.u.c.attribute = HPI_METER_PEAK;
2024  
2025  	hpi_send_recv(&hm, &hr);
2026  
2027  	if (!hr.error)
2028  		memcpy(an_peakdB, hr.u.c.an_log_value,
2029  			sizeof(short) * HPI_MAX_CHANNELS);
2030  	else
2031  		for (i = 0; i < HPI_MAX_CHANNELS; i++)
2032  			an_peakdB[i] = HPI_METER_MINIMUM;
2033  	return hr.error;
2034  }
2035  
hpi_meter_get_rms(u32 h_control,short an_rmsdB[HPI_MAX_CHANNELS])2036  u16 hpi_meter_get_rms(u32 h_control, short an_rmsdB[HPI_MAX_CHANNELS]
2037  	)
2038  {
2039  	short i = 0;
2040  
2041  	struct hpi_message hm;
2042  	struct hpi_response hr;
2043  
2044  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2045  		HPI_CONTROL_GET_STATE);
2046  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2047  		return HPI_ERROR_INVALID_HANDLE;
2048  	hm.u.c.attribute = HPI_METER_RMS;
2049  
2050  	hpi_send_recv(&hm, &hr);
2051  
2052  	if (!hr.error)
2053  		memcpy(an_rmsdB, hr.u.c.an_log_value,
2054  			sizeof(short) * HPI_MAX_CHANNELS);
2055  	else
2056  		for (i = 0; i < HPI_MAX_CHANNELS; i++)
2057  			an_rmsdB[i] = HPI_METER_MINIMUM;
2058  
2059  	return hr.error;
2060  }
2061  
hpi_meter_set_rms_ballistics(u32 h_control,u16 attack,u16 decay)2062  u16 hpi_meter_set_rms_ballistics(u32 h_control, u16 attack, u16 decay)
2063  {
2064  	return hpi_control_param_set(h_control, HPI_METER_RMS_BALLISTICS,
2065  		attack, decay);
2066  }
2067  
hpi_meter_get_rms_ballistics(u32 h_control,u16 * pn_attack,u16 * pn_decay)2068  u16 hpi_meter_get_rms_ballistics(u32 h_control, u16 *pn_attack, u16 *pn_decay)
2069  {
2070  	u32 attack;
2071  	u32 decay;
2072  	u16 error;
2073  
2074  	error = hpi_control_param2_get(h_control, HPI_METER_RMS_BALLISTICS,
2075  		&attack, &decay);
2076  
2077  	if (pn_attack)
2078  		*pn_attack = (unsigned short)attack;
2079  	if (pn_decay)
2080  		*pn_decay = (unsigned short)decay;
2081  
2082  	return error;
2083  }
2084  
hpi_meter_set_peak_ballistics(u32 h_control,u16 attack,u16 decay)2085  u16 hpi_meter_set_peak_ballistics(u32 h_control, u16 attack, u16 decay)
2086  {
2087  	return hpi_control_param_set(h_control, HPI_METER_PEAK_BALLISTICS,
2088  		attack, decay);
2089  }
2090  
hpi_meter_get_peak_ballistics(u32 h_control,u16 * pn_attack,u16 * pn_decay)2091  u16 hpi_meter_get_peak_ballistics(u32 h_control, u16 *pn_attack,
2092  	u16 *pn_decay)
2093  {
2094  	u32 attack;
2095  	u32 decay;
2096  	u16 error;
2097  
2098  	error = hpi_control_param2_get(h_control, HPI_METER_PEAK_BALLISTICS,
2099  		&attack, &decay);
2100  
2101  	if (pn_attack)
2102  		*pn_attack = (short)attack;
2103  	if (pn_decay)
2104  		*pn_decay = (short)decay;
2105  
2106  	return error;
2107  }
2108  
hpi_microphone_set_phantom_power(u32 h_control,u16 on_off)2109  u16 hpi_microphone_set_phantom_power(u32 h_control, u16 on_off)
2110  {
2111  	return hpi_control_param_set(h_control, HPI_MICROPHONE_PHANTOM_POWER,
2112  		(u32)on_off, 0);
2113  }
2114  
hpi_microphone_get_phantom_power(u32 h_control,u16 * pw_on_off)2115  u16 hpi_microphone_get_phantom_power(u32 h_control, u16 *pw_on_off)
2116  {
2117  	u16 error = 0;
2118  	u32 on_off = 0;
2119  	error = hpi_control_param1_get(h_control,
2120  		HPI_MICROPHONE_PHANTOM_POWER, &on_off);
2121  	if (pw_on_off)
2122  		*pw_on_off = (u16)on_off;
2123  	return error;
2124  }
2125  
hpi_multiplexer_set_source(u32 h_control,u16 source_node_type,u16 source_node_index)2126  u16 hpi_multiplexer_set_source(u32 h_control, u16 source_node_type,
2127  	u16 source_node_index)
2128  {
2129  	return hpi_control_param_set(h_control, HPI_MULTIPLEXER_SOURCE,
2130  		source_node_type, source_node_index);
2131  }
2132  
hpi_multiplexer_get_source(u32 h_control,u16 * source_node_type,u16 * source_node_index)2133  u16 hpi_multiplexer_get_source(u32 h_control, u16 *source_node_type,
2134  	u16 *source_node_index)
2135  {
2136  	u32 node, index;
2137  	u16 err = hpi_control_param2_get(h_control,
2138  		HPI_MULTIPLEXER_SOURCE, &node,
2139  		&index);
2140  	if (source_node_type)
2141  		*source_node_type = (u16)node;
2142  	if (source_node_index)
2143  		*source_node_index = (u16)index;
2144  	return err;
2145  }
2146  
hpi_multiplexer_query_source(u32 h_control,u16 index,u16 * source_node_type,u16 * source_node_index)2147  u16 hpi_multiplexer_query_source(u32 h_control, u16 index,
2148  	u16 *source_node_type, u16 *source_node_index)
2149  {
2150  	struct hpi_message hm;
2151  	struct hpi_response hr;
2152  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2153  		HPI_CONTROL_GET_STATE);
2154  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2155  		return HPI_ERROR_INVALID_HANDLE;
2156  	hm.u.c.attribute = HPI_MULTIPLEXER_QUERYSOURCE;
2157  	hm.u.c.param1 = index;
2158  
2159  	hpi_send_recv(&hm, &hr);
2160  
2161  	if (source_node_type)
2162  		*source_node_type = (u16)hr.u.c.param1;
2163  	if (source_node_index)
2164  		*source_node_index = (u16)hr.u.c.param2;
2165  	return hr.error;
2166  }
2167  
hpi_parametric_eq_get_info(u32 h_control,u16 * pw_number_of_bands,u16 * pw_on_off)2168  u16 hpi_parametric_eq_get_info(u32 h_control, u16 *pw_number_of_bands,
2169  	u16 *pw_on_off)
2170  {
2171  	u32 oB = 0;
2172  	u32 oO = 0;
2173  	u16 error = 0;
2174  
2175  	error = hpi_control_param2_get(h_control, HPI_EQUALIZER_NUM_FILTERS,
2176  		&oO, &oB);
2177  	if (pw_number_of_bands)
2178  		*pw_number_of_bands = (u16)oB;
2179  	if (pw_on_off)
2180  		*pw_on_off = (u16)oO;
2181  	return error;
2182  }
2183  
hpi_parametric_eq_set_state(u32 h_control,u16 on_off)2184  u16 hpi_parametric_eq_set_state(u32 h_control, u16 on_off)
2185  {
2186  	return hpi_control_param_set(h_control, HPI_EQUALIZER_NUM_FILTERS,
2187  		on_off, 0);
2188  }
2189  
hpi_parametric_eq_get_band(u32 h_control,u16 index,u16 * pn_type,u32 * pfrequency_hz,short * pnQ100,short * pn_gain0_01dB)2190  u16 hpi_parametric_eq_get_band(u32 h_control, u16 index, u16 *pn_type,
2191  	u32 *pfrequency_hz, short *pnQ100, short *pn_gain0_01dB)
2192  {
2193  	struct hpi_message hm;
2194  	struct hpi_response hr;
2195  
2196  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2197  		HPI_CONTROL_GET_STATE);
2198  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2199  		return HPI_ERROR_INVALID_HANDLE;
2200  	hm.u.c.attribute = HPI_EQUALIZER_FILTER;
2201  	hm.u.c.param2 = index;
2202  
2203  	hpi_send_recv(&hm, &hr);
2204  
2205  	if (pfrequency_hz)
2206  		*pfrequency_hz = hr.u.c.param1;
2207  	if (pn_type)
2208  		*pn_type = (u16)(hr.u.c.param2 >> 16);
2209  	if (pnQ100)
2210  		*pnQ100 = hr.u.c.an_log_value[1];
2211  	if (pn_gain0_01dB)
2212  		*pn_gain0_01dB = hr.u.c.an_log_value[0];
2213  
2214  	return hr.error;
2215  }
2216  
hpi_parametric_eq_set_band(u32 h_control,u16 index,u16 type,u32 frequency_hz,short q100,short gain0_01dB)2217  u16 hpi_parametric_eq_set_band(u32 h_control, u16 index, u16 type,
2218  	u32 frequency_hz, short q100, short gain0_01dB)
2219  {
2220  	struct hpi_message hm;
2221  	struct hpi_response hr;
2222  
2223  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2224  		HPI_CONTROL_SET_STATE);
2225  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2226  		return HPI_ERROR_INVALID_HANDLE;
2227  
2228  	hm.u.c.param1 = frequency_hz;
2229  	hm.u.c.param2 = (index & 0xFFFFL) + ((u32)type << 16);
2230  	hm.u.c.an_log_value[0] = gain0_01dB;
2231  	hm.u.c.an_log_value[1] = q100;
2232  	hm.u.c.attribute = HPI_EQUALIZER_FILTER;
2233  
2234  	hpi_send_recv(&hm, &hr);
2235  
2236  	return hr.error;
2237  }
2238  
hpi_parametric_eq_get_coeffs(u32 h_control,u16 index,short coeffs[5])2239  u16 hpi_parametric_eq_get_coeffs(u32 h_control, u16 index, short coeffs[5]
2240  	)
2241  {
2242  	struct hpi_message hm;
2243  	struct hpi_response hr;
2244  
2245  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2246  		HPI_CONTROL_GET_STATE);
2247  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2248  		return HPI_ERROR_INVALID_HANDLE;
2249  	hm.u.c.attribute = HPI_EQUALIZER_COEFFICIENTS;
2250  	hm.u.c.param2 = index;
2251  
2252  	hpi_send_recv(&hm, &hr);
2253  
2254  	coeffs[0] = (short)hr.u.c.an_log_value[0];
2255  	coeffs[1] = (short)hr.u.c.an_log_value[1];
2256  	coeffs[2] = (short)hr.u.c.param1;
2257  	coeffs[3] = (short)(hr.u.c.param1 >> 16);
2258  	coeffs[4] = (short)hr.u.c.param2;
2259  
2260  	return hr.error;
2261  }
2262  
hpi_sample_clock_query_source(const u32 h_clock,const u32 index,u16 * pw_source)2263  u16 hpi_sample_clock_query_source(const u32 h_clock, const u32 index,
2264  	u16 *pw_source)
2265  {
2266  	u32 qr;
2267  	u16 err;
2268  
2269  	err = hpi_control_query(h_clock, HPI_SAMPLECLOCK_SOURCE, index, 0,
2270  		&qr);
2271  	*pw_source = (u16)qr;
2272  	return err;
2273  }
2274  
hpi_sample_clock_set_source(u32 h_control,u16 source)2275  u16 hpi_sample_clock_set_source(u32 h_control, u16 source)
2276  {
2277  	return hpi_control_param_set(h_control, HPI_SAMPLECLOCK_SOURCE,
2278  		source, 0);
2279  }
2280  
hpi_sample_clock_get_source(u32 h_control,u16 * pw_source)2281  u16 hpi_sample_clock_get_source(u32 h_control, u16 *pw_source)
2282  {
2283  	u16 err = 0;
2284  	u32 source = 0;
2285  	err = hpi_control_param1_get(h_control, HPI_SAMPLECLOCK_SOURCE,
2286  		&source);
2287  	if (!err)
2288  		if (pw_source)
2289  			*pw_source = (u16)source;
2290  	return err;
2291  }
2292  
hpi_sample_clock_query_source_index(const u32 h_clock,const u32 index,const u32 source,u16 * pw_source_index)2293  u16 hpi_sample_clock_query_source_index(const u32 h_clock, const u32 index,
2294  	const u32 source, u16 *pw_source_index)
2295  {
2296  	u32 qr;
2297  	u16 err;
2298  
2299  	err = hpi_control_query(h_clock, HPI_SAMPLECLOCK_SOURCE_INDEX, index,
2300  		source, &qr);
2301  	*pw_source_index = (u16)qr;
2302  	return err;
2303  }
2304  
hpi_sample_clock_set_source_index(u32 h_control,u16 source_index)2305  u16 hpi_sample_clock_set_source_index(u32 h_control, u16 source_index)
2306  {
2307  	return hpi_control_param_set(h_control, HPI_SAMPLECLOCK_SOURCE_INDEX,
2308  		source_index, 0);
2309  }
2310  
hpi_sample_clock_get_source_index(u32 h_control,u16 * pw_source_index)2311  u16 hpi_sample_clock_get_source_index(u32 h_control, u16 *pw_source_index)
2312  {
2313  	u16 err = 0;
2314  	u32 source_index = 0;
2315  	err = hpi_control_param1_get(h_control, HPI_SAMPLECLOCK_SOURCE_INDEX,
2316  		&source_index);
2317  	if (!err)
2318  		if (pw_source_index)
2319  			*pw_source_index = (u16)source_index;
2320  	return err;
2321  }
2322  
hpi_sample_clock_query_local_rate(const u32 h_clock,const u32 index,u32 * prate)2323  u16 hpi_sample_clock_query_local_rate(const u32 h_clock, const u32 index,
2324  	u32 *prate)
2325  {
2326  	return hpi_control_query(h_clock, HPI_SAMPLECLOCK_LOCAL_SAMPLERATE,
2327  				 index, 0, prate);
2328  }
2329  
hpi_sample_clock_set_local_rate(u32 h_control,u32 sample_rate)2330  u16 hpi_sample_clock_set_local_rate(u32 h_control, u32 sample_rate)
2331  {
2332  	return hpi_control_param_set(h_control,
2333  		HPI_SAMPLECLOCK_LOCAL_SAMPLERATE, sample_rate, 0);
2334  }
2335  
hpi_sample_clock_get_local_rate(u32 h_control,u32 * psample_rate)2336  u16 hpi_sample_clock_get_local_rate(u32 h_control, u32 *psample_rate)
2337  {
2338  	u16 err = 0;
2339  	u32 sample_rate = 0;
2340  	err = hpi_control_param1_get(h_control,
2341  		HPI_SAMPLECLOCK_LOCAL_SAMPLERATE, &sample_rate);
2342  	if (!err)
2343  		if (psample_rate)
2344  			*psample_rate = sample_rate;
2345  	return err;
2346  }
2347  
hpi_sample_clock_get_sample_rate(u32 h_control,u32 * psample_rate)2348  u16 hpi_sample_clock_get_sample_rate(u32 h_control, u32 *psample_rate)
2349  {
2350  	u16 err = 0;
2351  	u32 sample_rate = 0;
2352  	err = hpi_control_param1_get(h_control, HPI_SAMPLECLOCK_SAMPLERATE,
2353  		&sample_rate);
2354  	if (!err)
2355  		if (psample_rate)
2356  			*psample_rate = sample_rate;
2357  	return err;
2358  }
2359  
hpi_sample_clock_set_auto(u32 h_control,u32 enable)2360  u16 hpi_sample_clock_set_auto(u32 h_control, u32 enable)
2361  {
2362  	return hpi_control_param_set(h_control, HPI_SAMPLECLOCK_AUTO, enable,
2363  		0);
2364  }
2365  
hpi_sample_clock_get_auto(u32 h_control,u32 * penable)2366  u16 hpi_sample_clock_get_auto(u32 h_control, u32 *penable)
2367  {
2368  	return hpi_control_param1_get(h_control, HPI_SAMPLECLOCK_AUTO,
2369  		penable);
2370  }
2371  
hpi_sample_clock_set_local_rate_lock(u32 h_control,u32 lock)2372  u16 hpi_sample_clock_set_local_rate_lock(u32 h_control, u32 lock)
2373  {
2374  	return hpi_control_param_set(h_control, HPI_SAMPLECLOCK_LOCAL_LOCK,
2375  		lock, 0);
2376  }
2377  
hpi_sample_clock_get_local_rate_lock(u32 h_control,u32 * plock)2378  u16 hpi_sample_clock_get_local_rate_lock(u32 h_control, u32 *plock)
2379  {
2380  	return hpi_control_param1_get(h_control, HPI_SAMPLECLOCK_LOCAL_LOCK,
2381  		plock);
2382  }
2383  
hpi_tone_detector_get_frequency(u32 h_control,u32 index,u32 * frequency)2384  u16 hpi_tone_detector_get_frequency(u32 h_control, u32 index, u32 *frequency)
2385  {
2386  	return hpi_control_param_get(h_control, HPI_TONEDETECTOR_FREQUENCY,
2387  		index, 0, frequency, NULL);
2388  }
2389  
hpi_tone_detector_get_state(u32 h_control,u32 * state)2390  u16 hpi_tone_detector_get_state(u32 h_control, u32 *state)
2391  {
2392  	return hpi_control_param1_get(h_control, HPI_TONEDETECTOR_STATE,
2393  		state);
2394  }
2395  
hpi_tone_detector_set_enable(u32 h_control,u32 enable)2396  u16 hpi_tone_detector_set_enable(u32 h_control, u32 enable)
2397  {
2398  	return hpi_control_param_set(h_control, HPI_GENERIC_ENABLE, enable,
2399  		0);
2400  }
2401  
hpi_tone_detector_get_enable(u32 h_control,u32 * enable)2402  u16 hpi_tone_detector_get_enable(u32 h_control, u32 *enable)
2403  {
2404  	return hpi_control_param1_get(h_control, HPI_GENERIC_ENABLE, enable);
2405  }
2406  
hpi_tone_detector_set_event_enable(u32 h_control,u32 event_enable)2407  u16 hpi_tone_detector_set_event_enable(u32 h_control, u32 event_enable)
2408  {
2409  	return hpi_control_param_set(h_control, HPI_GENERIC_EVENT_ENABLE,
2410  		(u32)event_enable, 0);
2411  }
2412  
hpi_tone_detector_get_event_enable(u32 h_control,u32 * event_enable)2413  u16 hpi_tone_detector_get_event_enable(u32 h_control, u32 *event_enable)
2414  {
2415  	return hpi_control_param1_get(h_control, HPI_GENERIC_EVENT_ENABLE,
2416  		event_enable);
2417  }
2418  
hpi_tone_detector_set_threshold(u32 h_control,int threshold)2419  u16 hpi_tone_detector_set_threshold(u32 h_control, int threshold)
2420  {
2421  	return hpi_control_param_set(h_control, HPI_TONEDETECTOR_THRESHOLD,
2422  		(u32)threshold, 0);
2423  }
2424  
hpi_tone_detector_get_threshold(u32 h_control,int * threshold)2425  u16 hpi_tone_detector_get_threshold(u32 h_control, int *threshold)
2426  {
2427  	return hpi_control_param1_get(h_control, HPI_TONEDETECTOR_THRESHOLD,
2428  		(u32 *)threshold);
2429  }
2430  
hpi_silence_detector_get_state(u32 h_control,u32 * state)2431  u16 hpi_silence_detector_get_state(u32 h_control, u32 *state)
2432  {
2433  	return hpi_control_param1_get(h_control, HPI_SILENCEDETECTOR_STATE,
2434  		state);
2435  }
2436  
hpi_silence_detector_set_enable(u32 h_control,u32 enable)2437  u16 hpi_silence_detector_set_enable(u32 h_control, u32 enable)
2438  {
2439  	return hpi_control_param_set(h_control, HPI_GENERIC_ENABLE, enable,
2440  		0);
2441  }
2442  
hpi_silence_detector_get_enable(u32 h_control,u32 * enable)2443  u16 hpi_silence_detector_get_enable(u32 h_control, u32 *enable)
2444  {
2445  	return hpi_control_param1_get(h_control, HPI_GENERIC_ENABLE, enable);
2446  }
2447  
hpi_silence_detector_set_event_enable(u32 h_control,u32 event_enable)2448  u16 hpi_silence_detector_set_event_enable(u32 h_control, u32 event_enable)
2449  {
2450  	return hpi_control_param_set(h_control, HPI_GENERIC_EVENT_ENABLE,
2451  		event_enable, 0);
2452  }
2453  
hpi_silence_detector_get_event_enable(u32 h_control,u32 * event_enable)2454  u16 hpi_silence_detector_get_event_enable(u32 h_control, u32 *event_enable)
2455  {
2456  	return hpi_control_param1_get(h_control, HPI_GENERIC_EVENT_ENABLE,
2457  		event_enable);
2458  }
2459  
hpi_silence_detector_set_delay(u32 h_control,u32 delay)2460  u16 hpi_silence_detector_set_delay(u32 h_control, u32 delay)
2461  {
2462  	return hpi_control_param_set(h_control, HPI_SILENCEDETECTOR_DELAY,
2463  		delay, 0);
2464  }
2465  
hpi_silence_detector_get_delay(u32 h_control,u32 * delay)2466  u16 hpi_silence_detector_get_delay(u32 h_control, u32 *delay)
2467  {
2468  	return hpi_control_param1_get(h_control, HPI_SILENCEDETECTOR_DELAY,
2469  		delay);
2470  }
2471  
hpi_silence_detector_set_threshold(u32 h_control,int threshold)2472  u16 hpi_silence_detector_set_threshold(u32 h_control, int threshold)
2473  {
2474  	return hpi_control_param_set(h_control, HPI_SILENCEDETECTOR_THRESHOLD,
2475  		threshold, 0);
2476  }
2477  
hpi_silence_detector_get_threshold(u32 h_control,int * threshold)2478  u16 hpi_silence_detector_get_threshold(u32 h_control, int *threshold)
2479  {
2480  	return hpi_control_param1_get(h_control,
2481  		HPI_SILENCEDETECTOR_THRESHOLD, (u32 *)threshold);
2482  }
2483  
hpi_tuner_query_band(const u32 h_tuner,const u32 index,u16 * pw_band)2484  u16 hpi_tuner_query_band(const u32 h_tuner, const u32 index, u16 *pw_band)
2485  {
2486  	u32 qr;
2487  	u16 err;
2488  
2489  	err = hpi_control_query(h_tuner, HPI_TUNER_BAND, index, 0, &qr);
2490  	*pw_band = (u16)qr;
2491  	return err;
2492  }
2493  
hpi_tuner_set_band(u32 h_control,u16 band)2494  u16 hpi_tuner_set_band(u32 h_control, u16 band)
2495  {
2496  	return hpi_control_param_set(h_control, HPI_TUNER_BAND, band, 0);
2497  }
2498  
hpi_tuner_get_band(u32 h_control,u16 * pw_band)2499  u16 hpi_tuner_get_band(u32 h_control, u16 *pw_band)
2500  {
2501  	u32 band = 0;
2502  	u16 error = 0;
2503  
2504  	error = hpi_control_param1_get(h_control, HPI_TUNER_BAND, &band);
2505  	if (pw_band)
2506  		*pw_band = (u16)band;
2507  	return error;
2508  }
2509  
hpi_tuner_query_frequency(const u32 h_tuner,const u32 index,const u16 band,u32 * pfreq)2510  u16 hpi_tuner_query_frequency(const u32 h_tuner, const u32 index,
2511  	const u16 band, u32 *pfreq)
2512  {
2513  	return hpi_control_query(h_tuner, HPI_TUNER_FREQ, index, band, pfreq);
2514  }
2515  
hpi_tuner_set_frequency(u32 h_control,u32 freq_ink_hz)2516  u16 hpi_tuner_set_frequency(u32 h_control, u32 freq_ink_hz)
2517  {
2518  	return hpi_control_param_set(h_control, HPI_TUNER_FREQ, freq_ink_hz,
2519  		0);
2520  }
2521  
hpi_tuner_get_frequency(u32 h_control,u32 * pw_freq_ink_hz)2522  u16 hpi_tuner_get_frequency(u32 h_control, u32 *pw_freq_ink_hz)
2523  {
2524  	return hpi_control_param1_get(h_control, HPI_TUNER_FREQ,
2525  		pw_freq_ink_hz);
2526  }
2527  
hpi_tuner_query_gain(const u32 h_tuner,const u32 index,u16 * pw_gain)2528  u16 hpi_tuner_query_gain(const u32 h_tuner, const u32 index, u16 *pw_gain)
2529  {
2530  	u32 qr;
2531  	u16 err;
2532  
2533  	err = hpi_control_query(h_tuner, HPI_TUNER_BAND, index, 0, &qr);
2534  	*pw_gain = (u16)qr;
2535  	return err;
2536  }
2537  
hpi_tuner_set_gain(u32 h_control,short gain)2538  u16 hpi_tuner_set_gain(u32 h_control, short gain)
2539  {
2540  	return hpi_control_param_set(h_control, HPI_TUNER_GAIN, gain, 0);
2541  }
2542  
hpi_tuner_get_gain(u32 h_control,short * pn_gain)2543  u16 hpi_tuner_get_gain(u32 h_control, short *pn_gain)
2544  {
2545  	u32 gain = 0;
2546  	u16 error = 0;
2547  
2548  	error = hpi_control_param1_get(h_control, HPI_TUNER_GAIN, &gain);
2549  	if (pn_gain)
2550  		*pn_gain = (u16)gain;
2551  	return error;
2552  }
2553  
hpi_tuner_get_rf_level(u32 h_control,short * pw_level)2554  u16 hpi_tuner_get_rf_level(u32 h_control, short *pw_level)
2555  {
2556  	struct hpi_message hm;
2557  	struct hpi_response hr;
2558  
2559  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2560  		HPI_CONTROL_GET_STATE);
2561  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2562  		return HPI_ERROR_INVALID_HANDLE;
2563  	hm.u.cu.attribute = HPI_TUNER_LEVEL_AVG;
2564  	hpi_send_recv(&hm, &hr);
2565  	if (pw_level)
2566  		*pw_level = hr.u.cu.tuner.s_level;
2567  	return hr.error;
2568  }
2569  
hpi_tuner_get_raw_rf_level(u32 h_control,short * pw_level)2570  u16 hpi_tuner_get_raw_rf_level(u32 h_control, short *pw_level)
2571  {
2572  	struct hpi_message hm;
2573  	struct hpi_response hr;
2574  
2575  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2576  		HPI_CONTROL_GET_STATE);
2577  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2578  		return HPI_ERROR_INVALID_HANDLE;
2579  	hm.u.cu.attribute = HPI_TUNER_LEVEL_RAW;
2580  	hpi_send_recv(&hm, &hr);
2581  	if (pw_level)
2582  		*pw_level = hr.u.cu.tuner.s_level;
2583  	return hr.error;
2584  }
2585  
hpi_tuner_query_deemphasis(const u32 h_tuner,const u32 index,const u16 band,u32 * pdeemphasis)2586  u16 hpi_tuner_query_deemphasis(const u32 h_tuner, const u32 index,
2587  	const u16 band, u32 *pdeemphasis)
2588  {
2589  	return hpi_control_query(h_tuner, HPI_TUNER_DEEMPHASIS, index, band,
2590  		pdeemphasis);
2591  }
2592  
hpi_tuner_set_deemphasis(u32 h_control,u32 deemphasis)2593  u16 hpi_tuner_set_deemphasis(u32 h_control, u32 deemphasis)
2594  {
2595  	return hpi_control_param_set(h_control, HPI_TUNER_DEEMPHASIS,
2596  		deemphasis, 0);
2597  }
2598  
hpi_tuner_get_deemphasis(u32 h_control,u32 * pdeemphasis)2599  u16 hpi_tuner_get_deemphasis(u32 h_control, u32 *pdeemphasis)
2600  {
2601  	return hpi_control_param1_get(h_control, HPI_TUNER_DEEMPHASIS,
2602  		pdeemphasis);
2603  }
2604  
hpi_tuner_query_program(const u32 h_tuner,u32 * pbitmap_program)2605  u16 hpi_tuner_query_program(const u32 h_tuner, u32 *pbitmap_program)
2606  {
2607  	return hpi_control_query(h_tuner, HPI_TUNER_PROGRAM, 0, 0,
2608  		pbitmap_program);
2609  }
2610  
hpi_tuner_set_program(u32 h_control,u32 program)2611  u16 hpi_tuner_set_program(u32 h_control, u32 program)
2612  {
2613  	return hpi_control_param_set(h_control, HPI_TUNER_PROGRAM, program,
2614  		0);
2615  }
2616  
hpi_tuner_get_program(u32 h_control,u32 * pprogram)2617  u16 hpi_tuner_get_program(u32 h_control, u32 *pprogram)
2618  {
2619  	return hpi_control_param1_get(h_control, HPI_TUNER_PROGRAM, pprogram);
2620  }
2621  
hpi_tuner_get_hd_radio_dsp_version(u32 h_control,char * psz_dsp_version,const u32 string_size)2622  u16 hpi_tuner_get_hd_radio_dsp_version(u32 h_control, char *psz_dsp_version,
2623  	const u32 string_size)
2624  {
2625  	return hpi_control_get_string(h_control,
2626  		HPI_TUNER_HDRADIO_DSP_VERSION, psz_dsp_version, string_size);
2627  }
2628  
hpi_tuner_get_hd_radio_sdk_version(u32 h_control,char * psz_sdk_version,const u32 string_size)2629  u16 hpi_tuner_get_hd_radio_sdk_version(u32 h_control, char *psz_sdk_version,
2630  	const u32 string_size)
2631  {
2632  	return hpi_control_get_string(h_control,
2633  		HPI_TUNER_HDRADIO_SDK_VERSION, psz_sdk_version, string_size);
2634  }
2635  
hpi_tuner_get_status(u32 h_control,u16 * pw_status_mask,u16 * pw_status)2636  u16 hpi_tuner_get_status(u32 h_control, u16 *pw_status_mask, u16 *pw_status)
2637  {
2638  	u32 status = 0;
2639  	u16 error = 0;
2640  
2641  	error = hpi_control_param1_get(h_control, HPI_TUNER_STATUS, &status);
2642  	if (pw_status) {
2643  		if (!error) {
2644  			*pw_status_mask = (u16)(status >> 16);
2645  			*pw_status = (u16)(status & 0xFFFF);
2646  		} else {
2647  			*pw_status_mask = 0;
2648  			*pw_status = 0;
2649  		}
2650  	}
2651  	return error;
2652  }
2653  
hpi_tuner_set_mode(u32 h_control,u32 mode,u32 value)2654  u16 hpi_tuner_set_mode(u32 h_control, u32 mode, u32 value)
2655  {
2656  	return hpi_control_param_set(h_control, HPI_TUNER_MODE, mode, value);
2657  }
2658  
hpi_tuner_get_mode(u32 h_control,u32 mode,u32 * pn_value)2659  u16 hpi_tuner_get_mode(u32 h_control, u32 mode, u32 *pn_value)
2660  {
2661  	return hpi_control_param_get(h_control, HPI_TUNER_MODE, mode, 0,
2662  		pn_value, NULL);
2663  }
2664  
hpi_tuner_get_hd_radio_signal_quality(u32 h_control,u32 * pquality)2665  u16 hpi_tuner_get_hd_radio_signal_quality(u32 h_control, u32 *pquality)
2666  {
2667  	return hpi_control_param1_get(h_control,
2668  		HPI_TUNER_HDRADIO_SIGNAL_QUALITY, pquality);
2669  }
2670  
hpi_tuner_get_hd_radio_signal_blend(u32 h_control,u32 * pblend)2671  u16 hpi_tuner_get_hd_radio_signal_blend(u32 h_control, u32 *pblend)
2672  {
2673  	return hpi_control_param1_get(h_control, HPI_TUNER_HDRADIO_BLEND,
2674  		pblend);
2675  }
2676  
hpi_tuner_set_hd_radio_signal_blend(u32 h_control,const u32 blend)2677  u16 hpi_tuner_set_hd_radio_signal_blend(u32 h_control, const u32 blend)
2678  {
2679  	return hpi_control_param_set(h_control, HPI_TUNER_HDRADIO_BLEND,
2680  		blend, 0);
2681  }
2682  
hpi_tuner_get_rds(u32 h_control,char * p_data)2683  u16 hpi_tuner_get_rds(u32 h_control, char *p_data)
2684  {
2685  	struct hpi_message hm;
2686  	struct hpi_response hr;
2687  
2688  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2689  		HPI_CONTROL_GET_STATE);
2690  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2691  		return HPI_ERROR_INVALID_HANDLE;
2692  	hm.u.c.attribute = HPI_TUNER_RDS;
2693  	hpi_send_recv(&hm, &hr);
2694  	if (p_data) {
2695  		*(u32 *)&p_data[0] = hr.u.cu.tuner.rds.data[0];
2696  		*(u32 *)&p_data[4] = hr.u.cu.tuner.rds.data[1];
2697  		*(u32 *)&p_data[8] = hr.u.cu.tuner.rds.bLER;
2698  	}
2699  	return hr.error;
2700  }
2701  
hpi_pad_get_channel_name(u32 h_control,char * psz_string,const u32 data_length)2702  u16 hpi_pad_get_channel_name(u32 h_control, char *psz_string,
2703  	const u32 data_length)
2704  {
2705  	return hpi_control_get_string(h_control, HPI_PAD_CHANNEL_NAME,
2706  		psz_string, data_length);
2707  }
2708  
hpi_pad_get_artist(u32 h_control,char * psz_string,const u32 data_length)2709  u16 hpi_pad_get_artist(u32 h_control, char *psz_string, const u32 data_length)
2710  {
2711  	return hpi_control_get_string(h_control, HPI_PAD_ARTIST, psz_string,
2712  		data_length);
2713  }
2714  
hpi_pad_get_title(u32 h_control,char * psz_string,const u32 data_length)2715  u16 hpi_pad_get_title(u32 h_control, char *psz_string, const u32 data_length)
2716  {
2717  	return hpi_control_get_string(h_control, HPI_PAD_TITLE, psz_string,
2718  		data_length);
2719  }
2720  
hpi_pad_get_comment(u32 h_control,char * psz_string,const u32 data_length)2721  u16 hpi_pad_get_comment(u32 h_control, char *psz_string,
2722  	const u32 data_length)
2723  {
2724  	return hpi_control_get_string(h_control, HPI_PAD_COMMENT, psz_string,
2725  		data_length);
2726  }
2727  
hpi_pad_get_program_type(u32 h_control,u32 * ppTY)2728  u16 hpi_pad_get_program_type(u32 h_control, u32 *ppTY)
2729  {
2730  	return hpi_control_param1_get(h_control, HPI_PAD_PROGRAM_TYPE, ppTY);
2731  }
2732  
hpi_pad_get_rdsPI(u32 h_control,u32 * ppI)2733  u16 hpi_pad_get_rdsPI(u32 h_control, u32 *ppI)
2734  {
2735  	return hpi_control_param1_get(h_control, HPI_PAD_PROGRAM_ID, ppI);
2736  }
2737  
hpi_volume_query_channels(const u32 h_volume,u32 * p_channels)2738  u16 hpi_volume_query_channels(const u32 h_volume, u32 *p_channels)
2739  {
2740  	return hpi_control_query(h_volume, HPI_VOLUME_NUM_CHANNELS, 0, 0,
2741  		p_channels);
2742  }
2743  
hpi_volume_set_gain(u32 h_control,short an_log_gain[HPI_MAX_CHANNELS])2744  u16 hpi_volume_set_gain(u32 h_control, short an_log_gain[HPI_MAX_CHANNELS]
2745  	)
2746  {
2747  	return hpi_control_log_set2(h_control, HPI_VOLUME_GAIN,
2748  		an_log_gain[0], an_log_gain[1]);
2749  }
2750  
hpi_volume_get_gain(u32 h_control,short an_log_gain[HPI_MAX_CHANNELS])2751  u16 hpi_volume_get_gain(u32 h_control, short an_log_gain[HPI_MAX_CHANNELS]
2752  	)
2753  {
2754  	return hpi_control_log_get2(h_control, HPI_VOLUME_GAIN,
2755  		&an_log_gain[0], &an_log_gain[1]);
2756  }
2757  
hpi_volume_set_mute(u32 h_control,u32 mute)2758  u16 hpi_volume_set_mute(u32 h_control, u32 mute)
2759  {
2760  	return hpi_control_param_set(h_control, HPI_VOLUME_MUTE, mute, 0);
2761  }
2762  
hpi_volume_get_mute(u32 h_control,u32 * mute)2763  u16 hpi_volume_get_mute(u32 h_control, u32 *mute)
2764  {
2765  	return hpi_control_param1_get(h_control, HPI_VOLUME_MUTE, mute);
2766  }
2767  
hpi_volume_query_range(u32 h_control,short * min_gain_01dB,short * max_gain_01dB,short * step_gain_01dB)2768  u16 hpi_volume_query_range(u32 h_control, short *min_gain_01dB,
2769  	short *max_gain_01dB, short *step_gain_01dB)
2770  {
2771  	struct hpi_message hm;
2772  	struct hpi_response hr;
2773  
2774  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2775  		HPI_CONTROL_GET_STATE);
2776  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2777  		return HPI_ERROR_INVALID_HANDLE;
2778  	hm.u.c.attribute = HPI_VOLUME_RANGE;
2779  
2780  	hpi_send_recv(&hm, &hr);
2781  	if (hr.error) {
2782  		hr.u.c.an_log_value[0] = 0;
2783  		hr.u.c.an_log_value[1] = 0;
2784  		hr.u.c.param1 = 0;
2785  	}
2786  	if (min_gain_01dB)
2787  		*min_gain_01dB = hr.u.c.an_log_value[0];
2788  	if (max_gain_01dB)
2789  		*max_gain_01dB = hr.u.c.an_log_value[1];
2790  	if (step_gain_01dB)
2791  		*step_gain_01dB = (short)hr.u.c.param1;
2792  	return hr.error;
2793  }
2794  
hpi_volume_auto_fade_profile(u32 h_control,short an_stop_gain0_01dB[HPI_MAX_CHANNELS],u32 duration_ms,u16 profile)2795  u16 hpi_volume_auto_fade_profile(u32 h_control,
2796  	short an_stop_gain0_01dB[HPI_MAX_CHANNELS], u32 duration_ms,
2797  	u16 profile)
2798  {
2799  	struct hpi_message hm;
2800  	struct hpi_response hr;
2801  
2802  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2803  		HPI_CONTROL_SET_STATE);
2804  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2805  		return HPI_ERROR_INVALID_HANDLE;
2806  
2807  	memcpy(hm.u.c.an_log_value, an_stop_gain0_01dB,
2808  		sizeof(short) * HPI_MAX_CHANNELS);
2809  
2810  	hm.u.c.attribute = HPI_VOLUME_AUTOFADE;
2811  	hm.u.c.param1 = duration_ms;
2812  	hm.u.c.param2 = profile;
2813  
2814  	hpi_send_recv(&hm, &hr);
2815  
2816  	return hr.error;
2817  }
2818  
hpi_volume_auto_fade(u32 h_control,short an_stop_gain0_01dB[HPI_MAX_CHANNELS],u32 duration_ms)2819  u16 hpi_volume_auto_fade(u32 h_control,
2820  	short an_stop_gain0_01dB[HPI_MAX_CHANNELS], u32 duration_ms)
2821  {
2822  	return hpi_volume_auto_fade_profile(h_control, an_stop_gain0_01dB,
2823  		duration_ms, HPI_VOLUME_AUTOFADE_LOG);
2824  }
2825  
hpi_volume_query_auto_fade_profile(const u32 h_volume,const u32 i,u16 * profile)2826  u16 hpi_volume_query_auto_fade_profile(const u32 h_volume, const u32 i,
2827  	u16 *profile)
2828  {
2829  	u16 e;
2830  	u32 u;
2831  	e = hpi_control_query(h_volume, HPI_VOLUME_AUTOFADE, i, 0, &u);
2832  	*profile = (u16)u;
2833  	return e;
2834  }
2835  
hpi_vox_set_threshold(u32 h_control,short an_gain0_01dB)2836  u16 hpi_vox_set_threshold(u32 h_control, short an_gain0_01dB)
2837  {
2838  	struct hpi_message hm;
2839  	struct hpi_response hr;
2840  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2841  		HPI_CONTROL_SET_STATE);
2842  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2843  		return HPI_ERROR_INVALID_HANDLE;
2844  	hm.u.c.attribute = HPI_VOX_THRESHOLD;
2845  
2846  	hm.u.c.an_log_value[0] = an_gain0_01dB;
2847  
2848  	hpi_send_recv(&hm, &hr);
2849  
2850  	return hr.error;
2851  }
2852  
hpi_vox_get_threshold(u32 h_control,short * an_gain0_01dB)2853  u16 hpi_vox_get_threshold(u32 h_control, short *an_gain0_01dB)
2854  {
2855  	struct hpi_message hm;
2856  	struct hpi_response hr;
2857  	hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
2858  		HPI_CONTROL_GET_STATE);
2859  	if (hpi_handle_indexes(h_control, &hm.adapter_index, &hm.obj_index))
2860  		return HPI_ERROR_INVALID_HANDLE;
2861  	hm.u.c.attribute = HPI_VOX_THRESHOLD;
2862  
2863  	hpi_send_recv(&hm, &hr);
2864  
2865  	*an_gain0_01dB = hr.u.c.an_log_value[0];
2866  
2867  	return hr.error;
2868  }
2869