1 /****************************************************************************** 2 3 AudioScience HPI driver 4 Copyright (C) 1997-2014 AudioScience Inc. <support@audioscience.com> 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of version 2 of the GNU General Public License as 8 published by the Free Software Foundation; 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software 17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 19 \file hpicmn.c 20 21 Common functions used by hpixxxx.c modules 22 23 (C) Copyright AudioScience Inc. 1998-2003 24 *******************************************************************************/ 25 #define SOURCEFILE_NAME "hpicmn.c" 26 27 #include "hpi_internal.h" 28 #include "hpidebug.h" 29 #include "hpimsginit.h" 30 31 #include "hpicmn.h" 32 33 struct hpi_adapters_list { 34 struct hpios_spinlock list_lock; 35 struct hpi_adapter_obj adapter[HPI_MAX_ADAPTERS]; 36 u16 gw_num_adapters; 37 }; 38 39 static struct hpi_adapters_list adapters; 40 41 /** 42 * Given an HPI Message that was sent out and a response that was received, 43 * validate that the response has the correct fields filled in, 44 * i.e ObjectType, Function etc 45 **/ 46 u16 hpi_validate_response(struct hpi_message *phm, struct hpi_response *phr) 47 { 48 if (phr->type != HPI_TYPE_RESPONSE) { 49 HPI_DEBUG_LOG(ERROR, "header type %d invalid\n", phr->type); 50 return HPI_ERROR_INVALID_RESPONSE; 51 } 52 53 if (phr->object != phm->object) { 54 HPI_DEBUG_LOG(ERROR, "header object %d invalid\n", 55 phr->object); 56 return HPI_ERROR_INVALID_RESPONSE; 57 } 58 59 if (phr->function != phm->function) { 60 HPI_DEBUG_LOG(ERROR, "header function %d invalid\n", 61 phr->function); 62 return HPI_ERROR_INVALID_RESPONSE; 63 } 64 65 return 0; 66 } 67 68 u16 hpi_add_adapter(struct hpi_adapter_obj *pao) 69 { 70 u16 retval = 0; 71 /*HPI_ASSERT(pao->type); */ 72 73 hpios_alistlock_lock(&adapters); 74 75 if (pao->index >= HPI_MAX_ADAPTERS) { 76 retval = HPI_ERROR_BAD_ADAPTER_NUMBER; 77 goto unlock; 78 } 79 80 if (adapters.adapter[pao->index].type) { 81 int a; 82 for (a = HPI_MAX_ADAPTERS - 1; a >= 0; a--) { 83 if (!adapters.adapter[a].type) { 84 HPI_DEBUG_LOG(WARNING, 85 "ASI%X duplicate index %d moved to %d\n", 86 pao->type, pao->index, a); 87 pao->index = a; 88 break; 89 } 90 } 91 if (a < 0) { 92 retval = HPI_ERROR_DUPLICATE_ADAPTER_NUMBER; 93 goto unlock; 94 } 95 } 96 adapters.adapter[pao->index] = *pao; 97 hpios_dsplock_init(&adapters.adapter[pao->index]); 98 adapters.gw_num_adapters++; 99 100 unlock: 101 hpios_alistlock_unlock(&adapters); 102 return retval; 103 } 104 105 void hpi_delete_adapter(struct hpi_adapter_obj *pao) 106 { 107 if (!pao->type) { 108 HPI_DEBUG_LOG(ERROR, "removing null adapter?\n"); 109 return; 110 } 111 112 hpios_alistlock_lock(&adapters); 113 if (adapters.adapter[pao->index].type) 114 adapters.gw_num_adapters--; 115 memset(&adapters.adapter[pao->index], 0, sizeof(adapters.adapter[0])); 116 hpios_alistlock_unlock(&adapters); 117 } 118 119 /** 120 * FindAdapter returns a pointer to the struct hpi_adapter_obj with 121 * index wAdapterIndex in an HPI_ADAPTERS_LIST structure. 122 * 123 */ 124 struct hpi_adapter_obj *hpi_find_adapter(u16 adapter_index) 125 { 126 struct hpi_adapter_obj *pao = NULL; 127 128 if (adapter_index >= HPI_MAX_ADAPTERS) { 129 HPI_DEBUG_LOG(VERBOSE, "find_adapter invalid index %d\n", 130 adapter_index); 131 return NULL; 132 } 133 134 pao = &adapters.adapter[adapter_index]; 135 if (pao->type != 0) { 136 /* 137 HPI_DEBUG_LOG(VERBOSE, "Found adapter index %d\n", 138 wAdapterIndex); 139 */ 140 return pao; 141 } else { 142 /* 143 HPI_DEBUG_LOG(VERBOSE, "No adapter index %d\n", 144 wAdapterIndex); 145 */ 146 return NULL; 147 } 148 } 149 150 /** 151 * 152 * wipe an HPI_ADAPTERS_LIST structure. 153 * 154 **/ 155 static void wipe_adapter_list(void) 156 { 157 memset(&adapters, 0, sizeof(adapters)); 158 } 159 160 static void subsys_get_adapter(struct hpi_message *phm, 161 struct hpi_response *phr) 162 { 163 int count = phm->obj_index; 164 u16 index = 0; 165 166 /* find the nCount'th nonzero adapter in array */ 167 for (index = 0; index < HPI_MAX_ADAPTERS; index++) { 168 if (adapters.adapter[index].type) { 169 if (!count) 170 break; 171 count--; 172 } 173 } 174 175 if (index < HPI_MAX_ADAPTERS) { 176 phr->u.s.adapter_index = adapters.adapter[index].index; 177 phr->u.s.adapter_type = adapters.adapter[index].type; 178 } else { 179 phr->u.s.adapter_index = 0; 180 phr->u.s.adapter_type = 0; 181 phr->error = HPI_ERROR_INVALID_OBJ_INDEX; 182 } 183 } 184 185 static unsigned int control_cache_alloc_check(struct hpi_control_cache *pC) 186 { 187 unsigned int i; 188 int cached = 0; 189 if (!pC) 190 return 0; 191 192 if (pC->init) 193 return pC->init; 194 195 if (!pC->p_cache) 196 return 0; 197 198 if (pC->control_count && pC->cache_size_in_bytes) { 199 char *p_master_cache; 200 unsigned int byte_count = 0; 201 202 p_master_cache = (char *)pC->p_cache; 203 HPI_DEBUG_LOG(DEBUG, "check %d controls\n", 204 pC->control_count); 205 for (i = 0; i < pC->control_count; i++) { 206 struct hpi_control_cache_info *info = 207 (struct hpi_control_cache_info *) 208 &p_master_cache[byte_count]; 209 u16 control_index = info->control_index; 210 211 if (control_index >= pC->control_count) { 212 HPI_DEBUG_LOG(INFO, 213 "adap %d control index %d out of range, cache not ready?\n", 214 pC->adap_idx, control_index); 215 return 0; 216 } 217 218 if (!info->size_in32bit_words) { 219 if (!i) { 220 HPI_DEBUG_LOG(INFO, 221 "adap %d cache not ready?\n", 222 pC->adap_idx); 223 return 0; 224 } 225 /* The cache is invalid. 226 * Minimum valid entry size is 227 * sizeof(struct hpi_control_cache_info) 228 */ 229 HPI_DEBUG_LOG(ERROR, 230 "adap %d zero size cache entry %d\n", 231 pC->adap_idx, i); 232 break; 233 } 234 235 if (info->control_type) { 236 pC->p_info[control_index] = info; 237 cached++; 238 } else { /* dummy cache entry */ 239 pC->p_info[control_index] = NULL; 240 } 241 242 byte_count += info->size_in32bit_words * 4; 243 244 HPI_DEBUG_LOG(VERBOSE, 245 "cached %d, pinfo %p index %d type %d size %d\n", 246 cached, pC->p_info[info->control_index], 247 info->control_index, info->control_type, 248 info->size_in32bit_words); 249 250 /* quit loop early if whole cache has been scanned. 251 * dwControlCount is the maximum possible entries 252 * but some may be absent from the cache 253 */ 254 if (byte_count >= pC->cache_size_in_bytes) 255 break; 256 /* have seen last control index */ 257 if (info->control_index == pC->control_count - 1) 258 break; 259 } 260 261 if (byte_count != pC->cache_size_in_bytes) 262 HPI_DEBUG_LOG(WARNING, 263 "adap %d bytecount %d != cache size %d\n", 264 pC->adap_idx, byte_count, 265 pC->cache_size_in_bytes); 266 else 267 HPI_DEBUG_LOG(DEBUG, 268 "adap %d cache good, bytecount == cache size = %d\n", 269 pC->adap_idx, byte_count); 270 271 pC->init = (u16)cached; 272 } 273 return pC->init; 274 } 275 276 /** Find a control. 277 */ 278 static short find_control(u16 control_index, 279 struct hpi_control_cache *p_cache, struct hpi_control_cache_info **pI) 280 { 281 if (!control_cache_alloc_check(p_cache)) { 282 HPI_DEBUG_LOG(VERBOSE, 283 "control_cache_alloc_check() failed %d\n", 284 control_index); 285 return 0; 286 } 287 288 *pI = p_cache->p_info[control_index]; 289 if (!*pI) { 290 HPI_DEBUG_LOG(VERBOSE, "Uncached Control %d\n", 291 control_index); 292 return 0; 293 } else { 294 HPI_DEBUG_LOG(VERBOSE, "find_control() type %d\n", 295 (*pI)->control_type); 296 } 297 return 1; 298 } 299 300 /* allow unified treatment of several string fields within struct */ 301 #define HPICMN_PAD_OFS_AND_SIZE(m) {\ 302 offsetof(struct hpi_control_cache_pad, m), \ 303 sizeof(((struct hpi_control_cache_pad *)(NULL))->m) } 304 305 struct pad_ofs_size { 306 unsigned int offset; 307 unsigned int field_size; 308 }; 309 310 static const struct pad_ofs_size pad_desc[] = { 311 HPICMN_PAD_OFS_AND_SIZE(c_channel), /* HPI_PAD_CHANNEL_NAME */ 312 HPICMN_PAD_OFS_AND_SIZE(c_artist), /* HPI_PAD_ARTIST */ 313 HPICMN_PAD_OFS_AND_SIZE(c_title), /* HPI_PAD_TITLE */ 314 HPICMN_PAD_OFS_AND_SIZE(c_comment), /* HPI_PAD_COMMENT */ 315 }; 316 317 /** CheckControlCache checks the cache and fills the struct hpi_response 318 * accordingly. It returns one if a cache hit occurred, zero otherwise. 319 */ 320 short hpi_check_control_cache_single(struct hpi_control_cache_single *pC, 321 struct hpi_message *phm, struct hpi_response *phr) 322 { 323 size_t response_size; 324 short found = 1; 325 326 /* set the default response size */ 327 response_size = 328 sizeof(struct hpi_response_header) + 329 sizeof(struct hpi_control_res); 330 331 switch (pC->u.i.control_type) { 332 333 case HPI_CONTROL_METER: 334 if (phm->u.c.attribute == HPI_METER_PEAK) { 335 phr->u.c.an_log_value[0] = pC->u.meter.an_log_peak[0]; 336 phr->u.c.an_log_value[1] = pC->u.meter.an_log_peak[1]; 337 } else if (phm->u.c.attribute == HPI_METER_RMS) { 338 if (pC->u.meter.an_logRMS[0] == 339 HPI_CACHE_INVALID_SHORT) { 340 phr->error = 341 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 342 phr->u.c.an_log_value[0] = HPI_METER_MINIMUM; 343 phr->u.c.an_log_value[1] = HPI_METER_MINIMUM; 344 } else { 345 phr->u.c.an_log_value[0] = 346 pC->u.meter.an_logRMS[0]; 347 phr->u.c.an_log_value[1] = 348 pC->u.meter.an_logRMS[1]; 349 } 350 } else 351 found = 0; 352 break; 353 case HPI_CONTROL_VOLUME: 354 if (phm->u.c.attribute == HPI_VOLUME_GAIN) { 355 phr->u.c.an_log_value[0] = pC->u.vol.an_log[0]; 356 phr->u.c.an_log_value[1] = pC->u.vol.an_log[1]; 357 } else if (phm->u.c.attribute == HPI_VOLUME_MUTE) { 358 if (pC->u.vol.flags & HPI_VOLUME_FLAG_HAS_MUTE) { 359 if (pC->u.vol.flags & HPI_VOLUME_FLAG_MUTED) 360 phr->u.c.param1 = 361 HPI_BITMASK_ALL_CHANNELS; 362 else 363 phr->u.c.param1 = 0; 364 } else { 365 phr->error = 366 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 367 phr->u.c.param1 = 0; 368 } 369 } else { 370 found = 0; 371 } 372 break; 373 case HPI_CONTROL_MULTIPLEXER: 374 if (phm->u.c.attribute == HPI_MULTIPLEXER_SOURCE) { 375 phr->u.c.param1 = pC->u.mux.source_node_type; 376 phr->u.c.param2 = pC->u.mux.source_node_index; 377 } else { 378 found = 0; 379 } 380 break; 381 case HPI_CONTROL_CHANNEL_MODE: 382 if (phm->u.c.attribute == HPI_CHANNEL_MODE_MODE) 383 phr->u.c.param1 = pC->u.mode.mode; 384 else 385 found = 0; 386 break; 387 case HPI_CONTROL_LEVEL: 388 if (phm->u.c.attribute == HPI_LEVEL_GAIN) { 389 phr->u.c.an_log_value[0] = pC->u.level.an_log[0]; 390 phr->u.c.an_log_value[1] = pC->u.level.an_log[1]; 391 } else 392 found = 0; 393 break; 394 case HPI_CONTROL_TUNER: 395 if (phm->u.c.attribute == HPI_TUNER_FREQ) 396 phr->u.c.param1 = pC->u.tuner.freq_ink_hz; 397 else if (phm->u.c.attribute == HPI_TUNER_BAND) 398 phr->u.c.param1 = pC->u.tuner.band; 399 else if (phm->u.c.attribute == HPI_TUNER_LEVEL_AVG) 400 if (pC->u.tuner.s_level_avg == 401 HPI_CACHE_INVALID_SHORT) { 402 phr->u.cu.tuner.s_level = 0; 403 phr->error = 404 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 405 } else 406 phr->u.cu.tuner.s_level = 407 pC->u.tuner.s_level_avg; 408 else 409 found = 0; 410 break; 411 case HPI_CONTROL_AESEBU_RECEIVER: 412 if (phm->u.c.attribute == HPI_AESEBURX_ERRORSTATUS) 413 phr->u.c.param1 = pC->u.aes3rx.error_status; 414 else if (phm->u.c.attribute == HPI_AESEBURX_FORMAT) 415 phr->u.c.param1 = pC->u.aes3rx.format; 416 else 417 found = 0; 418 break; 419 case HPI_CONTROL_AESEBU_TRANSMITTER: 420 if (phm->u.c.attribute == HPI_AESEBUTX_FORMAT) 421 phr->u.c.param1 = pC->u.aes3tx.format; 422 else 423 found = 0; 424 break; 425 case HPI_CONTROL_TONEDETECTOR: 426 if (phm->u.c.attribute == HPI_TONEDETECTOR_STATE) 427 phr->u.c.param1 = pC->u.tone.state; 428 else 429 found = 0; 430 break; 431 case HPI_CONTROL_SILENCEDETECTOR: 432 if (phm->u.c.attribute == HPI_SILENCEDETECTOR_STATE) { 433 phr->u.c.param1 = pC->u.silence.state; 434 } else 435 found = 0; 436 break; 437 case HPI_CONTROL_MICROPHONE: 438 if (phm->u.c.attribute == HPI_MICROPHONE_PHANTOM_POWER) 439 phr->u.c.param1 = pC->u.microphone.phantom_state; 440 else 441 found = 0; 442 break; 443 case HPI_CONTROL_SAMPLECLOCK: 444 if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE) 445 phr->u.c.param1 = pC->u.clk.source; 446 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE_INDEX) { 447 if (pC->u.clk.source_index == 448 HPI_CACHE_INVALID_UINT16) { 449 phr->u.c.param1 = 0; 450 phr->error = 451 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 452 } else 453 phr->u.c.param1 = pC->u.clk.source_index; 454 } else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SAMPLERATE) 455 phr->u.c.param1 = pC->u.clk.sample_rate; 456 else 457 found = 0; 458 break; 459 case HPI_CONTROL_PAD:{ 460 struct hpi_control_cache_pad *p_pad; 461 p_pad = (struct hpi_control_cache_pad *)pC; 462 463 if (!(p_pad->field_valid_flags & (1 << 464 HPI_CTL_ATTR_INDEX(phm->u.c. 465 attribute)))) { 466 phr->error = 467 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 468 break; 469 } 470 471 if (phm->u.c.attribute == HPI_PAD_PROGRAM_ID) 472 phr->u.c.param1 = p_pad->pI; 473 else if (phm->u.c.attribute == HPI_PAD_PROGRAM_TYPE) 474 phr->u.c.param1 = p_pad->pTY; 475 else { 476 unsigned int index = 477 HPI_CTL_ATTR_INDEX(phm->u.c. 478 attribute) - 1; 479 unsigned int offset = phm->u.c.param1; 480 unsigned int pad_string_len, field_size; 481 char *pad_string; 482 unsigned int tocopy; 483 484 if (index > ARRAY_SIZE(pad_desc) - 1) { 485 phr->error = 486 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 487 break; 488 } 489 490 pad_string = 491 ((char *)p_pad) + 492 pad_desc[index].offset; 493 field_size = pad_desc[index].field_size; 494 /* Ensure null terminator */ 495 pad_string[field_size - 1] = 0; 496 497 pad_string_len = strlen(pad_string) + 1; 498 499 if (offset > pad_string_len) { 500 phr->error = 501 HPI_ERROR_INVALID_CONTROL_VALUE; 502 break; 503 } 504 505 tocopy = pad_string_len - offset; 506 if (tocopy > sizeof(phr->u.cu.chars8.sz_data)) 507 tocopy = sizeof(phr->u.cu.chars8. 508 sz_data); 509 510 memcpy(phr->u.cu.chars8.sz_data, 511 &pad_string[offset], tocopy); 512 513 phr->u.cu.chars8.remaining_chars = 514 pad_string_len - offset - tocopy; 515 } 516 } 517 break; 518 default: 519 found = 0; 520 break; 521 } 522 523 HPI_DEBUG_LOG(VERBOSE, "%s Adap %d, Ctl %d, Type %d, Attr %d\n", 524 found ? "Cached" : "Uncached", phm->adapter_index, 525 pC->u.i.control_index, pC->u.i.control_type, 526 phm->u.c.attribute); 527 528 if (found) { 529 phr->size = (u16)response_size; 530 phr->type = HPI_TYPE_RESPONSE; 531 phr->object = phm->object; 532 phr->function = phm->function; 533 } 534 535 return found; 536 } 537 538 short hpi_check_control_cache(struct hpi_control_cache *p_cache, 539 struct hpi_message *phm, struct hpi_response *phr) 540 { 541 struct hpi_control_cache_info *pI; 542 543 if (!find_control(phm->obj_index, p_cache, &pI)) { 544 HPI_DEBUG_LOG(VERBOSE, 545 "HPICMN find_control() failed for adap %d\n", 546 phm->adapter_index); 547 return 0; 548 } 549 550 phr->error = 0; 551 phr->specific_error = 0; 552 phr->version = 0; 553 554 return hpi_check_control_cache_single((struct hpi_control_cache_single 555 *)pI, phm, phr); 556 } 557 558 /** Updates the cache with Set values. 559 560 Only update if no error. 561 Volume and Level return the limited values in the response, so use these 562 Multiplexer does so use sent values 563 */ 564 void hpi_cmn_control_cache_sync_to_msg_single(struct hpi_control_cache_single 565 *pC, struct hpi_message *phm, struct hpi_response *phr) 566 { 567 switch (pC->u.i.control_type) { 568 case HPI_CONTROL_VOLUME: 569 if (phm->u.c.attribute == HPI_VOLUME_GAIN) { 570 pC->u.vol.an_log[0] = phr->u.c.an_log_value[0]; 571 pC->u.vol.an_log[1] = phr->u.c.an_log_value[1]; 572 } else if (phm->u.c.attribute == HPI_VOLUME_MUTE) { 573 if (phm->u.c.param1) 574 pC->u.vol.flags |= HPI_VOLUME_FLAG_MUTED; 575 else 576 pC->u.vol.flags &= ~HPI_VOLUME_FLAG_MUTED; 577 } 578 break; 579 case HPI_CONTROL_MULTIPLEXER: 580 /* mux does not return its setting on Set command. */ 581 if (phm->u.c.attribute == HPI_MULTIPLEXER_SOURCE) { 582 pC->u.mux.source_node_type = (u16)phm->u.c.param1; 583 pC->u.mux.source_node_index = (u16)phm->u.c.param2; 584 } 585 break; 586 case HPI_CONTROL_CHANNEL_MODE: 587 /* mode does not return its setting on Set command. */ 588 if (phm->u.c.attribute == HPI_CHANNEL_MODE_MODE) 589 pC->u.mode.mode = (u16)phm->u.c.param1; 590 break; 591 case HPI_CONTROL_LEVEL: 592 if (phm->u.c.attribute == HPI_LEVEL_GAIN) { 593 pC->u.vol.an_log[0] = phr->u.c.an_log_value[0]; 594 pC->u.vol.an_log[1] = phr->u.c.an_log_value[1]; 595 } 596 break; 597 case HPI_CONTROL_MICROPHONE: 598 if (phm->u.c.attribute == HPI_MICROPHONE_PHANTOM_POWER) 599 pC->u.microphone.phantom_state = (u16)phm->u.c.param1; 600 break; 601 case HPI_CONTROL_AESEBU_TRANSMITTER: 602 if (phm->u.c.attribute == HPI_AESEBUTX_FORMAT) 603 pC->u.aes3tx.format = phm->u.c.param1; 604 break; 605 case HPI_CONTROL_AESEBU_RECEIVER: 606 if (phm->u.c.attribute == HPI_AESEBURX_FORMAT) 607 pC->u.aes3rx.format = phm->u.c.param1; 608 break; 609 case HPI_CONTROL_SAMPLECLOCK: 610 if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE) 611 pC->u.clk.source = (u16)phm->u.c.param1; 612 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE_INDEX) 613 pC->u.clk.source_index = (u16)phm->u.c.param1; 614 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SAMPLERATE) 615 pC->u.clk.sample_rate = phm->u.c.param1; 616 break; 617 default: 618 break; 619 } 620 } 621 622 void hpi_cmn_control_cache_sync_to_msg(struct hpi_control_cache *p_cache, 623 struct hpi_message *phm, struct hpi_response *phr) 624 { 625 struct hpi_control_cache_single *pC; 626 struct hpi_control_cache_info *pI; 627 628 if (phr->error) 629 return; 630 631 if (!find_control(phm->obj_index, p_cache, &pI)) { 632 HPI_DEBUG_LOG(VERBOSE, 633 "HPICMN find_control() failed for adap %d\n", 634 phm->adapter_index); 635 return; 636 } 637 638 /* pC is the default cached control strucure. 639 May be cast to something else in the following switch statement. 640 */ 641 pC = (struct hpi_control_cache_single *)pI; 642 643 hpi_cmn_control_cache_sync_to_msg_single(pC, phm, phr); 644 } 645 646 /** Allocate control cache. 647 648 \return Cache pointer, or NULL if allocation fails. 649 */ 650 struct hpi_control_cache *hpi_alloc_control_cache(const u32 control_count, 651 const u32 size_in_bytes, u8 *p_dsp_control_buffer) 652 { 653 struct hpi_control_cache *p_cache = 654 kmalloc(sizeof(*p_cache), GFP_KERNEL); 655 if (!p_cache) 656 return NULL; 657 658 p_cache->p_info = 659 kcalloc(control_count, sizeof(*p_cache->p_info), GFP_KERNEL); 660 if (!p_cache->p_info) { 661 kfree(p_cache); 662 return NULL; 663 } 664 665 p_cache->cache_size_in_bytes = size_in_bytes; 666 p_cache->control_count = control_count; 667 p_cache->p_cache = p_dsp_control_buffer; 668 p_cache->init = 0; 669 return p_cache; 670 } 671 672 void hpi_free_control_cache(struct hpi_control_cache *p_cache) 673 { 674 if (p_cache) { 675 kfree(p_cache->p_info); 676 kfree(p_cache); 677 } 678 } 679 680 static void subsys_message(struct hpi_message *phm, struct hpi_response *phr) 681 { 682 hpi_init_response(phr, HPI_OBJ_SUBSYSTEM, phm->function, 0); 683 684 switch (phm->function) { 685 case HPI_SUBSYS_OPEN: 686 case HPI_SUBSYS_CLOSE: 687 case HPI_SUBSYS_DRIVER_UNLOAD: 688 break; 689 case HPI_SUBSYS_DRIVER_LOAD: 690 wipe_adapter_list(); 691 hpios_alistlock_init(&adapters); 692 break; 693 case HPI_SUBSYS_GET_ADAPTER: 694 subsys_get_adapter(phm, phr); 695 break; 696 case HPI_SUBSYS_GET_NUM_ADAPTERS: 697 phr->u.s.num_adapters = adapters.gw_num_adapters; 698 break; 699 case HPI_SUBSYS_CREATE_ADAPTER: 700 break; 701 default: 702 phr->error = HPI_ERROR_INVALID_FUNC; 703 break; 704 } 705 } 706 707 void HPI_COMMON(struct hpi_message *phm, struct hpi_response *phr) 708 { 709 switch (phm->type) { 710 case HPI_TYPE_REQUEST: 711 switch (phm->object) { 712 case HPI_OBJ_SUBSYSTEM: 713 subsys_message(phm, phr); 714 break; 715 } 716 break; 717 718 default: 719 phr->error = HPI_ERROR_INVALID_TYPE; 720 break; 721 } 722 } 723