projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: usb-audio - Add quirk for Roland / BOSS BR-800
[deliverable/linux.git] / sound / pci / asihpi / hpicmn.c
CommitLineData
719f82d3
EB		 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"
3285ea10
EB		 29#include "hpimsginit.h"
30
719f82d3
EB		 31#include "hpicmn.h"
32
33struct 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
39static 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**/
46u16 hpi_validate_response(struct hpi_message *phm, struct hpi_response *phr)
47{
3285ea10 48 if (phr->type != HPI_TYPE_RESPONSE) {
1528fbb5 49 HPI_DEBUG_LOG(ERROR, "header type %d invalid\n", phr->type);
3285ea10
EB		 50 return HPI_ERROR_INVALID_RESPONSE;
51 }
52
53 if (phr->object != phm->object) {
1528fbb5
EB		 54 HPI_DEBUG_LOG(ERROR, "header object %d invalid\n",
55 phr->object);
3285ea10
EB		 56 return HPI_ERROR_INVALID_RESPONSE;
57 }
719f82d3 58
3285ea10 59 if (phr->function != phm->function) {
1528fbb5
EB		 60 HPI_DEBUG_LOG(ERROR, "header type %d invalid\n",
61 phr->function);
3285ea10
EB		 62 return HPI_ERROR_INVALID_RESPONSE;
63 }
719f82d3 64
3285ea10 65 return 0;
719f82d3
EB		 66}
67
68u16 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) {
d6f1c1c3
EB		 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;
719f82d3
EB		 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
100unlock:
3285ea10 101 hpios_alistlock_unlock(&adapters);
719f82d3
EB		 102 return retval;
103}
104
105void hpi_delete_adapter(struct hpi_adapter_obj *pao)
106{
3285ea10
EB		 107 if (!pao->adapter_type) {
108 HPI_DEBUG_LOG(ERROR, "removing null adapter?\n");
109 return;
110 }
719f82d3
EB		 111
112 hpios_alistlock_lock(&adapters);
3285ea10
EB		 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);
719f82d3
EB		 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*/
124struct 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) {
1528fbb5 129 HPI_DEBUG_LOG(VERBOSE, "find_adapter invalid index %d\n",
719f82d3
EB		 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**/
3285ea10 155static void wipe_adapter_list(void)
719f82d3
EB		 156{
157 memset(&adapters, 0, sizeof(adapters));
158}
159
3285ea10
EB		 160static void subsys_get_adapter(struct hpi_message *phm,
161 struct hpi_response *phr)
719f82d3 162{
3285ea10
EB		 163 int count = phm->obj_index;
164 u16 index = 0;
719f82d3 165
3285ea10
EB		 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) {
4704998e 169 if (!count)
3285ea10
EB		 170 break;
171 count--;
719f82d3 172 }
719f82d3
EB		 173 }
174
3285ea10
EB		 175 if (index < HPI_MAX_ADAPTERS) {
176 phr->u.s.adapter_index = adapters.adapter[index].index;
2f918a64 177 phr->u.s.adapter_type = adapters.adapter[index].adapter_type;
3285ea10
EB		 178 } else {
179 phr->u.s.adapter_index = 0;
2f918a64 180 phr->u.s.adapter_type = 0;
3285ea10
EB		 181 phr->error = HPI_ERROR_BAD_ADAPTER_NUMBER;
182 }
719f82d3
EB		 183}
184
185static 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;
719f82d3 191
3285ea10
EB		 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",
719f82d3
EB		 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 *)
3285ea10
EB		 208 &p_master_cache[byte_count];
209
210 if (!info->size_in32bit_words) {
4704998e 211 if (!i) {
ffdb5787
EB		 212 HPI_DEBUG_LOG(INFO,
213 "adap %d cache not ready?\n",
214 pC->adap_idx);
215 return 0;
216 }
1528fbb5
EB		 217 /* The cache is invalid.
218 * Minimum valid entry size is
219 * sizeof(struct hpi_control_cache_info)
220 */
3285ea10 221 HPI_DEBUG_LOG(ERROR,
ffdb5787
EB		 222 "adap %d zero size cache entry %d\n",
223 pC->adap_idx, i);
3285ea10
EB		 224 break;
225 }
719f82d3
EB		 226
227 if (info->control_type) {
3285ea10 228 pC->p_info[info->control_index] = info;
719f82d3 229 cached++;
42258dab 230 } else { /* dummy cache entry */
3285ea10 231 pC->p_info[info->control_index] = NULL;
42258dab 232 }
719f82d3 233
3285ea10 234 byte_count += info->size_in32bit_words * 4;
719f82d3
EB		 235
236 HPI_DEBUG_LOG(VERBOSE,
3285ea10
EB		 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
1528fbb5
EB		 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 */
3285ea10
EB		 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;
719f82d3 251 }
3285ea10
EB		 252
253 if (byte_count != pC->cache_size_in_bytes)
254 HPI_DEBUG_LOG(WARNING,
1528fbb5 255 "adap %d bytecount %d != cache size %d\n",
ffdb5787 256 pC->adap_idx, byte_count,
3285ea10
EB		 257 pC->cache_size_in_bytes);
258 else
259 HPI_DEBUG_LOG(DEBUG,
1528fbb5 260 "adap %d cache good, bytecount == cache size = %d\n",
ffdb5787 261 pC->adap_idx, byte_count);
3285ea10 262
1528fbb5 263 pC->init = (u16)cached;
719f82d3
EB		 264 }
265 return pC->init;
266}
267
268/** Find a control.
269*/
3285ea10
EB		 270static short find_control(u16 control_index,
271 struct hpi_control_cache *p_cache, struct hpi_control_cache_info **pI)
719f82d3 272{
719f82d3
EB		 273 if (!control_cache_alloc_check(p_cache)) {
274 HPI_DEBUG_LOG(VERBOSE,
3285ea10
EB		 275 "control_cache_alloc_check() failed %d\n",
276 control_index);
719f82d3
EB		 277 return 0;
278 }
279
3285ea10 280 *pI = p_cache->p_info[control_index];
719f82d3 281 if (!*pI) {
3285ea10
EB		 282 HPI_DEBUG_LOG(VERBOSE, "Uncached Control %d\n",
283 control_index);
719f82d3
EB		 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
719f82d3
EB		 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
297struct pad_ofs_size {
298 unsigned int offset;
299 unsigned int field_size;
300};
301
42258dab 302static const struct pad_ofs_size pad_desc[] = {
719f82d3
EB		 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 */
312short hpi_check_control_cache(struct hpi_control_cache *p_cache,
313 struct hpi_message *phm, struct hpi_response *phr)
314{
315 short found = 1;
719f82d3
EB		 316 struct hpi_control_cache_info *pI;
317 struct hpi_control_cache_single *pC;
318 struct hpi_control_cache_pad *p_pad;
319
3285ea10
EB		 320 if (!find_control(phm->obj_index, p_cache, &pI)) {
321 HPI_DEBUG_LOG(VERBOSE,
322 "HPICMN find_control() failed for adap %d\n",
323 phm->adapter_index);
719f82d3 324 return 0;
3285ea10 325 }
719f82d3
EB		 326
327 phr->error = 0;
328
329 /* pC is the default cached control strucure. May be cast to
330 something else in the following switch statement.
331 */
332 pC = (struct hpi_control_cache_single *)pI;
333 p_pad = (struct hpi_control_cache_pad *)pI;
334
335 switch (pI->control_type) {
336
337 case HPI_CONTROL_METER:
338 if (phm->u.c.attribute == HPI_METER_PEAK) {
3285ea10
EB		 339 phr->u.c.an_log_value[0] = pC->u.meter.an_log_peak[0];
340 phr->u.c.an_log_value[1] = pC->u.meter.an_log_peak[1];
719f82d3 341 } else if (phm->u.c.attribute == HPI_METER_RMS) {
3285ea10
EB		 342 if (pC->u.meter.an_logRMS[0] ==
343 HPI_CACHE_INVALID_SHORT) {
344 phr->error =
345 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
346 phr->u.c.an_log_value[0] = HPI_METER_MINIMUM;
347 phr->u.c.an_log_value[1] = HPI_METER_MINIMUM;
348 } else {
349 phr->u.c.an_log_value[0] =
350 pC->u.meter.an_logRMS[0];
351 phr->u.c.an_log_value[1] =
352 pC->u.meter.an_logRMS[1];
353 }
719f82d3
EB		 354 } else
355 found = 0;
356 break;
357 case HPI_CONTROL_VOLUME:
358 if (phm->u.c.attribute == HPI_VOLUME_GAIN) {
3285ea10
EB		 359 phr->u.c.an_log_value[0] = pC->u.vol.an_log[0];
360 phr->u.c.an_log_value[1] = pC->u.vol.an_log[1];
fc3a3990
EB		 361 } else if (phm->u.c.attribute == HPI_VOLUME_MUTE) {
362 if (pC->u.vol.flags & HPI_VOLUME_FLAG_HAS_MUTE) {
363 if (pC->u.vol.flags & HPI_VOLUME_FLAG_MUTED)
364 phr->u.c.param1 =
365 HPI_BITMASK_ALL_CHANNELS;
366 else
367 phr->u.c.param1 = 0;
368 } else {
369 phr->error =
370 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
371 phr->u.c.param1 = 0;
372 }
373 } else {
719f82d3 374 found = 0;
fc3a3990 375 }
719f82d3
EB		 376 break;
377 case HPI_CONTROL_MULTIPLEXER:
378 if (phm->u.c.attribute == HPI_MULTIPLEXER_SOURCE) {
3285ea10
EB		 379 phr->u.c.param1 = pC->u.mux.source_node_type;
380 phr->u.c.param2 = pC->u.mux.source_node_index;
719f82d3
EB		 381 } else {
382 found = 0;
383 }
384 break;
385 case HPI_CONTROL_CHANNEL_MODE:
386 if (phm->u.c.attribute == HPI_CHANNEL_MODE_MODE)
3285ea10 387 phr->u.c.param1 = pC->u.mode.mode;
719f82d3
EB		 388 else
389 found = 0;
390 break;
391 case HPI_CONTROL_LEVEL:
392 if (phm->u.c.attribute == HPI_LEVEL_GAIN) {
3285ea10
EB		 393 phr->u.c.an_log_value[0] = pC->u.level.an_log[0];
394 phr->u.c.an_log_value[1] = pC->u.level.an_log[1];
719f82d3
EB		 395 } else
396 found = 0;
397 break;
398 case HPI_CONTROL_TUNER:
3ee317fe 399 if (phm->u.c.attribute == HPI_TUNER_FREQ)
3285ea10 400 phr->u.c.param1 = pC->u.tuner.freq_ink_hz;
3ee317fe 401 else if (phm->u.c.attribute == HPI_TUNER_BAND)
3285ea10
EB		 402 phr->u.c.param1 = pC->u.tuner.band;
403 else if (phm->u.c.attribute == HPI_TUNER_LEVEL_AVG)
404 if (pC->u.tuner.s_level_avg ==
405 HPI_CACHE_INVALID_SHORT) {
406 phr->u.cu.tuner.s_level = 0;
36ed8bdd
EB		 407 phr->error =
408 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
409 } else
3285ea10
EB		 410 phr->u.cu.tuner.s_level =
411 pC->u.tuner.s_level_avg;
3ee317fe
EB		 412 else
413 found = 0;
719f82d3
EB		 414 break;
415 case HPI_CONTROL_AESEBU_RECEIVER:
416 if (phm->u.c.attribute == HPI_AESEBURX_ERRORSTATUS)
417 phr->u.c.param1 = pC->u.aes3rx.error_status;
418 else if (phm->u.c.attribute == HPI_AESEBURX_FORMAT)
3285ea10 419 phr->u.c.param1 = pC->u.aes3rx.format;
719f82d3
EB		 420 else
421 found = 0;
422 break;
423 case HPI_CONTROL_AESEBU_TRANSMITTER:
424 if (phm->u.c.attribute == HPI_AESEBUTX_FORMAT)
425 phr->u.c.param1 = pC->u.aes3tx.format;
426 else
427 found = 0;
428 break;
429 case HPI_CONTROL_TONEDETECTOR:
430 if (phm->u.c.attribute == HPI_TONEDETECTOR_STATE)
431 phr->u.c.param1 = pC->u.tone.state;
432 else
433 found = 0;
434 break;
435 case HPI_CONTROL_SILENCEDETECTOR:
436 if (phm->u.c.attribute == HPI_SILENCEDETECTOR_STATE) {
437 phr->u.c.param1 = pC->u.silence.state;
719f82d3
EB		 438 } else
439 found = 0;
440 break;
441 case HPI_CONTROL_MICROPHONE:
442 if (phm->u.c.attribute == HPI_MICROPHONE_PHANTOM_POWER)
3285ea10 443 phr->u.c.param1 = pC->u.microphone.phantom_state;
719f82d3
EB		 444 else
445 found = 0;
446 break;
447 case HPI_CONTROL_SAMPLECLOCK:
448 if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE)
449 phr->u.c.param1 = pC->u.clk.source;
450 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE_INDEX) {
451 if (pC->u.clk.source_index ==
3285ea10 452 HPI_CACHE_INVALID_UINT16) {
719f82d3 453 phr->u.c.param1 = 0;
36ed8bdd
EB		 454 phr->error =
455 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
719f82d3
EB		 456 } else
457 phr->u.c.param1 = pC->u.clk.source_index;
458 } else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SAMPLERATE)
459 phr->u.c.param1 = pC->u.clk.sample_rate;
460 else
461 found = 0;
462 break;
3285ea10
EB		 463 case HPI_CONTROL_PAD:{
464 struct hpi_control_cache_pad *p_pad;
465 p_pad = (struct hpi_control_cache_pad *)pI;
719f82d3 466
3285ea10
EB		 467 if (!(p_pad->field_valid_flags & (1 <<
468 HPI_CTL_ATTR_INDEX(phm->u.c.
469 attribute)))) {
719f82d3
EB		 470 phr->error =
471 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
472 break;
473 }
474
3285ea10
EB		 475 if (phm->u.c.attribute == HPI_PAD_PROGRAM_ID)
476 phr->u.c.param1 = p_pad->pI;
477 else if (phm->u.c.attribute == HPI_PAD_PROGRAM_TYPE)
478 phr->u.c.param1 = p_pad->pTY;
479 else {
480 unsigned int index =
481 HPI_CTL_ATTR_INDEX(phm->u.c.
482 attribute) - 1;
483 unsigned int offset = phm->u.c.param1;
484 unsigned int pad_string_len, field_size;
485 char *pad_string;
486 unsigned int tocopy;
487
488 if (index > ARRAY_SIZE(pad_desc) - 1) {
489 phr->error =
490 HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
491 break;
492 }
493
494 pad_string =
495 ((char *)p_pad) +
496 pad_desc[index].offset;
497 field_size = pad_desc[index].field_size;
498 /* Ensure null terminator */
499 pad_string[field_size - 1] = 0;
500
501 pad_string_len = strlen(pad_string) + 1;
502
503 if (offset > pad_string_len) {
504 phr->error =
505 HPI_ERROR_INVALID_CONTROL_VALUE;
506 break;
507 }
508
509 tocopy = pad_string_len - offset;
510 if (tocopy > sizeof(phr->u.cu.chars8.sz_data))
511 tocopy = sizeof(phr->u.cu.chars8.
512 sz_data);
513
514 memcpy(phr->u.cu.chars8.sz_data,
515 &pad_string[offset], tocopy);
516
517 phr->u.cu.chars8.remaining_chars =
518 pad_string_len - offset - tocopy;
719f82d3 519 }
719f82d3
EB		 520 }
521 break;
522 default:
523 found = 0;
524 break;
525 }
526
3285ea10
EB		 527 HPI_DEBUG_LOG(VERBOSE, "%s Adap %d, Ctl %d, Type %d, Attr %d\n",
528 found ? "Cached" : "Uncached", phm->adapter_index,
529 pI->control_index, pI->control_type, phm->u.c.attribute);
719f82d3
EB		 530
531 if (found)
532 phr->size =
533 sizeof(struct hpi_response_header) +
534 sizeof(struct hpi_control_res);
535
536 return found;
537}
538
539/** Updates the cache with Set values.
540
541Only update if no error.
542Volume and Level return the limited values in the response, so use these
543Multiplexer does so use sent values
544*/
3285ea10 545void hpi_cmn_control_cache_sync_to_msg(struct hpi_control_cache *p_cache,
719f82d3
EB		 546 struct hpi_message *phm, struct hpi_response *phr)
547{
719f82d3
EB		 548 struct hpi_control_cache_single *pC;
549 struct hpi_control_cache_info *pI;
550
3ee317fe
EB		 551 if (phr->error)
552 return;
553
3285ea10
EB		 554 if (!find_control(phm->obj_index, p_cache, &pI)) {
555 HPI_DEBUG_LOG(VERBOSE,
556 "HPICMN find_control() failed for adap %d\n",
557 phm->adapter_index);
719f82d3 558 return;
3285ea10 559 }
719f82d3
EB		 560
561 /* pC is the default cached control strucure.
562 May be cast to something else in the following switch statement.
563 */
564 pC = (struct hpi_control_cache_single *)pI;
565
566 switch (pI->control_type) {
567 case HPI_CONTROL_VOLUME:
568 if (phm->u.c.attribute == HPI_VOLUME_GAIN) {
3285ea10
EB		 569 pC->u.vol.an_log[0] = phr->u.c.an_log_value[0];
570 pC->u.vol.an_log[1] = phr->u.c.an_log_value[1];
fc3a3990
EB		 571 } else if (phm->u.c.attribute == HPI_VOLUME_MUTE) {
572 if (phm->u.c.param1)
573 pC->u.vol.flags |= HPI_VOLUME_FLAG_MUTED;
574 else
575 pC->u.vol.flags &= ~HPI_VOLUME_FLAG_MUTED;
719f82d3
EB		 576 }
577 break;
578 case HPI_CONTROL_MULTIPLEXER:
579 /* mux does not return its setting on Set command. */
719f82d3 580 if (phm->u.c.attribute == HPI_MULTIPLEXER_SOURCE) {
3285ea10
EB		 581 pC->u.mux.source_node_type = (u16)phm->u.c.param1;
582 pC->u.mux.source_node_index = (u16)phm->u.c.param2;
719f82d3
EB		 583 }
584 break;
585 case HPI_CONTROL_CHANNEL_MODE:
586 /* mode does not return its setting on Set command. */
719f82d3 587 if (phm->u.c.attribute == HPI_CHANNEL_MODE_MODE)
3285ea10 588 pC->u.mode.mode = (u16)phm->u.c.param1;
719f82d3
EB		 589 break;
590 case HPI_CONTROL_LEVEL:
591 if (phm->u.c.attribute == HPI_LEVEL_GAIN) {
3285ea10
EB		 592 pC->u.vol.an_log[0] = phr->u.c.an_log_value[0];
593 pC->u.vol.an_log[1] = phr->u.c.an_log_value[1];
719f82d3
EB		 594 }
595 break;
596 case HPI_CONTROL_MICROPHONE:
597 if (phm->u.c.attribute == HPI_MICROPHONE_PHANTOM_POWER)
3285ea10 598 pC->u.microphone.phantom_state = (u16)phm->u.c.param1;
719f82d3
EB		 599 break;
600 case HPI_CONTROL_AESEBU_TRANSMITTER:
719f82d3
EB		 601 if (phm->u.c.attribute == HPI_AESEBUTX_FORMAT)
602 pC->u.aes3tx.format = phm->u.c.param1;
603 break;
604 case HPI_CONTROL_AESEBU_RECEIVER:
719f82d3 605 if (phm->u.c.attribute == HPI_AESEBURX_FORMAT)
3285ea10 606 pC->u.aes3rx.format = phm->u.c.param1;
719f82d3
EB		 607 break;
608 case HPI_CONTROL_SAMPLECLOCK:
719f82d3
EB		 609 if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE)
610 pC->u.clk.source = (u16)phm->u.c.param1;
611 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SOURCE_INDEX)
612 pC->u.clk.source_index = (u16)phm->u.c.param1;
613 else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SAMPLERATE)
614 pC->u.clk.sample_rate = phm->u.c.param1;
615 break;
616 default:
617 break;
618 }
619}
620
42258dab
EB		 621/** Allocate control cache.
622
623\return Cache pointer, or NULL if allocation fails.
624*/
4704998e
EB		 625struct hpi_control_cache *hpi_alloc_control_cache(const u32 control_count,
626 const u32 size_in_bytes, u8 *p_dsp_control_buffer)
719f82d3
EB		 627{
628 struct hpi_control_cache *p_cache =
629 kmalloc(sizeof(*p_cache), GFP_KERNEL);
fd0977d0
JJ		 630 if (!p_cache)
631 return NULL;
4704998e 632
fd0977d0 633 p_cache->p_info =
4704998e 634 kmalloc(sizeof(*p_cache->p_info) * control_count, GFP_KERNEL);
fd0977d0
JJ		 635 if (!p_cache->p_info) {
636 kfree(p_cache);
637 return NULL;
638 }
4704998e 639 memset(p_cache->p_info, 0, sizeof(*p_cache->p_info) * control_count);
719f82d3 640 p_cache->cache_size_in_bytes = size_in_bytes;
4704998e
EB		 641 p_cache->control_count = control_count;
642 p_cache->p_cache = p_dsp_control_buffer;
719f82d3 643 p_cache->init = 0;
719f82d3
EB		 644 return p_cache;
645}
646
647void hpi_free_control_cache(struct hpi_control_cache *p_cache)
648{
3285ea10 649 if (p_cache) {
719f82d3 650 kfree(p_cache->p_info);
719f82d3
EB		 651 kfree(p_cache);
652 }
653}
654
655static void subsys_message(struct hpi_message *phm, struct hpi_response *phr)
656{
3285ea10 657 hpi_init_response(phr, HPI_OBJ_SUBSYSTEM, phm->function, 0);
719f82d3
EB		 658
659 switch (phm->function) {
660 case HPI_SUBSYS_OPEN:
661 case HPI_SUBSYS_CLOSE:
662 case HPI_SUBSYS_DRIVER_UNLOAD:
719f82d3
EB		 663 break;
664 case HPI_SUBSYS_DRIVER_LOAD:
665 wipe_adapter_list();
666 hpios_alistlock_init(&adapters);
719f82d3 667 break;
3285ea10
EB		 668 case HPI_SUBSYS_GET_ADAPTER:
669 subsys_get_adapter(phm, phr);
670 break;
671 case HPI_SUBSYS_GET_NUM_ADAPTERS:
672 phr->u.s.num_adapters = adapters.gw_num_adapters;
719f82d3
EB		 673 break;
674 case HPI_SUBSYS_CREATE_ADAPTER:
719f82d3
EB		 675 break;
676 default:
677 phr->error = HPI_ERROR_INVALID_FUNC;
678 break;
679 }
680}
681
682void HPI_COMMON(struct hpi_message *phm, struct hpi_response *phr)
683{
684 switch (phm->type) {
685 case HPI_TYPE_MESSAGE:
686 switch (phm->object) {
687 case HPI_OBJ_SUBSYSTEM:
688 subsys_message(phm, phr);
689 break;
690 }
691 break;
692
693 default:
694 phr->error = HPI_ERROR_INVALID_TYPE;
695 break;
696 }
697}
Linux kernel - Deliverables
This page took 0.123559 seconds and 5 git commands to generate.