1 /****************************************************************************** 2 3 AudioScience HPI driver 4 Copyright (C) 1997-2011 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 210 if (!info->size_in32bit_words) { 211 if (!i) { 212 HPI_DEBUG_LOG(INFO, 213 "adap %d cache not ready?\n", 214 pC->adap_idx); 215 return 0; 216 } 217 /* The cache is invalid. 218 * Minimum valid entry size is 219 * sizeof(struct hpi_control_cache_info) 220 */ 221 HPI_DEBUG_LOG(ERROR, 222 "adap %d zero size cache entry %d\n", 223 pC->adap_idx, i); 224 break; 225 } 226 227 if (info->control_type) { 228 pC->p_info[info->control_index] = info; 229 cached++; 230 } else { /* dummy cache entry */ 231 pC->p_info[info->control_index] = NULL; 232 } 233 234 byte_count += info->size_in32bit_words * 4; 235 236 HPI_DEBUG_LOG(VERBOSE, 237 "cached %d, pinfo %p index %d type %d size %d\n", 238 cached, pC->p_info[info->control_index], 239 info->control_index, info->control_type, 240 info->size_in32bit_words); 241 242 /* quit loop early if whole cache has been scanned. 243 * dwControlCount is the maximum possible entries 244 * but some may be absent from the cache 245 */ 246 if (byte_count >= pC->cache_size_in_bytes) 247 break; 248 /* have seen last control index */ 249 if (info->control_index == pC->control_count - 1) 250 break; 251 } 252 253 if (byte_count != pC->cache_size_in_bytes) 254 HPI_DEBUG_LOG(WARNING, 255 "adap %d bytecount %d != cache size %d\n", 256 pC->adap_idx, byte_count, 257 pC->cache_size_in_bytes); 258 else 259 HPI_DEBUG_LOG(DEBUG, 260 "adap %d cache good, bytecount == cache size = %d\n", 261 pC->adap_idx, byte_count); 262 263 pC->init = (u16)cached; 264 } 265 return pC->init; 266 } 267 268 /** Find a control. 269 */ 270 static short find_control(u16 control_index, 271 struct hpi_control_cache *p_cache, struct hpi_control_cache_info **pI) 272 { 273 if (!control_cache_alloc_check(p_cache)) { 274 HPI_DEBUG_LOG(VERBOSE, 275 "control_cache_alloc_check() failed %d\n", 276 control_index); 277 return 0; 278 } 279 280 *pI = p_cache->p_info[control_index]; 281 if (!*pI) { 282 HPI_DEBUG_LOG(VERBOSE, "Uncached Control %d\n", 283 control_index); 284 return 0; 285 } else { 286 HPI_DEBUG_LOG(VERBOSE, "find_control() type %d\n", 287 (*pI)->control_type); 288 } 289 return 1; 290 } 291 292 /* allow unified treatment of several string fields within struct */ 293 #define HPICMN_PAD_OFS_AND_SIZE(m) {\ 294 offsetof(struct hpi_control_cache_pad, m), \ 295 sizeof(((struct hpi_control_cache_pad *)(NULL))->m) } 296 297 struct pad_ofs_size { 298 unsigned int offset; 299 unsigned int field_size; 300 }; 301 302 static const struct pad_ofs_size pad_desc[] = { 303 HPICMN_PAD_OFS_AND_SIZE(c_channel), /* HPI_PAD_CHANNEL_NAME */ 304 HPICMN_PAD_OFS_AND_SIZE(c_artist), /* HPI_PAD_ARTIST */ 305 HPICMN_PAD_OFS_AND_SIZE(c_title), /* HPI_PAD_TITLE */ 306 HPICMN_PAD_OFS_AND_SIZE(c_comment), /* HPI_PAD_COMMENT */ 307 }; 308 309 /** CheckControlCache checks the cache and fills the struct hpi_response 310 * accordingly. It returns one if a cache hit occurred, zero otherwise. 311 */ 312 short hpi_check_control_cache(struct hpi_control_cache *p_cache, 313 struct hpi_message *phm, struct hpi_response *phr) 314 { 315 short found = 1; 316 struct hpi_control_cache_info *pI; 317 struct hpi_control_cache_single *pC; 318 size_t response_size; 319 if (!find_control(phm->obj_index, p_cache, &pI)) { 320 HPI_DEBUG_LOG(VERBOSE, 321 "HPICMN find_control() failed for adap %d\n", 322 phm->adapter_index); 323 return 0; 324 } 325 326 phr->error = 0; 327 phr->specific_error = 0; 328 phr->version = 0; 329 330 /* set the default response size */ 331 response_size = 332 sizeof(struct hpi_response_header) + 333 sizeof(struct hpi_control_res); 334 335 /* pC is the default cached control strucure. May be cast to 336 something else in the following switch statement. 337 */ 338 pC = (struct hpi_control_cache_single *)pI; 339 340 switch (pI->control_type) { 341 342 case HPI_CONTROL_METER: 343 if (phm->u.c.attribute == HPI_METER_PEAK) { 344 phr->u.c.an_log_value[0] = pC->u.meter.an_log_peak[0]; 345 phr->u.c.an_log_value[1] = pC->u.meter.an_log_peak[1]; 346 } else if (phm->u.c.attribute == HPI_METER_RMS) { 347 if (pC->u.meter.an_logRMS[0] == 348 HPI_CACHE_INVALID_SHORT) { 349 phr->error = 350 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 351 phr->u.c.an_log_value[0] = HPI_METER_MINIMUM; 352 phr->u.c.an_log_value[1] = HPI_METER_MINIMUM; 353 } else { 354 phr->u.c.an_log_value[0] = 355 pC->u.meter.an_logRMS[0]; 356 phr->u.c.an_log_value[1] = 357 pC->u.meter.an_logRMS[1]; 358 } 359 } else 360 found = 0; 361 break; 362 case HPI_CONTROL_VOLUME: 363 if (phm->u.c.attribute == HPI_VOLUME_GAIN) { 364 phr->u.c.an_log_value[0] = pC->u.vol.an_log[0]; 365 phr->u.c.an_log_value[1] = pC->u.vol.an_log[1]; 366 } else if (phm->u.c.attribute == HPI_VOLUME_MUTE) { 367 if (pC->u.vol.flags & HPI_VOLUME_FLAG_HAS_MUTE) { 368 if (pC->u.vol.flags & HPI_VOLUME_FLAG_MUTED) 369 phr->u.c.param1 = 370 HPI_BITMASK_ALL_CHANNELS; 371 else 372 phr->u.c.param1 = 0; 373 } else { 374 phr->error = 375 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 376 phr->u.c.param1 = 0; 377 } 378 } else { 379 found = 0; 380 } 381 break; 382 case HPI_CONTROL_MULTIPLEXER: 383 if (phm->u.c.attribute == HPI_MULTIPLEXER_SOURCE) { 384 phr->u.c.param1 = pC->u.mux.source_node_type; 385 phr->u.c.param2 = pC->u.mux.source_node_index; 386 } else { 387 found = 0; 388 } 389 break; 390 case HPI_CONTROL_CHANNEL_MODE: 391 if (phm->u.c.attribute == HPI_CHANNEL_MODE_MODE) 392 phr->u.c.param1 = pC->u.mode.mode; 393 else 394 found = 0; 395 break; 396 case HPI_CONTROL_LEVEL: 397 if (phm->u.c.attribute == HPI_LEVEL_GAIN) { 398 phr->u.c.an_log_value[0] = pC->u.level.an_log[0]; 399 phr->u.c.an_log_value[1] = pC->u.level.an_log[1]; 400 } else 401 found = 0; 402 break; 403 case HPI_CONTROL_TUNER: 404 if (phm->u.c.attribute == HPI_TUNER_FREQ) 405 phr->u.c.param1 = pC->u.tuner.freq_ink_hz; 406 else if (phm->u.c.attribute == HPI_TUNER_BAND) 407 phr->u.c.param1 = pC->u.tuner.band; 408 else if (phm->u.c.attribute == HPI_TUNER_LEVEL_AVG) 409 if (pC->u.tuner.s_level_avg == 410 HPI_CACHE_INVALID_SHORT) { 411 phr->u.cu.tuner.s_level = 0; 412 phr->error = 413 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 414 } else 415 phr->u.cu.tuner.s_level = 416 pC->u.tuner.s_level_avg; 417 else 418 found = 0; 419 break; 420 case HPI_CONTROL_AESEBU_RECEIVER: 421 if (phm->u.c.attribute == HPI_AESEBURX_ERRORSTATUS) 422 phr->u.c.param1 = pC->u.aes3rx.error_status; 423 else if (phm->u.c.attribute == HPI_AESEBURX_FORMAT) 424 phr->u.c.param1 = pC->u.aes3rx.format; 425 else 426 found = 0; 427 break; 428 case HPI_CONTROL_AESEBU_TRANSMITTER: 429 if (phm->u.c.attribute == HPI_AESEBUTX_FORMAT) 430 phr->u.c.param1 = pC->u.aes3tx.format; 431 else 432 found = 0; 433 break; 434 case HPI_CONTROL_TONEDETECTOR: 435 if (phm->u.c.attribute == HPI_TONEDETECTOR_STATE) 436 phr->u.c.param1 = pC->u.tone.state; 437 else 438 found = 0; 439 break; 440 case HPI_CONTROL_SILENCEDETECTOR: 441 if (phm->u.c.attribute == HPI_SILENCEDETECTOR_STATE) { 442 phr->u.c.param1 = pC->u.silence.state; 443 } else 444 found = 0; 445 break; 446 case HPI_CONTROL_MICROPHONE: 447 if (phm->u.c.attribute == HPI_MICROPHONE_PHANTOM_POWER) 448 phr->u.c.param1 = pC->u.microphone.phantom_state; 449 else 450 found = 0; 451 break; 452 case HPI_CONTROL_SAMPLECLOCK: 453 if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE) 454 phr->u.c.param1 = pC->u.clk.source; 455 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE_INDEX) { 456 if (pC->u.clk.source_index == 457 HPI_CACHE_INVALID_UINT16) { 458 phr->u.c.param1 = 0; 459 phr->error = 460 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 461 } else 462 phr->u.c.param1 = pC->u.clk.source_index; 463 } else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SAMPLERATE) 464 phr->u.c.param1 = pC->u.clk.sample_rate; 465 else 466 found = 0; 467 break; 468 case HPI_CONTROL_PAD:{ 469 struct hpi_control_cache_pad *p_pad; 470 p_pad = (struct hpi_control_cache_pad *)pI; 471 472 if (!(p_pad->field_valid_flags & (1 << 473 HPI_CTL_ATTR_INDEX(phm->u.c. 474 attribute)))) { 475 phr->error = 476 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 477 break; 478 } 479 480 if (phm->u.c.attribute == HPI_PAD_PROGRAM_ID) 481 phr->u.c.param1 = p_pad->pI; 482 else if (phm->u.c.attribute == HPI_PAD_PROGRAM_TYPE) 483 phr->u.c.param1 = p_pad->pTY; 484 else { 485 unsigned int index = 486 HPI_CTL_ATTR_INDEX(phm->u.c. 487 attribute) - 1; 488 unsigned int offset = phm->u.c.param1; 489 unsigned int pad_string_len, field_size; 490 char *pad_string; 491 unsigned int tocopy; 492 493 if (index > ARRAY_SIZE(pad_desc) - 1) { 494 phr->error = 495 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE; 496 break; 497 } 498 499 pad_string = 500 ((char *)p_pad) + 501 pad_desc[index].offset; 502 field_size = pad_desc[index].field_size; 503 /* Ensure null terminator */ 504 pad_string[field_size - 1] = 0; 505 506 pad_string_len = strlen(pad_string) + 1; 507 508 if (offset > pad_string_len) { 509 phr->error = 510 HPI_ERROR_INVALID_CONTROL_VALUE; 511 break; 512 } 513 514 tocopy = pad_string_len - offset; 515 if (tocopy > sizeof(phr->u.cu.chars8.sz_data)) 516 tocopy = sizeof(phr->u.cu.chars8. 517 sz_data); 518 519 memcpy(phr->u.cu.chars8.sz_data, 520 &pad_string[offset], tocopy); 521 522 phr->u.cu.chars8.remaining_chars = 523 pad_string_len - offset - tocopy; 524 } 525 } 526 break; 527 default: 528 found = 0; 529 break; 530 } 531 532 HPI_DEBUG_LOG(VERBOSE, "%s Adap %d, Ctl %d, Type %d, Attr %d\n", 533 found ? "Cached" : "Uncached", phm->adapter_index, 534 pI->control_index, pI->control_type, phm->u.c.attribute); 535 536 if (found) { 537 phr->size = (u16)response_size; 538 phr->type = HPI_TYPE_RESPONSE; 539 phr->object = phm->object; 540 phr->function = phm->function; 541 } 542 543 return found; 544 } 545 546 /** Updates the cache with Set values. 547 548 Only update if no error. 549 Volume and Level return the limited values in the response, so use these 550 Multiplexer does so use sent values 551 */ 552 void hpi_cmn_control_cache_sync_to_msg(struct hpi_control_cache *p_cache, 553 struct hpi_message *phm, struct hpi_response *phr) 554 { 555 struct hpi_control_cache_single *pC; 556 struct hpi_control_cache_info *pI; 557 558 if (phr->error) 559 return; 560 561 if (!find_control(phm->obj_index, p_cache, &pI)) { 562 HPI_DEBUG_LOG(VERBOSE, 563 "HPICMN find_control() failed for adap %d\n", 564 phm->adapter_index); 565 return; 566 } 567 568 /* pC is the default cached control strucure. 569 May be cast to something else in the following switch statement. 570 */ 571 pC = (struct hpi_control_cache_single *)pI; 572 573 switch (pI->control_type) { 574 case HPI_CONTROL_VOLUME: 575 if (phm->u.c.attribute == HPI_VOLUME_GAIN) { 576 pC->u.vol.an_log[0] = phr->u.c.an_log_value[0]; 577 pC->u.vol.an_log[1] = phr->u.c.an_log_value[1]; 578 } else if (phm->u.c.attribute == HPI_VOLUME_MUTE) { 579 if (phm->u.c.param1) 580 pC->u.vol.flags |= HPI_VOLUME_FLAG_MUTED; 581 else 582 pC->u.vol.flags &= ~HPI_VOLUME_FLAG_MUTED; 583 } 584 break; 585 case HPI_CONTROL_MULTIPLEXER: 586 /* mux does not return its setting on Set command. */ 587 if (phm->u.c.attribute == HPI_MULTIPLEXER_SOURCE) { 588 pC->u.mux.source_node_type = (u16)phm->u.c.param1; 589 pC->u.mux.source_node_index = (u16)phm->u.c.param2; 590 } 591 break; 592 case HPI_CONTROL_CHANNEL_MODE: 593 /* mode does not return its setting on Set command. */ 594 if (phm->u.c.attribute == HPI_CHANNEL_MODE_MODE) 595 pC->u.mode.mode = (u16)phm->u.c.param1; 596 break; 597 case HPI_CONTROL_LEVEL: 598 if (phm->u.c.attribute == HPI_LEVEL_GAIN) { 599 pC->u.vol.an_log[0] = phr->u.c.an_log_value[0]; 600 pC->u.vol.an_log[1] = phr->u.c.an_log_value[1]; 601 } 602 break; 603 case HPI_CONTROL_MICROPHONE: 604 if (phm->u.c.attribute == HPI_MICROPHONE_PHANTOM_POWER) 605 pC->u.microphone.phantom_state = (u16)phm->u.c.param1; 606 break; 607 case HPI_CONTROL_AESEBU_TRANSMITTER: 608 if (phm->u.c.attribute == HPI_AESEBUTX_FORMAT) 609 pC->u.aes3tx.format = phm->u.c.param1; 610 break; 611 case HPI_CONTROL_AESEBU_RECEIVER: 612 if (phm->u.c.attribute == HPI_AESEBURX_FORMAT) 613 pC->u.aes3rx.format = phm->u.c.param1; 614 break; 615 case HPI_CONTROL_SAMPLECLOCK: 616 if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE) 617 pC->u.clk.source = (u16)phm->u.c.param1; 618 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE_INDEX) 619 pC->u.clk.source_index = (u16)phm->u.c.param1; 620 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SAMPLERATE) 621 pC->u.clk.sample_rate = phm->u.c.param1; 622 break; 623 default: 624 break; 625 } 626 } 627 628 /** Allocate control cache. 629 630 \return Cache pointer, or NULL if allocation fails. 631 */ 632 struct hpi_control_cache *hpi_alloc_control_cache(const u32 control_count, 633 const u32 size_in_bytes, u8 *p_dsp_control_buffer) 634 { 635 struct hpi_control_cache *p_cache = 636 kmalloc(sizeof(*p_cache), GFP_KERNEL); 637 if (!p_cache) 638 return NULL; 639 640 p_cache->p_info = kcalloc(control_count, sizeof(*p_cache->p_info), 641 GFP_KERNEL); 642 if (!p_cache->p_info) { 643 kfree(p_cache); 644 return NULL; 645 } 646 p_cache->cache_size_in_bytes = size_in_bytes; 647 p_cache->control_count = control_count; 648 p_cache->p_cache = p_dsp_control_buffer; 649 p_cache->init = 0; 650 return p_cache; 651 } 652 653 void hpi_free_control_cache(struct hpi_control_cache *p_cache) 654 { 655 if (p_cache) { 656 kfree(p_cache->p_info); 657 kfree(p_cache); 658 } 659 } 660 661 static void subsys_message(struct hpi_message *phm, struct hpi_response *phr) 662 { 663 hpi_init_response(phr, HPI_OBJ_SUBSYSTEM, phm->function, 0); 664 665 switch (phm->function) { 666 case HPI_SUBSYS_OPEN: 667 case HPI_SUBSYS_CLOSE: 668 case HPI_SUBSYS_DRIVER_UNLOAD: 669 break; 670 case HPI_SUBSYS_DRIVER_LOAD: 671 wipe_adapter_list(); 672 hpios_alistlock_init(&adapters); 673 break; 674 case HPI_SUBSYS_GET_ADAPTER: 675 subsys_get_adapter(phm, phr); 676 break; 677 case HPI_SUBSYS_GET_NUM_ADAPTERS: 678 phr->u.s.num_adapters = adapters.gw_num_adapters; 679 break; 680 case HPI_SUBSYS_CREATE_ADAPTER: 681 break; 682 default: 683 phr->error = HPI_ERROR_INVALID_FUNC; 684 break; 685 } 686 } 687 688 void HPI_COMMON(struct hpi_message *phm, struct hpi_response *phr) 689 { 690 switch (phm->type) { 691 case HPI_TYPE_REQUEST: 692 switch (phm->object) { 693 case HPI_OBJ_SUBSYSTEM: 694 subsys_message(phm, phr); 695 break; 696 } 697 break; 698 699 default: 700 phr->error = HPI_ERROR_INVALID_TYPE; 701 break; 702 } 703 } 704