sound/pci/asihpi/hpicmn.c

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