sound/pci/asihpi/hpifunc.c

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