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