sound/pci/asihpi/hpifunc.c

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