~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/asihpi/hpifunc.c

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /sound/pci/asihpi/hpifunc.c (Version linux-6.12-rc7) and /sound/pci/asihpi/hpifunc.c (Version linux-5.16.20)


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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php