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 "hpicmn.h"
  30
  31 struct hpi_adapters_list {
  32         struct hpios_spinlock list_lock;
  33         struct hpi_adapter_obj adapter[HPI_MAX_ADAPTERS];
  34         u16 gw_num_adapters;
  35 };
  36
  37 static struct hpi_adapters_list adapters;
  38
  39 /**
  40 * Given an HPI Message that was sent out and a response that was received,
  41 * validate that the response has the correct fields filled in,
  42 * i.e ObjectType, Function etc
  43 **/
  44 u16 hpi_validate_response(struct hpi_message *phm, struct hpi_response *phr)
  45 {
  46         u16 error = 0;
  47
  48         if ((phr->type != HPI_TYPE_RESPONSE)
  49                 || (phr->object != phm->object)
  50                 || (phr->function != phm->function))
  51                 error = HPI_ERROR_INVALID_RESPONSE;
  52
  53         return error;
  54 }
  55
  56 u16 hpi_add_adapter(struct hpi_adapter_obj *pao)
  57 {
  58         u16 retval = 0;
  59         /*HPI_ASSERT(pao->wAdapterType); */
  60
  61         hpios_alistlock_lock(&adapters);
  62
  63         if (pao->index >= HPI_MAX_ADAPTERS) {
  64                 retval = HPI_ERROR_BAD_ADAPTER_NUMBER;
  65                 goto unlock;
  66         }
  67
  68         if (adapters.adapter[pao->index].adapter_type) {
  69                 {
  70                         retval = HPI_DUPLICATE_ADAPTER_NUMBER;
  71                         goto unlock;
  72                 }
  73         }
  74         adapters.adapter[pao->index] = *pao;
  75         hpios_dsplock_init(&adapters.adapter[pao->index]);
  76         adapters.gw_num_adapters++;
  77
  78 unlock:
  79         hpios_alistlock_un_lock(&adapters);
  80         return retval;
  81 }
  82
  83 void hpi_delete_adapter(struct hpi_adapter_obj *pao)
  84 {
  85         memset(pao, 0, sizeof(struct hpi_adapter_obj));
  86
  87         hpios_alistlock_lock(&adapters);
  88         adapters.gw_num_adapters--;     /* dec the number of adapters */
  89         hpios_alistlock_un_lock(&adapters);
  90 }
  91
  92 /**
  93 * FindAdapter returns a pointer to the struct hpi_adapter_obj with
  94 * index wAdapterIndex in an HPI_ADAPTERS_LIST structure.
  95 *
  96 */
  97 struct hpi_adapter_obj *hpi_find_adapter(u16 adapter_index)
  98 {
  99         struct hpi_adapter_obj *pao = NULL;
 100
 101         if (adapter_index >= HPI_MAX_ADAPTERS) {
 102                 HPI_DEBUG_LOG(VERBOSE, "find_adapter invalid index %d ",
 103                         adapter_index);
 104                 return NULL;
 105         }
 106
 107         pao = &adapters.adapter[adapter_index];
 108         if (pao->adapter_type != 0) {
 109                 /*
 110                    HPI_DEBUG_LOG(VERBOSE, "Found adapter index %d\n",
 111                    wAdapterIndex);
 112                  */
 113                 return pao;
 114         } else {
 115                 /*
 116                    HPI_DEBUG_LOG(VERBOSE, "No adapter index %d\n",
 117                    wAdapterIndex);
 118                  */
 119                 return NULL;
 120         }
 121 }
 122
 123 /**
 124 *
 125 * wipe an HPI_ADAPTERS_LIST structure.
 126 *
 127 **/
 128 static void wipe_adapter_list(void
 129         )
 130 {
 131         memset(&adapters, 0, sizeof(adapters));
 132 }
 133
 134 /**
 135 * SubSysGetAdapters fills awAdapterList in an struct hpi_response structure
 136 * with all adapters in the given HPI_ADAPTERS_LIST.
 137 *
 138 */
 139 static void subsys_get_adapters(struct hpi_response *phr)
 140 {
 141         /* fill in the response adapter array with the position */
 142         /* identified by the adapter number/index of the adapters in */
 143         /* this HPI */
 144         /* i.e. if we have an A120 with it's jumper set to */
 145         /* Adapter Number 2 then put an Adapter type A120 in the */
 146         /* array in position 1 */
 147         /* NOTE: AdapterNumber is 1..N, Index is 0..N-1 */
 148
 149         /* input:  NONE */
 150         /* output: wNumAdapters */
 151         /*                 awAdapter[] */
 152         /* */
 153
 154         short i;
 155         struct hpi_adapter_obj *pao = NULL;
 156
 157         HPI_DEBUG_LOG(VERBOSE, "subsys_get_adapters\n");
 158
 159         /* for each adapter, place it's type in the position of the array */
 160         /* corresponding to it's adapter number */
 161         for (i = 0; i < adapters.gw_num_adapters; i++) {
 162                 pao = &adapters.adapter[i];
 163                 if (phr->u.s.aw_adapter_list[pao->index] != 0) {
 164                         phr->error = HPI_DUPLICATE_ADAPTER_NUMBER;
 165                         phr->specific_error = pao->index;
 166                         return;
 167                 }
 168                 phr->u.s.aw_adapter_list[pao->index] = pao->adapter_type;
 169         }
 170
 171         phr->u.s.num_adapters = adapters.gw_num_adapters;
 172         phr->error = 0; /* the function completed OK; */
 173 }
 174
 175 static unsigned int control_cache_alloc_check(struct hpi_control_cache *pC)
 176 {
 177         unsigned int i;
 178         int cached = 0;
 179         if (!pC)
 180                 return 0;
 181         if ((!pC->init) && (pC->p_cache != NULL) && (pC->control_count)
 182                 && (pC->cache_size_in_bytes)
 183                 ) {
 184                 u32 *p_master_cache;
 185                 pC->init = 1;
 186
 187                 p_master_cache = (u32 *)pC->p_cache;
 188                 HPI_DEBUG_LOG(VERBOSE, "check %d controls\n",
 189                         pC->control_count);
 190                 for (i = 0; i < pC->control_count; i++) {
 191                         struct hpi_control_cache_info *info =
 192                                 (struct hpi_control_cache_info *)
 193                                 p_master_cache;
 194
 195                         if (info->control_type) {
 196                                 pC->p_info[i] = info;
 197                                 cached++;
 198                         } else
 199                                 pC->p_info[i] = NULL;
 200
 201                         if (info->size_in32bit_words)
 202                                 p_master_cache += info->size_in32bit_words;
 203                         else
 204                                 p_master_cache +=
 205                                         sizeof(struct
 206                                         hpi_control_cache_single) /
 207                                         sizeof(u32);
 208
 209                         HPI_DEBUG_LOG(VERBOSE,
 210                                 "cached %d, pinfo %p index %d type %d\n",
 211                                 cached, pC->p_info[i], info->control_index,
 212                                 info->control_type);
 213                 }
 214                 /*
 215                    We didn't find anything to cache, so try again later !
 216                  */
 217                 if (!cached)
 218                         pC->init = 0;
 219         }
 220         return pC->init;
 221 }
 222
 223 /** Find a control.
 224 */
 225 static short find_control(struct hpi_message *phm,
 226         struct hpi_control_cache *p_cache, struct hpi_control_cache_info **pI,
 227         u16 *pw_control_index)
 228 {
 229         *pw_control_index = phm->obj_index;
 230
 231         if (!control_cache_alloc_check(p_cache)) {
 232                 HPI_DEBUG_LOG(VERBOSE,
 233                         "control_cache_alloc_check() failed. adap%d ci%d\n",
 234                         phm->adapter_index, *pw_control_index);
 235                 return 0;
 236         }
 237
 238         *pI = p_cache->p_info[*pw_control_index];
 239         if (!*pI) {
 240                 HPI_DEBUG_LOG(VERBOSE, "uncached adap %d, control %d\n",
 241                         phm->adapter_index, *pw_control_index);
 242                 return 0;
 243         } else {
 244                 HPI_DEBUG_LOG(VERBOSE, "find_control() type %d\n",
 245                         (*pI)->control_type);
 246         }
 247         return 1;
 248 }
 249
 250 /** Used by the kernel driver to figure out if a buffer needs mapping.
 251  */
 252 short hpi_check_buffer_mapping(struct hpi_control_cache *p_cache,
 253         struct hpi_message *phm, void **p, unsigned int *pN)
 254 {
 255         *pN = 0;
 256         *p = NULL;
 257         if ((phm->function == HPI_CONTROL_GET_STATE)
 258                 && (phm->object == HPI_OBJ_CONTROLEX)
 259                 ) {
 260                 u16 control_index;
 261                 struct hpi_control_cache_info *pI;
 262
 263                 if (!find_control(phm, p_cache, &pI, &control_index))
 264                         return 0;
 265         }
 266         return 0;
 267 }
 268
 269 /* allow unified treatment of several string fields within struct */
 270 #define HPICMN_PAD_OFS_AND_SIZE(m)  {\
 271         offsetof(struct hpi_control_cache_pad, m), \
 272         sizeof(((struct hpi_control_cache_pad *)(NULL))->m) }
 273
 274 struct pad_ofs_size {
 275         unsigned int offset;
 276         unsigned int field_size;
 277 };
 278
 279 static struct pad_ofs_size pad_desc[] = {
 280         HPICMN_PAD_OFS_AND_SIZE(c_channel),     /* HPI_PAD_CHANNEL_NAME */
 281         HPICMN_PAD_OFS_AND_SIZE(c_artist),      /* HPI_PAD_ARTIST */
 282         HPICMN_PAD_OFS_AND_SIZE(c_title),       /* HPI_PAD_TITLE */
 283         HPICMN_PAD_OFS_AND_SIZE(c_comment),     /* HPI_PAD_COMMENT */
 284 };
 285
 286 /** CheckControlCache checks the cache and fills the struct hpi_response
 287  * accordingly. It returns one if a cache hit occurred, zero otherwise.
 288  */
 289 short hpi_check_control_cache(struct hpi_control_cache *p_cache,
 290         struct hpi_message *phm, struct hpi_response *phr)
 291 {
 292         short found = 1;
 293         u16 control_index;
 294         struct hpi_control_cache_info *pI;
 295         struct hpi_control_cache_single *pC;
 296         struct hpi_control_cache_pad *p_pad;
 297
 298         if (!find_control(phm, p_cache, &pI, &control_index))
 299                 return 0;
 300
 301         phr->error = 0;
 302
 303         /* pC is the default cached control strucure. May be cast to
 304            something else in the following switch statement.
 305          */
 306         pC = (struct hpi_control_cache_single *)pI;
 307         p_pad = (struct hpi_control_cache_pad *)pI;
 308
 309         switch (pI->control_type) {
 310
 311         case HPI_CONTROL_METER:
 312                 if (phm->u.c.attribute == HPI_METER_PEAK) {
 313                         phr->u.c.an_log_value[0] = pC->u.p.an_log_peak[0];
 314                         phr->u.c.an_log_value[1] = pC->u.p.an_log_peak[1];
 315                 } else if (phm->u.c.attribute == HPI_METER_RMS) {
 316                         phr->u.c.an_log_value[0] = pC->u.p.an_logRMS[0];
 317                         phr->u.c.an_log_value[1] = pC->u.p.an_logRMS[1];
 318                 } else
 319                         found = 0;
 320                 break;
 321         case HPI_CONTROL_VOLUME:
 322                 if (phm->u.c.attribute == HPI_VOLUME_GAIN) {
 323                         phr->u.c.an_log_value[0] = pC->u.v.an_log[0];
 324                         phr->u.c.an_log_value[1] = pC->u.v.an_log[1];
 325                 } else
 326                         found = 0;
 327                 break;
 328         case HPI_CONTROL_MULTIPLEXER:
 329                 if (phm->u.c.attribute == HPI_MULTIPLEXER_SOURCE) {
 330                         phr->u.c.param1 = pC->u.x.source_node_type;
 331                         phr->u.c.param2 = pC->u.x.source_node_index;
 332                 } else {
 333                         found = 0;
 334                 }
 335                 break;
 336         case HPI_CONTROL_CHANNEL_MODE:
 337                 if (phm->u.c.attribute == HPI_CHANNEL_MODE_MODE)
 338                         phr->u.c.param1 = pC->u.m.mode;
 339                 else
 340                         found = 0;
 341                 break;
 342         case HPI_CONTROL_LEVEL:
 343                 if (phm->u.c.attribute == HPI_LEVEL_GAIN) {
 344                         phr->u.c.an_log_value[0] = pC->u.l.an_log[0];
 345                         phr->u.c.an_log_value[1] = pC->u.l.an_log[1];
 346                 } else
 347                         found = 0;
 348                 break;
 349         case HPI_CONTROL_TUNER:
 350                 if (phm->u.c.attribute == HPI_TUNER_FREQ)
 351                         phr->u.c.param1 = pC->u.t.freq_ink_hz;
 352                 else if (phm->u.c.attribute == HPI_TUNER_BAND)
 353                         phr->u.c.param1 = pC->u.t.band;
 354                 else if ((phm->u.c.attribute == HPI_TUNER_LEVEL)
 355                         && (phm->u.c.param1 == HPI_TUNER_LEVEL_AVERAGE))
 356                         phr->u.c.param1 = pC->u.t.level;
 357                 else
 358                         found = 0;
 359                 break;
 360         case HPI_CONTROL_AESEBU_RECEIVER:
 361                 if (phm->u.c.attribute == HPI_AESEBURX_ERRORSTATUS)
 362                         phr->u.c.param1 = pC->u.aes3rx.error_status;
 363                 else if (phm->u.c.attribute == HPI_AESEBURX_FORMAT)
 364                         phr->u.c.param1 = pC->u.aes3rx.source;
 365                 else
 366                         found = 0;
 367                 break;
 368         case HPI_CONTROL_AESEBU_TRANSMITTER:
 369                 if (phm->u.c.attribute == HPI_AESEBUTX_FORMAT)
 370                         phr->u.c.param1 = pC->u.aes3tx.format;
 371                 else
 372                         found = 0;
 373                 break;
 374         case HPI_CONTROL_TONEDETECTOR:
 375                 if (phm->u.c.attribute == HPI_TONEDETECTOR_STATE)
 376                         phr->u.c.param1 = pC->u.tone.state;
 377                 else
 378                         found = 0;
 379                 break;
 380         case HPI_CONTROL_SILENCEDETECTOR:
 381                 if (phm->u.c.attribute == HPI_SILENCEDETECTOR_STATE) {
 382                         phr->u.c.param1 = pC->u.silence.state;
 383                         phr->u.c.param2 = pC->u.silence.count;
 384                 } else
 385                         found = 0;
 386                 break;
 387         case HPI_CONTROL_MICROPHONE:
 388                 if (phm->u.c.attribute == HPI_MICROPHONE_PHANTOM_POWER)
 389                         phr->u.c.param1 = pC->u.phantom_power.state;
 390                 else
 391                         found = 0;
 392                 break;
 393         case HPI_CONTROL_SAMPLECLOCK:
 394                 if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE)
 395                         phr->u.c.param1 = pC->u.clk.source;
 396                 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE_INDEX) {
 397                         if (pC->u.clk.source_index ==
 398                                 HPI_ERROR_ILLEGAL_CACHE_VALUE) {
 399                                 phr->u.c.param1 = 0;
 400                                 phr->error = HPI_ERROR_INVALID_OPERATION;
 401                         } else
 402                                 phr->u.c.param1 = pC->u.clk.source_index;
 403                 } else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SAMPLERATE)
 404                         phr->u.c.param1 = pC->u.clk.sample_rate;
 405                 else
 406                         found = 0;
 407                 break;
 408         case HPI_CONTROL_PAD:
 409
 410                 if (!(p_pad->field_valid_flags & (1 <<
 411                                         HPI_CTL_ATTR_INDEX(phm->u.c.
 412                                                 attribute)))) {
 413                         phr->error = HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
 414                         break;
 415                 }
 416
 417                 if (phm->u.c.attribute == HPI_PAD_PROGRAM_ID)
 418                         phr->u.c.param1 = p_pad->pI;
 419                 else if (phm->u.c.attribute == HPI_PAD_PROGRAM_TYPE)
 420                         phr->u.c.param1 = p_pad->pTY;
 421                 else {
 422                         unsigned int index =
 423                                 HPI_CTL_ATTR_INDEX(phm->u.c.attribute) - 1;
 424                         unsigned int offset = phm->u.c.param1;
 425                         unsigned int pad_string_len, field_size;
 426                         char *pad_string;
 427                         unsigned int tocopy;
 428
 429                         HPI_DEBUG_LOG(VERBOSE, "PADS HPI_PADS_ %d\n",
 430                                 phm->u.c.attribute);
 431
 432                         if (index > ARRAY_SIZE(pad_desc) - 1) {
 433                                 phr->error =
 434                                         HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
 435                                 break;
 436                         }
 437
 438                         pad_string = ((char *)p_pad) + pad_desc[index].offset;
 439                         field_size = pad_desc[index].field_size;
 440                         /* Ensure null terminator */
 441                         pad_string[field_size - 1] = 0;
 442
 443                         pad_string_len = strlen(pad_string) + 1;
 444
 445                         if (offset > pad_string_len) {
 446                                 phr->error = HPI_ERROR_INVALID_CONTROL_VALUE;
 447                                 break;
 448                         }
 449
 450                         tocopy = pad_string_len - offset;
 451                         if (tocopy > sizeof(phr->u.cu.chars8.sz_data))
 452                                 tocopy = sizeof(phr->u.cu.chars8.sz_data);
 453
 454                         HPI_DEBUG_LOG(VERBOSE,
 455                                 "PADS memcpy(%d), offset %d \n", tocopy,
 456                                 offset);
 457                         memcpy(phr->u.cu.chars8.sz_data, &pad_string[offset],
 458                                 tocopy);
 459
 460                         phr->u.cu.chars8.remaining_chars =
 461                                 pad_string_len - offset - tocopy;
 462                 }
 463                 break;
 464         default:
 465                 found = 0;
 466                 break;
 467         }
 468
 469         if (found)
 470                 HPI_DEBUG_LOG(VERBOSE,
 471                         "cached adap %d, ctl %d, type %d, attr %d\n",
 472                         phm->adapter_index, pI->control_index,
 473                         pI->control_type, phm->u.c.attribute);
 474         else
 475                 HPI_DEBUG_LOG(VERBOSE,
 476                         "uncached adap %d, ctl %d, ctl type %d\n",
 477                         phm->adapter_index, pI->control_index,
 478                         pI->control_type);
 479
 480         if (found)
 481                 phr->size =
 482                         sizeof(struct hpi_response_header) +
 483                         sizeof(struct hpi_control_res);
 484
 485         return found;
 486 }
 487
 488 /** Updates the cache with Set values.
 489
 490 Only update if no error.
 491 Volume and Level return the limited values in the response, so use these
 492 Multiplexer does so use sent values
 493 */
 494 void hpi_sync_control_cache(struct hpi_control_cache *p_cache,
 495         struct hpi_message *phm, struct hpi_response *phr)
 496 {
 497         u16 control_index;
 498         struct hpi_control_cache_single *pC;
 499         struct hpi_control_cache_info *pI;
 500
 501         if (phr->error)
 502                 return;
 503
 504         if (!find_control(phm, p_cache, &pI, &control_index))
 505                 return;
 506
 507         /* pC is the default cached control strucure.
 508            May be cast to something else in the following switch statement.
 509          */
 510         pC = (struct hpi_control_cache_single *)pI;
 511
 512         switch (pI->control_type) {
 513         case HPI_CONTROL_VOLUME:
 514                 if (phm->u.c.attribute == HPI_VOLUME_GAIN) {
 515                         pC->u.v.an_log[0] = phr->u.c.an_log_value[0];
 516                         pC->u.v.an_log[1] = phr->u.c.an_log_value[1];
 517                 }
 518                 break;
 519         case HPI_CONTROL_MULTIPLEXER:
 520                 /* mux does not return its setting on Set command. */
 521                 if (phm->u.c.attribute == HPI_MULTIPLEXER_SOURCE) {
 522                         pC->u.x.source_node_type = (u16)phm->u.c.param1;
 523                         pC->u.x.source_node_index = (u16)phm->u.c.param2;
 524                 }
 525                 break;
 526         case HPI_CONTROL_CHANNEL_MODE:
 527                 /* mode does not return its setting on Set command. */
 528                 if (phm->u.c.attribute == HPI_CHANNEL_MODE_MODE)
 529                         pC->u.m.mode = (u16)phm->u.c.param1;
 530                 break;
 531         case HPI_CONTROL_LEVEL:
 532                 if (phm->u.c.attribute == HPI_LEVEL_GAIN) {
 533                         pC->u.v.an_log[0] = phr->u.c.an_log_value[0];
 534                         pC->u.v.an_log[1] = phr->u.c.an_log_value[1];
 535                 }
 536                 break;
 537         case HPI_CONTROL_MICROPHONE:
 538                 if (phm->u.c.attribute == HPI_MICROPHONE_PHANTOM_POWER)
 539                         pC->u.phantom_power.state = (u16)phm->u.c.param1;
 540                 break;
 541         case HPI_CONTROL_AESEBU_TRANSMITTER:
 542                 if (phm->u.c.attribute == HPI_AESEBUTX_FORMAT)
 543                         pC->u.aes3tx.format = phm->u.c.param1;
 544                 break;
 545         case HPI_CONTROL_AESEBU_RECEIVER:
 546                 if (phm->u.c.attribute == HPI_AESEBURX_FORMAT)
 547                         pC->u.aes3rx.source = phm->u.c.param1;
 548                 break;
 549         case HPI_CONTROL_SAMPLECLOCK:
 550                 if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE)
 551                         pC->u.clk.source = (u16)phm->u.c.param1;
 552                 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE_INDEX)
 553                         pC->u.clk.source_index = (u16)phm->u.c.param1;
 554                 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SAMPLERATE)
 555                         pC->u.clk.sample_rate = phm->u.c.param1;
 556                 break;
 557         default:
 558                 break;
 559         }
 560 }
 561
 562 struct hpi_control_cache *hpi_alloc_control_cache(const u32
 563         number_of_controls, const u32 size_in_bytes,
 564         struct hpi_control_cache_info *pDSP_control_buffer)
 565 {
 566         struct hpi_control_cache *p_cache =
 567                 kmalloc(sizeof(*p_cache), GFP_KERNEL);
 568         p_cache->cache_size_in_bytes = size_in_bytes;
 569         p_cache->control_count = number_of_controls;
 570         p_cache->p_cache =
 571                 (struct hpi_control_cache_single *)pDSP_control_buffer;
 572         p_cache->init = 0;
 573         p_cache->p_info =
 574                 kmalloc(sizeof(*p_cache->p_info) * p_cache->control_count,
 575                 GFP_KERNEL);
 576         return p_cache;
 577 }
 578
 579 void hpi_free_control_cache(struct hpi_control_cache *p_cache)
 580 {
 581         if (p_cache->init) {
 582                 kfree(p_cache->p_info);
 583                 p_cache->p_info = NULL;
 584                 p_cache->init = 0;
 585                 kfree(p_cache);
 586         }
 587 }
 588
 589 static void subsys_message(struct hpi_message *phm, struct hpi_response *phr)
 590 {
 591
 592         switch (phm->function) {
 593         case HPI_SUBSYS_OPEN:
 594         case HPI_SUBSYS_CLOSE:
 595         case HPI_SUBSYS_DRIVER_UNLOAD:
 596                 phr->error = 0;
 597                 break;
 598         case HPI_SUBSYS_DRIVER_LOAD:
 599                 wipe_adapter_list();
 600                 hpios_alistlock_init(&adapters);
 601                 phr->error = 0;
 602                 break;
 603         case HPI_SUBSYS_GET_INFO:
 604                 subsys_get_adapters(phr);
 605                 break;
 606         case HPI_SUBSYS_CREATE_ADAPTER:
 607         case HPI_SUBSYS_DELETE_ADAPTER:
 608                 phr->error = 0;
 609                 break;
 610         default:
 611                 phr->error = HPI_ERROR_INVALID_FUNC;
 612                 break;
 613         }
 614 }
 615
 616 void HPI_COMMON(struct hpi_message *phm, struct hpi_response *phr)
 617 {
 618         switch (phm->type) {
 619         case HPI_TYPE_MESSAGE:
 620                 switch (phm->object) {
 621                 case HPI_OBJ_SUBSYSTEM:
 622                         subsys_message(phm, phr);
 623                         break;
 624                 }
 625                 break;
 626
 627         default:
 628                 phr->error = HPI_ERROR_INVALID_TYPE;
 629                 break;
 630         }
 631 }