?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
BPicture: Fix archive constructor.
[haiku.git] / src / add-ons / kernel / drivers / audio / ac97 / es1370 / multi.c
blobf61a95a1769728d80c2d8fb1851e1453a0fc1f5f
1 /*
2 * ES1370 Haiku Driver for ES1370 audio
3 *
4 * Copyright 2002-2007, Haiku, Inc.
5 * Distributed under the terms of the MIT License.
6 *
7 * Authors:
8 * Jerome Duval, jerome.duval@free.fr
9 */
10
11 #include <driver_settings.h>
12 #include <OS.h>
13 #include <MediaDefs.h>
14 #include <string.h>
15 #include <strings.h>
16 #include "hmulti_audio.h"
17 #include "multi.h"
18 #include "ac97.h"
19
20 //#define DEBUG 1
21
22 #include "debug.h"
23 #include "es1370.h"
24 #include "util.h"
25 #include "io.h"
26
27 static void
28 es1370_ac97_get_mix(void *card, const void *cookie, int32 type, float *values) {
29 es1370_dev *dev = (es1370_dev*)card;
30 ac97_source_info *info = (ac97_source_info *)cookie;
31 uint16 value, mask;
32 float gain;
33
34 switch(type) {
35 case B_MIX_GAIN:
36 value = es1370_codec_read(&dev->config, info->reg);
37 //PRINT(("B_MIX_GAIN value : %u\n", value));
38 if (info->type & B_MIX_STEREO) {
39 mask = ((1 << (info->bits + 1)) - 1) << 8;
40 gain = ((value & mask) >> 8) * info->granularity;
41 if (info->polarity == 1)
42 values[0] = info->max_gain - gain;
43 else
44 values[0] = gain - info->min_gain;
45
46 mask = ((1 << (info->bits + 1)) - 1);
47 gain = (value & mask) * info->granularity;
48 if (info->polarity == 1)
49 values[1] = info->max_gain - gain;
50 else
51 values[1] = gain - info->min_gain;
52 } else {
53 mask = ((1 << (info->bits + 1)) - 1);
54 gain = (value & mask) * info->granularity;
55 if (info->polarity == 1)
56 values[0] = info->max_gain - gain;
57 else
58 values[0] = gain - info->min_gain;
59 }
60 break;
61 case B_MIX_MUTE:
62 mask = ((1 << 1) - 1) << 15;
63 value = es1370_codec_read(&dev->config, info->reg);
64 //PRINT(("B_MIX_MUTE value : %u\n", value));
65 value &= mask;
66 values[0] = ((value >> 15) == 1) ? 1.0 : 0.0;
67 break;
68 case B_MIX_MICBOOST:
69 mask = ((1 << 1) - 1) << 6;
70 value = es1370_codec_read(&dev->config, info->reg);
71 //PRINT(("B_MIX_MICBOOST value : %u\n", value));
72 value &= mask;
73 values[0] = ((value >> 6) == 1) ? 1.0 : 0.0;
74 break;
75 case B_MIX_MUX:
76 mask = ((1 << 3) - 1);
77 value = es1370_codec_read(&dev->config, AC97_RECORD_SELECT);
78 value &= mask;
79 //PRINT(("B_MIX_MUX value : %u\n", value));
80 values[0] = (float)value;
81 break;
82 }
83 }
84
85 static void
86 es1370_ac97_set_mix(void *card, const void *cookie, int32 type, float *values) {
87 es1370_dev *dev = (es1370_dev*)card;
88 ac97_source_info *info = (ac97_source_info *)cookie;
89 uint16 value, mask;
90 float gain;
91
92 switch(type) {
93 case B_MIX_GAIN:
94 value = es1370_codec_read(&dev->config, info->reg);
95 if (info->type & B_MIX_STEREO) {
96 mask = ((1 << (info->bits + 1)) - 1) << 8;
97 value &= ~mask;
98
99 if (info->polarity == 1)
100 gain = info->max_gain - values[0];
101 else
102 gain = values[0] - info->min_gain;
103 value |= ((uint16)(gain / info->granularity) << 8) & mask;
104
105 mask = ((1 << (info->bits + 1)) - 1);
106 value &= ~mask;
107 if (info->polarity == 1)
108 gain = info->max_gain - values[1];
109 else
110 gain = values[1] - info->min_gain;
111 value |= ((uint16)(gain / info->granularity)) & mask;
112 } else {
113 mask = ((1 << (info->bits + 1)) - 1);
114 value &= ~mask;
115 if (info->polarity == 1)
116 gain = info->max_gain - values[0];
117 else
118 gain = values[0] - info->min_gain;
119 value |= ((uint16)(gain / info->granularity)) & mask;
120 }
121 //PRINT(("B_MIX_GAIN value : %u\n", value));
122 es1370_codec_write(&dev->config, info->reg, value);
123 break;
124 case B_MIX_MUTE:
125 mask = ((1 << 1) - 1) << 15;
126 value = es1370_codec_read(&dev->config, info->reg);
127 value &= ~mask;
128 value |= ((values[0] == 1.0 ? 1 : 0 ) << 15 & mask);
129 if (info->reg == AC97_SURR_VOLUME) {
130 // there is a independent mute for each channel
131 mask = ((1 << 1) - 1) << 7;
132 value &= ~mask;
133 value |= ((values[0] == 1.0 ? 1 : 0 ) << 7 & mask);
134 }
135 //PRINT(("B_MIX_MUTE value : %u\n", value));
136 es1370_codec_write(&dev->config, info->reg, value);
137 break;
138 case B_MIX_MICBOOST:
139 mask = ((1 << 1) - 1) << 6;
140 value = es1370_codec_read(&dev->config, info->reg);
141 value &= ~mask;
142 value |= ((values[0] == 1.0 ? 1 : 0 ) << 6 & mask);
143 //PRINT(("B_MIX_MICBOOST value : %u\n", value));
144 es1370_codec_write(&dev->config, info->reg, value);
145 break;
146 case B_MIX_MUX:
147 mask = ((1 << 3) - 1);
148 value = ((int32)values[0]) & mask;
149 value = value | (value << 8);
150 //PRINT(("B_MIX_MUX value : %u\n", value));
151 es1370_codec_write(&dev->config, AC97_RECORD_SELECT, value);
152 break;
153 }
154
155 }
156
157 static int32
158 es1370_create_group_control(multi_dev *multi, int32 *index, int32 parent,
159 int32 string, const char* name) {
160 int32 i = *index;
161 (*index)++;
162 multi->controls[i].mix_control.id = EMU_MULTI_CONTROL_FIRSTID + i;
163 multi->controls[i].mix_control.parent = parent;
164 multi->controls[i].mix_control.flags = B_MULTI_MIX_GROUP;
165 multi->controls[i].mix_control.master = EMU_MULTI_CONTROL_MASTERID;
166 multi->controls[i].mix_control.string = string;
167 if (name)
168 strcpy(multi->controls[i].mix_control.name, name);
169
170 return multi->controls[i].mix_control.id;
171 }
172
173 static status_t
174 es1370_create_controls_list(multi_dev *multi)
175 {
176 multi->control_count = 0;
177 PRINT(("multi->control_count %lu\n", multi->control_count));
178 return B_OK;
179 }
180
181 static status_t
182 es1370_get_mix(es1370_dev *card, multi_mix_value_info * mmvi)
183 {
184 int32 i, id;
185 multi_mixer_control *control = NULL;
186 for (i = 0; i < mmvi->item_count; i++) {
187 id = mmvi->values[i].id - EMU_MULTI_CONTROL_FIRSTID;
188 if (id < 0 || id >= card->multi.control_count) {
189 PRINT(("es1370_get_mix : invalid control id requested : %li\n", id));
190 continue;
191 }
192 control = &card->multi.controls[id];
193
194 if (control->mix_control.flags & B_MULTI_MIX_GAIN) {
195 if (control->get) {
196 float values[2];
197 control->get(card, control->cookie, control->type, values);
198 if (control->mix_control.master == EMU_MULTI_CONTROL_MASTERID)
199 mmvi->values[i].u.gain = values[0];
200 else
201 mmvi->values[i].u.gain = values[1];
202 }
203 }
204
205 if (control->mix_control.flags & B_MULTI_MIX_ENABLE && control->get) {
206 float values[1];
207 control->get(card, control->cookie, control->type, values);
208 mmvi->values[i].u.enable = (values[0] == 1.0);
209 }
210
211 if (control->mix_control.flags & B_MULTI_MIX_MUX && control->get) {
212 float values[1];
213 control->get(card, control->cookie, control->type, values);
214 mmvi->values[i].u.mux = (int32)values[0];
215 }
216 }
217 return B_OK;
218 }
219
220 static status_t
221 es1370_set_mix(es1370_dev *card, multi_mix_value_info * mmvi)
222 {
223 int32 i, id;
224 multi_mixer_control *control = NULL;
225 for (i = 0; i < mmvi->item_count; i++) {
226 id = mmvi->values[i].id - EMU_MULTI_CONTROL_FIRSTID;
227 if (id < 0 || id >= card->multi.control_count) {
228 PRINT(("es1370_set_mix : invalid control id requested : %li\n", id));
229 continue;
230 }
231 control = &card->multi.controls[id];
232
233 if (control->mix_control.flags & B_MULTI_MIX_GAIN) {
234 multi_mixer_control *control2 = NULL;
235 if (i+1<mmvi->item_count) {
236 id = mmvi->values[i + 1].id - EMU_MULTI_CONTROL_FIRSTID;
237 if (id < 0 || id >= card->multi.control_count) {
238 PRINT(("es1370_set_mix : invalid control id requested : %li\n", id));
239 } else {
240 control2 = &card->multi.controls[id];
241 if (control2->mix_control.master != control->mix_control.id)
242 control2 = NULL;
243 }
244 }
245
246 if (control->set) {
247 float values[2];
248 values[0] = 0.0;
249 values[1] = 0.0;
250
251 if (control->mix_control.master == EMU_MULTI_CONTROL_MASTERID)
252 values[0] = mmvi->values[i].u.gain;
253 else
254 values[1] = mmvi->values[i].u.gain;
255
256 if (control2 && control2->mix_control.master != EMU_MULTI_CONTROL_MASTERID)
257 values[1] = mmvi->values[i+1].u.gain;
258
259 control->set(card, control->cookie, control->type, values);
260 }
261
262 if (control2)
263 i++;
264 }
265
266 if (control->mix_control.flags & B_MULTI_MIX_ENABLE && control->set) {
267 float values[1];
268
269 values[0] = mmvi->values[i].u.enable ? 1.0 : 0.0;
270 control->set(card, control->cookie, control->type, values);
271 }
272
273 if (control->mix_control.flags & B_MULTI_MIX_MUX && control->set) {
274 float values[1];
275
276 values[0] = (float)mmvi->values[i].u.mux;
277 control->set(card, control->cookie, control->type, values);
278 }
279 }
280 return B_OK;
281 }
282
283 static status_t
284 es1370_list_mix_controls(es1370_dev *card, multi_mix_control_info * mmci)
285 {
286 multi_mix_control *mmc;
287 int32 i;
288
289 mmc = mmci->controls;
290 if (mmci->control_count < 24)
291 return B_ERROR;
292
293 if (es1370_create_controls_list(&card->multi) < B_OK)
294 return B_ERROR;
295 for (i = 0; i < card->multi.control_count; i++) {
296 mmc[i] = card->multi.controls[i].mix_control;
297 }
298
299 mmci->control_count = card->multi.control_count;
300 return B_OK;
301 }
302
303 static status_t
304 es1370_list_mix_connections(es1370_dev *card, multi_mix_connection_info * data)
305 {
306 return B_ERROR;
307 }
308
309 static status_t
310 es1370_list_mix_channels(es1370_dev *card, multi_mix_channel_info *data)
311 {
312 return B_ERROR;
313 }
314
315 /*multi_channel_info chans[] = {
316 { 0, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, 0 },
317 { 1, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, 0 },
318 { 2, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, 0 },
319 { 3, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, 0 },
320 { 4, B_MULTI_INPUT_CHANNEL, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, 0 },
321 { 5, B_MULTI_INPUT_CHANNEL, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, 0 },
322 { 6, B_MULTI_INPUT_CHANNEL, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, 0 },
323 { 7, B_MULTI_INPUT_CHANNEL, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, 0 },
324 { 8, B_MULTI_OUTPUT_BUS, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, B_CHANNEL_MINI_JACK_STEREO },
325 { 9, B_MULTI_OUTPUT_BUS, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, B_CHANNEL_MINI_JACK_STEREO },
326 { 10, B_MULTI_INPUT_BUS, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, B_CHANNEL_MINI_JACK_STEREO },
327 { 11, B_MULTI_INPUT_BUS, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, B_CHANNEL_MINI_JACK_STEREO },
328 };*/
329
330 /*multi_channel_info chans[] = {
331 { 0, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, 0 },
332 { 1, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, 0 },
333 { 2, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_LEFT | B_CHANNEL_SURROUND_BUS, 0 },
334 { 3, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_RIGHT | B_CHANNEL_SURROUND_BUS, 0 },
335 { 4, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_REARLEFT | B_CHANNEL_SURROUND_BUS, 0 },
336 { 5, B_MULTI_OUTPUT_CHANNEL, B_CHANNEL_REARRIGHT | B_CHANNEL_SURROUND_BUS, 0 },
337 { 6, B_MULTI_INPUT_CHANNEL, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, 0 },
338 { 7, B_MULTI_INPUT_CHANNEL, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, 0 },
339 { 8, B_MULTI_INPUT_CHANNEL, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, 0 },
340 { 9, B_MULTI_INPUT_CHANNEL, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, 0 },
341 { 10, B_MULTI_OUTPUT_BUS, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, B_CHANNEL_MINI_JACK_STEREO },
342 { 11, B_MULTI_OUTPUT_BUS, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, B_CHANNEL_MINI_JACK_STEREO },
343 { 12, B_MULTI_INPUT_BUS, B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS, B_CHANNEL_MINI_JACK_STEREO },
344 { 13, B_MULTI_INPUT_BUS, B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS, B_CHANNEL_MINI_JACK_STEREO },
345 };*/
346
347
348 static void
349 es1370_create_channels_list(multi_dev *multi)
350 {
351 es1370_stream *stream;
352 uint32 index, i, mode, designations;
353 multi_channel_info *chans;
354 uint32 chan_designations[] = {
355 B_CHANNEL_LEFT,
356 B_CHANNEL_RIGHT,
357 B_CHANNEL_REARLEFT,
358 B_CHANNEL_REARRIGHT,
359 B_CHANNEL_CENTER,
360 B_CHANNEL_SUB
361 };
362
363 chans = multi->chans;
364 index = 0;
365
366 for (mode=ES1370_USE_PLAY; mode!=-1;
367 mode = (mode == ES1370_USE_PLAY) ? ES1370_USE_RECORD : -1) {
368 LIST_FOREACH(stream, &((es1370_dev*)multi->card)->streams, next) {
369 if ((stream->use & mode) == 0)
370 continue;
371
372 if (stream->channels == 2)
373 designations = B_CHANNEL_STEREO_BUS;
374 else
375 designations = B_CHANNEL_SURROUND_BUS;
376
377 for (i = 0; i < stream->channels; i++) {
378 chans[index].channel_id = index;
379 chans[index].kind = (mode == ES1370_USE_PLAY) ? B_MULTI_OUTPUT_CHANNEL : B_MULTI_INPUT_CHANNEL;
380 chans[index].designations = designations | chan_designations[i];
381 chans[index].connectors = 0;
382 index++;
383 }
384 }
385
386 if (mode==ES1370_USE_PLAY) {
387 multi->output_channel_count = index;
388 } else {
389 multi->input_channel_count = index - multi->output_channel_count;
390 }
391 }
392
393 chans[index].channel_id = index;
394 chans[index].kind = B_MULTI_OUTPUT_BUS;
395 chans[index].designations = B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS;
396 chans[index].connectors = B_CHANNEL_MINI_JACK_STEREO;
397 index++;
398
399 chans[index].channel_id = index;
400 chans[index].kind = B_MULTI_OUTPUT_BUS;
401 chans[index].designations = B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS;
402 chans[index].connectors = B_CHANNEL_MINI_JACK_STEREO;
403 index++;
404
405 multi->output_bus_channel_count = index - multi->output_channel_count
406 - multi->input_channel_count;
407
408 chans[index].channel_id = index;
409 chans[index].kind = B_MULTI_INPUT_BUS;
410 chans[index].designations = B_CHANNEL_LEFT | B_CHANNEL_STEREO_BUS;
411 chans[index].connectors = B_CHANNEL_MINI_JACK_STEREO;
412 index++;
413
414 chans[index].channel_id = index;
415 chans[index].kind = B_MULTI_INPUT_BUS;
416 chans[index].designations = B_CHANNEL_RIGHT | B_CHANNEL_STEREO_BUS;
417 chans[index].connectors = B_CHANNEL_MINI_JACK_STEREO;
418 index++;
419
420 multi->input_bus_channel_count = index - multi->output_channel_count
421 - multi->input_channel_count - multi->output_bus_channel_count;
422
423 multi->aux_bus_channel_count = 0;
424 }
425
426
427 static status_t
428 es1370_get_description(es1370_dev *card, multi_description *data)
429 {
430 uint32 size;
431
432 data->interface_version = B_CURRENT_INTERFACE_VERSION;
433 data->interface_minimum = B_CURRENT_INTERFACE_VERSION;
434
435 strncpy(data->friendly_name, FRIENDLY_NAME, 32);
436 strcpy(data->vendor_info, AUTHOR);
437
438 data->output_channel_count = card->multi.output_channel_count;
439 data->input_channel_count = card->multi.input_channel_count;
440 data->output_bus_channel_count = card->multi.output_bus_channel_count;
441 data->input_bus_channel_count = card->multi.input_bus_channel_count;
442 data->aux_bus_channel_count = card->multi.aux_bus_channel_count;
443
444 size = card->multi.output_channel_count + card->multi.input_channel_count
445 + card->multi.output_bus_channel_count + card->multi.input_bus_channel_count
446 + card->multi.aux_bus_channel_count;
447
448 // for each channel, starting with the first output channel,
449 // then the second, third..., followed by the first input
450 // channel, second, third, ..., followed by output bus
451 // channels and input bus channels and finally auxillary channels,
452
453 LOG(("request_channel_count = %d\n",data->request_channel_count));
454 if (data->request_channel_count >= size) {
455 LOG(("copying data\n"));
456 memcpy(data->channels, card->multi.chans, size * sizeof(card->multi.chans[0]));
457 }
458
459 data->output_rates = B_SR_44100;// | B_SR_48000 | B_SR_CVSR;
460 data->input_rates = B_SR_44100;// | B_SR_48000 | B_SR_CVSR;
461 data->output_rates = B_SR_44100;
462 data->input_rates = B_SR_44100;
463 data->min_cvsr_rate = 0;
464 data->max_cvsr_rate = 44100;
465
466 data->output_formats = B_FMT_16BIT;
467 data->input_formats = B_FMT_16BIT;
468 data->lock_sources = B_MULTI_LOCK_INTERNAL;
469 data->timecode_sources = 0;
470 data->interface_flags = B_MULTI_INTERFACE_PLAYBACK | B_MULTI_INTERFACE_RECORD;
471 data->start_latency = 3000;
472
473 strcpy(data->control_panel,"");
474
475 return B_OK;
476 }
477
478 static status_t
479 es1370_get_enabled_channels(es1370_dev *card, multi_channel_enable *data)
480 {
481 B_SET_CHANNEL(data->enable_bits, 0, true);
482 B_SET_CHANNEL(data->enable_bits, 1, true);
483 B_SET_CHANNEL(data->enable_bits, 2, true);
484 B_SET_CHANNEL(data->enable_bits, 3, true);
485 data->lock_source = B_MULTI_LOCK_INTERNAL;
486 /*
487 uint32 lock_source;
488 int32 lock_data;
489 uint32 timecode_source;
490 uint32 * connectors;
491 */
492 return B_OK;
493 }
494
495 static status_t
496 es1370_set_enabled_channels(es1370_dev *card, multi_channel_enable *data)
497 {
498 PRINT(("set_enabled_channels 0 : %s\n", B_TEST_CHANNEL(data->enable_bits, 0) ? "enabled": "disabled"));
499 PRINT(("set_enabled_channels 1 : %s\n", B_TEST_CHANNEL(data->enable_bits, 1) ? "enabled": "disabled"));
500 PRINT(("set_enabled_channels 2 : %s\n", B_TEST_CHANNEL(data->enable_bits, 2) ? "enabled": "disabled"));
501 PRINT(("set_enabled_channels 3 : %s\n", B_TEST_CHANNEL(data->enable_bits, 3) ? "enabled": "disabled"));
502 return B_OK;
503 }
504
505 static status_t
506 es1370_get_global_format(es1370_dev *card, multi_format_info *data)
507 {
508 data->output_latency = 0;
509 data->input_latency = 0;
510 data->timecode_kind = 0;
511 data->input.rate = B_SR_44100;
512 data->input.cvsr = 44100;
513 data->input.format = B_FMT_16BIT;
514 data->output.rate = B_SR_44100;
515 data->output.cvsr = 44100;
516 data->output.format = B_FMT_16BIT;
517 return B_OK;
518 }
519
520 static status_t
521 es1370_get_buffers(es1370_dev *card, multi_buffer_list *data)
522 {
523 uint8 i, j, pchannels, rchannels, bufcount;
524
525 LOG(("flags = %#x\n",data->flags));
526 LOG(("request_playback_buffers = %#x\n",data->request_playback_buffers));
527 LOG(("request_playback_channels = %#x\n",data->request_playback_channels));
528 LOG(("request_playback_buffer_size = %#x\n",data->request_playback_buffer_size));
529 LOG(("request_record_buffers = %#x\n",data->request_record_buffers));
530 LOG(("request_record_channels = %#x\n",data->request_record_channels));
531 LOG(("request_record_buffer_size = %#x\n",data->request_record_buffer_size));
532
533 pchannels = card->pstream->channels;
534 rchannels = card->rstream->channels;
535
536 if (data->request_playback_buffers < current_settings.buffer_count ||
537 data->request_playback_channels < (pchannels) ||
538 data->request_record_buffers < current_settings.buffer_count ||
539 data->request_record_channels < (rchannels)) {
540 LOG(("not enough channels/buffers\n"));
541 }
542
543 data->flags = B_MULTI_BUFFER_PLAYBACK | B_MULTI_BUFFER_RECORD; // XXX ???
544 // data->flags = 0;
545
546 data->return_playback_buffers = current_settings.buffer_count; /* playback_buffers[b][] */
547 data->return_playback_channels = pchannels; /* playback_buffers[][c] */
548 data->return_playback_buffer_size = current_settings.buffer_frames; /* frames */
549
550 bufcount = current_settings.buffer_count;
551 if (bufcount > data->request_playback_buffers)
552 bufcount = data->request_playback_buffers;
553
554 for (i = 0; i < bufcount; i++)
555 for (j=0; j<pchannels; j++)
556 es1370_stream_get_nth_buffer(card->pstream, j, i,
557 &data->playback_buffers[i][j].base,
558 &data->playback_buffers[i][j].stride);
559
560 data->return_record_buffers = current_settings.buffer_count;
561 data->return_record_channels = rchannels;
562 data->return_record_buffer_size = current_settings.buffer_frames; /* frames */
563
564 bufcount = current_settings.buffer_count;
565 if (bufcount > data->request_record_buffers)
566 bufcount = data->request_record_buffers;
567
568 for (i = 0; i < bufcount; i++)
569 for (j=0; j<rchannels; j++)
570 es1370_stream_get_nth_buffer(card->rstream, j, i,
571 &data->record_buffers[i][j].base,
572 &data->record_buffers[i][j].stride);
573
574 return B_OK;
575 }
576
577
578 static void
579 es1370_play_inth(void* inthparams)
580 {
581 es1370_stream *stream = (es1370_stream *)inthparams;
582 //int32 count;
583
584 acquire_spinlock(&slock);
585 stream->real_time = system_time();
586 stream->frames_count += current_settings.buffer_frames;
587 stream->buffer_cycle = (stream->trigblk
588 + stream->blkmod - 1) % stream->blkmod;
589 stream->update_needed = true;
590 release_spinlock(&slock);
591
592 //TRACE(("es1370_play_inth : cycle : %d\n", stream->buffer_cycle));
593
594 release_sem_etc(stream->card->buffer_ready_sem, 1, B_DO_NOT_RESCHEDULE);
595 }
596
597 static void
598 es1370_record_inth(void* inthparams)
599 {
600 es1370_stream *stream = (es1370_stream *)inthparams;
601 //int32 count;
602
603 acquire_spinlock(&slock);
604 stream->real_time = system_time();
605 stream->frames_count += current_settings.buffer_frames;
606 stream->buffer_cycle = (stream->trigblk
607 + stream->blkmod - 1) % stream->blkmod;
608 stream->update_needed = true;
609 release_spinlock(&slock);
610
611 //TRACE(("es1370_record_inth : cycle : %d\n", stream->buffer_cycle));
612
613 release_sem_etc(stream->card->buffer_ready_sem, 1, B_DO_NOT_RESCHEDULE);
614 }
615
616 static status_t
617 es1370_buffer_exchange(es1370_dev *card, multi_buffer_info *data)
618 {
619 cpu_status status;
620 es1370_stream *pstream, *rstream;
621 multi_buffer_info buffer_info;
622
623 #ifdef __HAIKU__
624 if (user_memcpy(&buffer_info, data, sizeof(buffer_info)) < B_OK)
625 return B_BAD_ADDRESS;
626 #else
627 memcpy(&buffer_info, data, sizeof(buffer_info));
628 #endif
629
630 buffer_info.flags = B_MULTI_BUFFER_PLAYBACK | B_MULTI_BUFFER_RECORD;
631
632 if (!(card->pstream->state & ES1370_STATE_STARTED))
633 es1370_stream_start(card->pstream, es1370_play_inth, card->pstream);
634
635 if (!(card->rstream->state & ES1370_STATE_STARTED))
636 es1370_stream_start(card->rstream, es1370_record_inth, card->rstream);
637
638 if (acquire_sem_etc(card->buffer_ready_sem, 1, B_RELATIVE_TIMEOUT | B_CAN_INTERRUPT, 100000)
639 == B_TIMED_OUT) {
640 LOG(("buffer_exchange timeout ff\n"));
641 }
642
643 status = lock();
644
645 LIST_FOREACH(pstream, &card->streams, next) {
646 if ((pstream->use & ES1370_USE_PLAY) == 0 ||
647 (pstream->state & ES1370_STATE_STARTED) == 0)
648 continue;
649 if (pstream->update_needed)
650 break;
651 }
652
653 LIST_FOREACH(rstream, &card->streams, next) {
654 if ((rstream->use & ES1370_USE_RECORD) == 0 ||
655 (rstream->state & ES1370_STATE_STARTED) == 0)
656 continue;
657 if (rstream->update_needed)
658 break;
659 }
660
661 if (!pstream)
662 pstream = card->pstream;
663 if (!rstream)
664 rstream = card->rstream;
665
666 /* do playback */
667 buffer_info.playback_buffer_cycle = pstream->buffer_cycle;
668 buffer_info.played_real_time = pstream->real_time;
669 buffer_info.played_frames_count = pstream->frames_count;
670 buffer_info._reserved_0 = pstream->first_channel;
671 pstream->update_needed = false;
672
673 /* do record */
674 buffer_info.record_buffer_cycle = rstream->buffer_cycle;
675 buffer_info.recorded_frames_count = rstream->frames_count;
676 buffer_info.recorded_real_time = rstream->real_time;
677 buffer_info._reserved_1 = rstream->first_channel;
678 rstream->update_needed = false;
679 unlock(status);
680
681 #ifdef __HAIKU__
682 if (user_memcpy(data, &buffer_info, sizeof(buffer_info)) < B_OK)
683 return B_BAD_ADDRESS;
684 #else
685 memcpy(data, &buffer_info, sizeof(buffer_info));
686 #endif
687
688 //TRACE(("buffer_exchange ended\n"));
689 return B_OK;
690 }
691
692 static status_t
693 es1370_buffer_force_stop(es1370_dev *card)
694 {
695 //es1370_voice_halt(card->pvoice);
696 return B_OK;
697 }
698
699 static status_t
700 es1370_multi_control(void *cookie, uint32 op, void *data, size_t length)
701 {
702 es1370_dev *card = (es1370_dev *)cookie;
703
704 switch (op) {
705 case B_MULTI_GET_DESCRIPTION:
706 LOG(("B_MULTI_GET_DESCRIPTION\n"));
707 return es1370_get_description(card, (multi_description *)data);
708 case B_MULTI_GET_EVENT_INFO:
709 LOG(("B_MULTI_GET_EVENT_INFO\n"));
710 return B_ERROR;
711 case B_MULTI_SET_EVENT_INFO:
712 LOG(("B_MULTI_SET_EVENT_INFO\n"));
713 return B_ERROR;
714 case B_MULTI_GET_EVENT:
715 LOG(("B_MULTI_GET_EVENT\n"));
716 return B_ERROR;
717 case B_MULTI_GET_ENABLED_CHANNELS:
718 LOG(("B_MULTI_GET_ENABLED_CHANNELS\n"));
719 return es1370_get_enabled_channels(card, (multi_channel_enable *)data);
720 case B_MULTI_SET_ENABLED_CHANNELS:
721 LOG(("B_MULTI_SET_ENABLED_CHANNELS\n"));
722 return es1370_set_enabled_channels(card, (multi_channel_enable *)data);
723 case B_MULTI_GET_GLOBAL_FORMAT:
724 LOG(("B_MULTI_GET_GLOBAL_FORMAT\n"));
725 return es1370_get_global_format(card, (multi_format_info *)data);
726 case B_MULTI_SET_GLOBAL_FORMAT:
727 LOG(("B_MULTI_SET_GLOBAL_FORMAT\n"));
728 return B_OK; /* XXX BUG! we *MUST* return B_OK, returning B_ERROR will prevent
729 * BeOS to accept the format returned in B_MULTI_GET_GLOBAL_FORMAT
730 */
731 case B_MULTI_GET_CHANNEL_FORMATS:
732 LOG(("B_MULTI_GET_CHANNEL_FORMATS\n"));
733 return B_ERROR;
734 case B_MULTI_SET_CHANNEL_FORMATS: /* only implemented if possible */
735 LOG(("B_MULTI_SET_CHANNEL_FORMATS\n"));
736 return B_ERROR;
737 case B_MULTI_GET_MIX:
738 LOG(("B_MULTI_GET_MIX\n"));
739 return es1370_get_mix(card, (multi_mix_value_info *)data);
740 case B_MULTI_SET_MIX:
741 LOG(("B_MULTI_SET_MIX\n"));
742 return es1370_set_mix(card, (multi_mix_value_info *)data);
743 case B_MULTI_LIST_MIX_CHANNELS:
744 LOG(("B_MULTI_LIST_MIX_CHANNELS\n"));
745 return es1370_list_mix_channels(card, (multi_mix_channel_info *)data);
746 case B_MULTI_LIST_MIX_CONTROLS:
747 LOG(("B_MULTI_LIST_MIX_CONTROLS\n"));
748 return es1370_list_mix_controls(card, (multi_mix_control_info *)data);
749 case B_MULTI_LIST_MIX_CONNECTIONS:
750 LOG(("B_MULTI_LIST_MIX_CONNECTIONS\n"));
751 return es1370_list_mix_connections(card, (multi_mix_connection_info *)data);
752 case B_MULTI_GET_BUFFERS: /* Fill out the struct for the first time; doesn't start anything. */
753 LOG(("B_MULTI_GET_BUFFERS\n"));
754 return es1370_get_buffers(card, data);
755 case B_MULTI_SET_BUFFERS: /* Set what buffers to use, if the driver supports soft buffers. */
756 LOG(("B_MULTI_SET_BUFFERS\n"));
757 return B_ERROR; /* we do not support soft buffers */
758 case B_MULTI_SET_START_TIME: /* When to actually start */
759 LOG(("B_MULTI_SET_START_TIME\n"));
760 return B_ERROR;
761 case B_MULTI_BUFFER_EXCHANGE: /* stop and go are derived from this being called */
762 //TRACE(("B_MULTI_BUFFER_EXCHANGE\n"));
763 return es1370_buffer_exchange(card, (multi_buffer_info *)data);
764 case B_MULTI_BUFFER_FORCE_STOP: /* force stop of playback, nothing in data */
765 LOG(("B_MULTI_BUFFER_FORCE_STOP\n"));
766 return es1370_buffer_force_stop(card);
767 }
768 LOG(("ERROR: unknown multi_control %#x\n",op));
769 return B_ERROR;
770 }
771
772 static status_t es1370_open(const char *name, uint32 flags, void** cookie);
773 static status_t es1370_close(void* cookie);
774 static status_t es1370_free(void* cookie);
775 static status_t es1370_control(void* cookie, uint32 op, void* arg, size_t len);
776 static status_t es1370_read(void* cookie, off_t position, void *buf, size_t* num_bytes);
777 static status_t es1370_write(void* cookie, off_t position, const void* buffer, size_t* num_bytes);
778
779 device_hooks multi_hooks = {
780 es1370_open, /* -> open entry point */
781 es1370_close, /* -> close entry point */
782 es1370_free, /* -> free cookie */
783 es1370_control, /* -> control entry point */
784 es1370_read, /* -> read entry point */
785 es1370_write, /* -> write entry point */
786 NULL, /* start select */
787 NULL, /* stop select */
788 NULL, /* scatter-gather read from the device */
789 NULL /* scatter-gather write to the device */
790 };
791
792 static status_t
793 es1370_open(const char *name, uint32 flags, void** cookie)
794 {
795 es1370_dev *card = NULL;
796 void *settings_handle;
797 int ix;
798
799 LOG(("open()\n"));
800
801 for (ix=0; ix<num_cards; ix++) {
802 if (!strcmp(cards[ix].name, name)) {
803 card = &cards[ix];
804 }
805 }
806
807 if (card == NULL) {
808 LOG(("open() card not found %s\n", name));
809 for (ix=0; ix<num_cards; ix++) {
810 LOG(("open() card available %s\n", cards[ix].name));
811 }
812 return B_ERROR;
813 }
814
815 LOG(("open() got card\n"));
816
817 if (card->pstream !=NULL)
818 return B_ERROR;
819 if (card->rstream !=NULL)
820 return B_ERROR;
821
822 *cookie = card;
823 card->multi.card = card;
824
825 // get driver settings
826 settings_handle = load_driver_settings(ES1370_SETTINGS);
827 if (settings_handle != NULL) {
828 const char *item;
829 char *end;
830 uint32 value;
831
832 item = get_driver_parameter (settings_handle, "sample_rate", "44100", "44100");
833 value = strtoul (item, &end, 0);
834 if (*end == '\0')
835 current_settings.sample_rate = value;
836
837 item = get_driver_parameter (settings_handle, "buffer_frames", "512", "512");
838 value = strtoul (item, &end, 0);
839 if (*end == '\0')
840 current_settings.buffer_frames = value;
841
842 item = get_driver_parameter (settings_handle, "buffer_count", "2", "2");
843 value = strtoul (item, &end, 0);
844 if (*end == '\0')
845 current_settings.buffer_count = value;
846
847 unload_driver_settings(settings_handle);
848 }
849
850 LOG(("stream_new\n"));
851
852 card->rstream = es1370_stream_new(card, ES1370_USE_RECORD, current_settings.buffer_frames, current_settings.buffer_count);
853 card->pstream = es1370_stream_new(card, ES1370_USE_PLAY, current_settings.buffer_frames, current_settings.buffer_count);
854
855 card->buffer_ready_sem = create_sem(0, "pbuffer ready");
856
857 LOG(("stream_setaudio\n"));
858
859 es1370_stream_set_audioparms(card->pstream, 2, true, current_settings.sample_rate);
860 es1370_stream_set_audioparms(card->rstream, 2, true, current_settings.sample_rate);
861
862 card->pstream->first_channel = 0;
863 card->rstream->first_channel = 2;
864
865 es1370_stream_commit_parms(card->pstream);
866 es1370_stream_commit_parms(card->rstream);
867
868 es1370_create_channels_list(&card->multi);
869
870 return B_OK;
871 }
872
873 static status_t
874 es1370_close(void* cookie)
875 {
876 //es1370_dev *card = cookie;
877 LOG(("close()\n"));
878
879 return B_OK;
880 }
881
882 static status_t
883 es1370_free(void* cookie)
884 {
885 es1370_dev *card = cookie;
886 es1370_stream *stream;
887 LOG(("free()\n"));
888
889 if (card->buffer_ready_sem > B_OK)
890 delete_sem(card->buffer_ready_sem);
891
892 LIST_FOREACH(stream, &card->streams, next) {
893 es1370_stream_halt(stream);
894 }
895
896 while (!LIST_EMPTY(&card->streams)) {
897 es1370_stream_delete(LIST_FIRST(&card->streams));
898 }
899
900 card->pstream = NULL;
901 card->rstream = NULL;
902
903 return B_OK;
904 }
905
906 static status_t
907 es1370_control(void* cookie, uint32 op, void* arg, size_t len)
908 {
909 return es1370_multi_control(cookie, op, arg, len);
910 }
911
912 static status_t
913 es1370_read(void* cookie, off_t position, void *buf, size_t* num_bytes)
914 {
915 *num_bytes = 0; /* tell caller nothing was read */
916 return B_IO_ERROR;
917 }
918
919 static status_t
920 es1370_write(void* cookie, off_t position, const void* buffer, size_t* num_bytes)
921 {
922 *num_bytes = 0; /* tell caller nothing was written */
923 return B_IO_ERROR;
924 }
925
Clone of Haiku svn repository