i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clean up

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34005 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Jérôme Duval
2009-11-11 20:06:28 +00:00
parent e629da4a47
commit 79cc4374cf
1 changed files with 174 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/drivers/audio/ice1712/multi.c
+174 -176
View File
@@ -17,8 +17,9 @@
#include <string.h> #include <string.h>
#define AUTORIZED_RATE (B_SR_SAME_AS_INPUT | B_SR_IS_GLOBAL | B_SR_96000 | B_SR_88200 | B_SR_48000 | B_SR_44100) #define AUTHORIZED_RATE (B_SR_SAME_AS_INPUT | B_SR_IS_GLOBAL | B_SR_96000 \
#define AUTORIZED_SAMPLE_SIZE (B_FMT_32BIT) | B_SR_88200 | B_SR_48000 | B_SR_44100)
#define AUTHORIZED_SAMPLE_SIZE (B_FMT_32BIT)
static void static void
start_DMA(ice1712 *card) start_DMA(ice1712 *card)
@@ -27,65 +28,65 @@ start_DMA(ice1712 *card)
write_mt_uint8(card, MT_PROF_PB_CONTROL, 0); write_mt_uint8(card, MT_PROF_PB_CONTROL, 0);
write_mt_uint32(card, MT_PROF_PB_DMA_BASE_ADDRESS, (uint32)card->phys_addr_pb); write_mt_uint32(card, MT_PROF_PB_DMA_BASE_ADDRESS, (uint32)card->phys_addr_pb);
write_mt_uint16(card, MT_PROF_PB_DMA_COUNT_ADDRESS, (size * SWAPPING_BUFFERS) - 1); write_mt_uint16(card, MT_PROF_PB_DMA_COUNT_ADDRESS, (size * SWAPPING_BUFFERS) - 1);
//We want interrupt only from playback //We want interrupt only from playback
write_mt_uint16(card, MT_PROF_PB_DMA_TERM_COUNT, size - 1); write_mt_uint16(card, MT_PROF_PB_DMA_TERM_COUNT, size - 1);
TRACE_ICE(("SIZE DMA PLAYBACK %#x\n", size)); TRACE_ICE(("SIZE DMA PLAYBACK %#x\n", size));
size = card->input_buffer_size * MAX_ADC; size = card->input_buffer_size * MAX_ADC;
write_mt_uint32(card, MT_PROF_REC_DMA_BASE_ADDRESS, (uint32)card->phys_addr_rec); write_mt_uint32(card, MT_PROF_REC_DMA_BASE_ADDRESS, (uint32)card->phys_addr_rec);
write_mt_uint16(card, MT_PROF_REC_DMA_COUNT_ADDRESS, (size * SWAPPING_BUFFERS) - 1); write_mt_uint16(card, MT_PROF_REC_DMA_COUNT_ADDRESS, (size * SWAPPING_BUFFERS) - 1);
//We do not want any interrupt from the record //We do not want any interrupt from the record
write_mt_uint16(card, MT_PROF_REC_DMA_TERM_COUNT, 0); write_mt_uint16(card, MT_PROF_REC_DMA_TERM_COUNT, 0);
TRACE_ICE(("SIZE DMA RECORD %#x\n", size)); TRACE_ICE(("SIZE DMA RECORD %#x\n", size));
//Enable output AND Input from Analog CODEC //Enable output AND Input from Analog CODEC
switch (card->product) switch (card->product) {
{//TODO: find correct value for all card //TODO: find correct value for all card
case ICE1712_SUBDEVICE_DELTA66 : case ICE1712_SUBDEVICE_DELTA66:
case ICE1712_SUBDEVICE_DELTA44 : case ICE1712_SUBDEVICE_DELTA44:
case ICE1712_SUBDEVICE_AUDIOPHILE_2496 : case ICE1712_SUBDEVICE_AUDIOPHILE_2496:
case ICE1712_SUBDEVICE_DELTADIO2496 : case ICE1712_SUBDEVICE_DELTADIO2496:
case ICE1712_SUBDEVICE_DELTA410 : case ICE1712_SUBDEVICE_DELTA410:
case ICE1712_SUBDEVICE_DELTA1010LT : case ICE1712_SUBDEVICE_DELTA1010LT:
case ICE1712_SUBDEVICE_DELTA1010 : case ICE1712_SUBDEVICE_DELTA1010:
codec_write(card, AK45xx_CLOCK_FORMAT_REGISTER, 0x69); codec_write(card, AK45xx_CLOCK_FORMAT_REGISTER, 0x69);
codec_write(card, AK45xx_RESET_REGISTER, 0x03); codec_write(card, AK45xx_RESET_REGISTER, 0x03);
break; break;
case ICE1712_SUBDEVICE_VX442 : case ICE1712_SUBDEVICE_VX442:
// ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_0); // ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_0);
// ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_1); // ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_1);
break; break;
} }
//Set Data Format for SPDif codec //Set Data Format for SPDif codec
switch (card->product) switch (card->product) {
{//TODO: find correct value for all card //TODO: find correct value for all card
case ICE1712_SUBDEVICE_DELTA1010 : case ICE1712_SUBDEVICE_DELTA1010:
break; break;
case ICE1712_SUBDEVICE_DELTADIO2496 : case ICE1712_SUBDEVICE_DELTADIO2496:
break; break;
case ICE1712_SUBDEVICE_DELTA66 : case ICE1712_SUBDEVICE_DELTA66:
case ICE1712_SUBDEVICE_DELTA44 : case ICE1712_SUBDEVICE_DELTA44:
// ak45xx_write_gpio(ice, reg_addr, data, DELTA66_CODEC_CS_0); // ak45xx_write_gpio(ice, reg_addr, data, DELTA66_CODEC_CS_0);
// ak45xx_write_gpio(ice, reg_addr, data, DELTA66_CODEC_CS_1); // ak45xx_write_gpio(ice, reg_addr, data, DELTA66_CODEC_CS_1);
break; break;
case ICE1712_SUBDEVICE_AUDIOPHILE_2496 : case ICE1712_SUBDEVICE_AUDIOPHILE_2496:
spdif_write(card, CS84xx_SERIAL_INPUT_FORMAT_REG, 0x85); spdif_write(card, CS84xx_SERIAL_INPUT_FORMAT_REG, 0x85);
spdif_write(card, CS84xx_SERIAL_OUTPUT_FORMAT_REG, 0x85); spdif_write(card, CS84xx_SERIAL_OUTPUT_FORMAT_REG, 0x85);
// spdif_write(card, CS84xx_SERIAL_OUTPUT_FORMAT_REG, 0x41); // spdif_write(card, CS84xx_SERIAL_OUTPUT_FORMAT_REG, 0x41);
break; break;
case ICE1712_SUBDEVICE_DELTA410 : case ICE1712_SUBDEVICE_DELTA410:
break; break;
case ICE1712_SUBDEVICE_DELTA1010LT : case ICE1712_SUBDEVICE_DELTA1010LT:
// ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_0); // ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_0);
// ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_1); // ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_1);
// ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_2); // ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_2);
// ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_3); // ak45xx_write_gpio(ice, reg_addr, data, DELTA1010LT_CODEC_CS_3);
break; break;
case ICE1712_SUBDEVICE_VX442 : case ICE1712_SUBDEVICE_VX442:
// ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_0); // ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_0);
// ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_1); // ak45xx_write_gpio(ice, reg_addr, data, VX442_CODEC_CS_1);
break; break;
@@ -104,81 +105,79 @@ ice1712_get_description(ice1712 *card, multi_description *data)
data->interface_version = B_CURRENT_INTERFACE_VERSION; data->interface_version = B_CURRENT_INTERFACE_VERSION;
data->interface_minimum = B_CURRENT_INTERFACE_VERSION; data->interface_minimum = B_CURRENT_INTERFACE_VERSION;
switch (card->product) switch (card->product) {
{ case ICE1712_SUBDEVICE_DELTA1010:
case ICE1712_SUBDEVICE_DELTA1010 :
strncpy(data->friendly_name, "Delta 1010", 32); strncpy(data->friendly_name, "Delta 1010", 32);
break; break;
case ICE1712_SUBDEVICE_DELTADIO2496 : case ICE1712_SUBDEVICE_DELTADIO2496:
strncpy(data->friendly_name, "Delta DIO 2496", 32); strncpy(data->friendly_name, "Delta DIO 2496", 32);
break; break;
case ICE1712_SUBDEVICE_DELTA66 : case ICE1712_SUBDEVICE_DELTA66:
strncpy(data->friendly_name, "Delta 66", 32); strncpy(data->friendly_name, "Delta 66", 32);
break; break;
case ICE1712_SUBDEVICE_DELTA44 : case ICE1712_SUBDEVICE_DELTA44:
strncpy(data->friendly_name, "Delta 44", 32); strncpy(data->friendly_name, "Delta 44", 32);
break; break;
case ICE1712_SUBDEVICE_AUDIOPHILE_2496 : case ICE1712_SUBDEVICE_AUDIOPHILE_2496:
strncpy(data->friendly_name, "Audiophile 2496", 32); strncpy(data->friendly_name, "Audiophile 2496", 32);
break; break;
case ICE1712_SUBDEVICE_DELTA410 : case ICE1712_SUBDEVICE_DELTA410:
strncpy(data->friendly_name, "Delta 410", 32); strncpy(data->friendly_name, "Delta 410", 32);
break; break;
case ICE1712_SUBDEVICE_DELTA1010LT : case ICE1712_SUBDEVICE_DELTA1010LT:
strncpy(data->friendly_name, "Delta 1010 LT", 32); strncpy(data->friendly_name, "Delta 1010 LT", 32);
break; break;
case ICE1712_SUBDEVICE_VX442 : case ICE1712_SUBDEVICE_VX442:
strncpy(data->friendly_name, "VX 442", 32); strncpy(data->friendly_name, "VX 442", 32);
break; break;
default:
default :
strncpy(data->friendly_name, "Unknow Device", 32); strncpy(data->friendly_name, "Unknow Device", 32);
break; break;
} }
strncpy(data->vendor_info, "J. H Leveque", 32); strncpy(data->vendor_info, "J. H Leveque", 32);
data->output_channel_count = card->total_output_channels; data->output_channel_count = card->total_output_channels;
data->input_channel_count = card->total_input_channels; data->input_channel_count = card->total_input_channels;
data->output_bus_channel_count = 0; data->output_bus_channel_count = card->total_output_channels;
data->input_bus_channel_count = 0; data->input_bus_channel_count = card->total_input_channels;
data->aux_bus_channel_count = 0; data->aux_bus_channel_count = 0;
TRACE_ICE(("request_channel_count = %d\n", data->request_channel_count)); TRACE_ICE(("request_channel_count = %d\n", data->request_channel_count));
if (data->request_channel_count >= (card->total_output_channels + card->total_input_channels)) { if (data->request_channel_count >= (card->total_output_channels
+ card->total_input_channels)) {
for (i = 0; i < card->nb_DAC; i++) { for (i = 0; i < card->nb_DAC; i++) {
//Analog STEREO output //Analog STEREO output
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_OUTPUT_CHANNEL; data->channels[chan].kind = B_MULTI_OUTPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS | \ data->channels[chan].designations = B_CHANNEL_STEREO_BUS
((i & 1) == 0) ? B_CHANNEL_LEFT : B_CHANNEL_RIGHT; | ((i & 1) == 0) ? B_CHANNEL_LEFT : B_CHANNEL_RIGHT;
data->channels[chan].connectors = 0; data->channels[chan++].connectors = 0;
chan++;
} }
if (card->spdif_config & NO_IN_YES_OUT) { if (card->spdif_config & NO_IN_YES_OUT) {
//SPDIF STEREO output //SPDIF STEREO output
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_OUTPUT_CHANNEL; data->channels[chan].kind = B_MULTI_OUTPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS | B_CHANNEL_LEFT; data->channels[chan].designations = B_CHANNEL_STEREO_BUS
| B_CHANNEL_LEFT;
data->channels[chan].connectors = 0; data->channels[chan].connectors = 0;
chan++; chan++;
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_OUTPUT_CHANNEL; data->channels[chan].kind = B_MULTI_OUTPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS | B_CHANNEL_RIGHT; data->channels[chan].designations = B_CHANNEL_STEREO_BUS
data->channels[chan].connectors = 0; | B_CHANNEL_RIGHT;
chan++; data->channels[chan++].connectors = 0;
} }
for (i = 0; i < card->nb_ADC; i++) { for (i = 0; i < card->nb_ADC; i++) {
//Analog STEREO input //Analog STEREO input
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_INPUT_CHANNEL; data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS | \ data->channels[chan].designations = B_CHANNEL_STEREO_BUS |
((i & 1) == 0) ? B_CHANNEL_LEFT : B_CHANNEL_RIGHT; ((i & 1) == 0) ? B_CHANNEL_LEFT : B_CHANNEL_RIGHT;
data->channels[chan].connectors = 0; data->channels[chan++].connectors = 0;
chan++;
} }
if (card->spdif_config & YES_IN_NO_OUT) { if (card->spdif_config & YES_IN_NO_OUT) {
@@ -186,26 +185,22 @@ ice1712_get_description(ice1712 *card, multi_description *data)
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_INPUT_CHANNEL; data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS | B_CHANNEL_LEFT; data->channels[chan].designations = B_CHANNEL_STEREO_BUS | B_CHANNEL_LEFT;
data->channels[chan].connectors = 0; data->channels[chan++].connectors = 0;
chan++;
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_INPUT_CHANNEL; data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS | B_CHANNEL_RIGHT; data->channels[chan].designations = B_CHANNEL_STEREO_BUS | B_CHANNEL_RIGHT;
data->channels[chan].connectors = 0; data->channels[chan++].connectors = 0;
chan++;
} }
//The digital mixer output //The digital mixer output
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_INPUT_CHANNEL; data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS | B_CHANNEL_LEFT; data->channels[chan].designations = B_CHANNEL_STEREO_BUS | B_CHANNEL_LEFT;
data->channels[chan].connectors = 0; data->channels[chan++].connectors = 0;
chan++;
data->channels[chan].channel_id = chan; data->channels[chan].channel_id = chan;
data->channels[chan].kind = B_MULTI_INPUT_CHANNEL; data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
data->channels[chan].designations = B_CHANNEL_STEREO_BUS | B_CHANNEL_RIGHT; data->channels[chan].designations = B_CHANNEL_STEREO_BUS | B_CHANNEL_RIGHT;
data->channels[chan].connectors = 0; data->channels[chan++].connectors = 0;
chan++;
} }
TRACE_ICE(("output_channel_count = %d\n", data->output_channel_count)); TRACE_ICE(("output_channel_count = %d\n", data->output_channel_count));
@@ -213,11 +208,11 @@ ice1712_get_description(ice1712 *card, multi_description *data)
TRACE_ICE(("output_bus_channel_count = %d\n", data->output_bus_channel_count)); TRACE_ICE(("output_bus_channel_count = %d\n", data->output_bus_channel_count));
TRACE_ICE(("input_bus_channel_count = %d\n", data->input_bus_channel_count)); TRACE_ICE(("input_bus_channel_count = %d\n", data->input_bus_channel_count));
data->output_rates = data->input_rates = AUTORIZED_RATE; data->output_rates = data->input_rates = AUTHORIZED_RATE;
data->min_cvsr_rate = 44100; data->min_cvsr_rate = 44100;
data->max_cvsr_rate = 96000; data->max_cvsr_rate = 96000;
data->output_formats = data->input_formats = AUTORIZED_SAMPLE_SIZE; data->output_formats = data->input_formats = AUTHORIZED_SAMPLE_SIZE;
data->lock_sources = B_MULTI_LOCK_INTERNAL | B_MULTI_LOCK_SPDIF; data->lock_sources = B_MULTI_LOCK_INTERNAL | B_MULTI_LOCK_SPDIF;
data->timecode_sources = 0; data->timecode_sources = 0;
data->interface_flags = B_MULTI_INTERFACE_PLAYBACK | B_MULTI_INTERFACE_RECORD; data->interface_flags = B_MULTI_INTERFACE_PLAYBACK | B_MULTI_INTERFACE_RECORD;
@@ -253,7 +248,8 @@ ice1712_set_enabled_channels(ice1712 *card, multi_channel_enable *data)
{ {
int i; int i;
for (i = 0; i < (card->total_output_channels + card->total_input_channels); i++) for (i = 0; i < (card->total_output_channels + card->total_input_channels); i++)
TRACE_ICE(("set_enabled_channels %d : %s\n", i, B_TEST_CHANNEL(data->enable_bits, i) ? "enabled": "disabled")); TRACE_ICE(("set_enabled_channels %d : %s\n", i,
B_TEST_CHANNEL(data->enable_bits, i) ? "enabled": "disabled"));
TRACE_ICE(("lock_source %d\n", data->lock_source)); TRACE_ICE(("lock_source %d\n", data->lock_source));
TRACE_ICE(("lock_data %d\n", data->lock_data)); TRACE_ICE(("lock_data %d\n", data->lock_data));
@@ -276,30 +272,23 @@ ice1712_get_global_format(ice1712 *card, multi_format_info *data)
switch (sr) switch (sr)
{ {
case 0x0 : case 0x0:
data->input.rate = data->output.rate = B_SR_48000; data->input.rate = data->output.rate = B_SR_48000;
data->input.cvsr = data->output.cvsr = 48000.0f;
break; break;
case 0x7 : case 0x7:
data->input.rate = data->output.rate = B_SR_96000; data->input.rate = data->output.rate = B_SR_96000;
data->input.cvsr = data->output.cvsr = 96000.0f;
break; break;
case 0x8 : case 0x8:
data->input.rate = data->output.rate = B_SR_44100; data->input.rate = data->output.rate = B_SR_44100;
data->input.cvsr = data->output.cvsr = 44100.0f;
break; break;
case 0xB : case 0xB:
data->input.rate = data->output.rate = B_SR_88200; data->input.rate = data->output.rate = B_SR_88200;
data->input.cvsr = data->output.cvsr = 88200.0f;
break; break;
} }
data->timecode_kind = 0; data->timecode_kind = 0;
data->output_latency = data->input_latency = 0; data->output_latency = data->input_latency = 0;
data->output.format = data->input.format = AUTORIZED_SAMPLE_SIZE; data->output.format = data->input.format = AUTHORIZED_SAMPLE_SIZE;
TRACE_ICE(("Input Sampling Rate = %d\n", (int)data->input.cvsr));
TRACE_ICE(("Output Sampling Rate = %d\n", (int)data->output.cvsr));
return B_OK; return B_OK;
} }
@@ -315,18 +304,17 @@ ice1712_set_global_format(ice1712 *card, multi_format_info *data)
if ((data->input.rate == data->output.rate) if ((data->input.rate == data->output.rate)
&& (card->lock_source == B_MULTI_LOCK_INTERNAL)) { && (card->lock_source == B_MULTI_LOCK_INTERNAL)) {
switch (data->input.rate) switch (data->input.rate) {
{ case B_SR_96000:
case B_SR_96000 :
card->sampling_rate = 0x07; card->sampling_rate = 0x07;
break; break;
case B_SR_88200 : case B_SR_88200:
card->sampling_rate = 0x0B; card->sampling_rate = 0x0B;
break; break;
case B_SR_48000 : case B_SR_48000:
card->sampling_rate = 0x00; card->sampling_rate = 0x00;
break; break;
case B_SR_44100 : case B_SR_44100:
card->sampling_rate = 0x08; card->sampling_rate = 0x08;
break; break;
} }
@@ -375,7 +363,8 @@ ice1712_list_mix_channels(ice1712 *card, multi_mix_channel_info *data)
#endif #endif
static int32 static int32
create_group_control(multi_mix_control *multi, int32 idx, int32 parent, int32 string, const char* name) create_group_control(multi_mix_control *multi, int32 idx, int32 parent,
int32 string, const char* name)
{ {
multi->id = MULTI_AUDIO_BASE_ID + idx; multi->id = MULTI_AUDIO_BASE_ID + idx;
multi->master = parent; multi->master = parent;
@@ -390,7 +379,8 @@ create_group_control(multi_mix_control *multi, int32 idx, int32 parent, int32 st
} }
static int32 static int32
create_slider_control(multi_mix_control *multi, int32 idx, int32 parent, int32 string, const char* name) create_slider_control(multi_mix_control *multi, int32 idx, int32 parent,
int32 string, const char* name)
{ {
multi->id = MULTI_AUDIO_BASE_ID + idx; multi->id = MULTI_AUDIO_BASE_ID + idx;
multi->master = parent; multi->master = parent;
@@ -398,9 +388,9 @@ create_slider_control(multi_mix_control *multi, int32 idx, int32 parent, int32 s
multi->master = MULTI_AUDIO_MASTER_ID + 1; multi->master = MULTI_AUDIO_MASTER_ID + 1;
// multi->string = string; // multi->string = string;
multi->u.gain.min_gain = -144.0; multi->u.gain.min_gain = -144.0;
multi->u.gain.max_gain = 0.0; multi->u.gain.max_gain = 0.0;
multi->u.gain.granularity = 1.5; multi->u.gain.granularity = 1.5;
if (name != NULL) if (name != NULL)
strcpy(multi->name, name); strcpy(multi->name, name);
@@ -415,11 +405,13 @@ ice1712_list_mix_controls(ice1712 *card, multi_mix_control_info *data)
int32 parent; int32 parent;
TRACE_ICE(("count = %d\n", data->control_count)); TRACE_ICE(("count = %d\n", data->control_count));
parent = create_group_control (data->controls + 0, 0, 0, S_null, "Playback"); parent = create_group_control(data->controls + 0, 0, 0, S_null, "Playback");
create_slider_control (data->controls + 1, 1, parent, S_STEREO_MIX, "Master Output"); create_slider_control(data->controls + 1, 1, parent, S_STEREO_MIX,
"Master Output");
parent = create_group_control (data->controls + 2, 2, 0, S_null, "Record"); parent = create_group_control(data->controls + 2, 2, 0, S_null, "Record");
create_slider_control (data->controls + 3, 3, parent, S_STEREO_MIX, "Master Input"); create_slider_control(data->controls + 3, 3, parent, S_STEREO_MIX,
"Master Input");
data->control_count = 4; data->control_count = 4;
return B_OK; return B_OK;
@@ -439,24 +431,31 @@ ice1712_get_buffers(ice1712 *card, multi_buffer_list *data)
int buff, chan_i = 0, chan_o = 0; int buff, chan_i = 0, chan_o = 0;
TRACE_ICE(("flags = %#x\n",data->flags)); TRACE_ICE(("flags = %#x\n",data->flags));
TRACE_ICE(("request_playback_buffers = %#x\n", data->request_playback_buffers)); TRACE_ICE(("request_playback_buffers = %#x\n",
TRACE_ICE(("request_playback_channels = %#x\n", data->request_playback_channels)); data->request_playback_buffers));
TRACE_ICE(("request_playback_buffer_size = %#x\n", data->request_playback_buffer_size)); TRACE_ICE(("request_playback_channels = %#x\n",
TRACE_ICE(("request_record_buffers = %#x\n", data->request_record_buffers)); data->request_playback_channels));
TRACE_ICE(("request_record_channels = %#x\n", data->request_record_channels)); TRACE_ICE(("request_playback_buffer_size = %#x\n",
TRACE_ICE(("request_record_buffer_size = %#x\n", data->request_record_buffer_size)); data->request_playback_buffer_size));
TRACE_ICE(("request_record_buffers = %#x\n",
data->request_record_buffers));
TRACE_ICE(("request_record_channels = %#x\n",
data->request_record_channels));
TRACE_ICE(("request_record_buffer_size = %#x\n",
data->request_record_buffer_size));
// MIN_BUFFER_FRAMES <= requested value <= MAX_BUFFER_FRAMES // MIN_BUFFER_FRAMES <= requested value <= MAX_BUFFER_FRAMES
card->output_buffer_size = data->request_playback_buffer_size <= MAX_BUFFER_FRAMES ? \ card->output_buffer_size = data->request_playback_buffer_size;
data->request_playback_buffer_size >= MIN_BUFFER_FRAMES ? \ if (card->output_buffer_size > MAX_BUFFER_FRAMES)
data->request_playback_buffer_size : MIN_BUFFER_FRAMES \ card->output_buffer_size = MAX_BUFFER_FRAMES;
: MAX_BUFFER_FRAMES; if (card->output_buffer_size < MIN_BUFFER_FRAMES)
card->output_buffer_size = MIN_BUFFER_FRAMES;
// MIN_BUFFER_FRAMES <= requested value <= MAX_BUFFER_FRAMES card->input_buffer_size = data->request_record_buffer_size;
card->input_buffer_size = data->request_record_buffer_size <= MAX_BUFFER_FRAMES ? \ if (card->input_buffer_size > MAX_BUFFER_FRAMES)
data->request_record_buffer_size >= MIN_BUFFER_FRAMES ? \ card->input_buffer_size = MAX_BUFFER_FRAMES;
data->request_record_buffer_size : MIN_BUFFER_FRAMES \ if (card->input_buffer_size < MIN_BUFFER_FRAMES)
: MAX_BUFFER_FRAMES; card->input_buffer_size = MIN_BUFFER_FRAMES;
for (buff = 0; buff < SWAPPING_BUFFERS; buff++) { for (buff = 0; buff < SWAPPING_BUFFERS; buff++) {
uint32 stride_o = MAX_DAC * SAMPLE_SIZE; uint32 stride_o = MAX_DAC * SAMPLE_SIZE;
@@ -467,30 +466,27 @@ ice1712_get_buffers(ice1712 *card, multi_buffer_list *data)
if (data->request_playback_channels == card->total_output_channels) { if (data->request_playback_channels == card->total_output_channels) {
for (chan_o = 0; chan_o < card->nb_DAC; chan_o++) { for (chan_o = 0; chan_o < card->nb_DAC; chan_o++) {
//Analog STEREO output //Analog STEREO output
data->playback_buffers[buff][chan_o].base = card->log_addr_pb + \ data->playback_buffers[buff][chan_o].base = card->log_addr_pb
buf_o * buff + \ + buf_o * buff + SAMPLE_SIZE * chan_o;
SAMPLE_SIZE * chan_o;
data->playback_buffers[buff][chan_o].stride = stride_o; data->playback_buffers[buff][chan_o].stride = stride_o;
TRACE_ICE(("pb_buffer[%d][%d] = %#x\n", \ TRACE_ICE(("pb_buffer[%d][%d] = %#x\n", buff, chan_o,
buff, chan_o, data->playback_buffers[buff][chan_o].base)); data->playback_buffers[buff][chan_o].base));
} }
if (card->spdif_config & NO_IN_YES_OUT) { if (card->spdif_config & NO_IN_YES_OUT) {
//SPDIF STEREO output //SPDIF STEREO output
data->playback_buffers[buff][chan_o].base = card->log_addr_pb + \ data->playback_buffers[buff][chan_o].base = card->log_addr_pb
buf_o * buff + \ + buf_o * buff + SAMPLE_SIZE * SPDIF_LEFT;
SAMPLE_SIZE * SPDIF_LEFT;
data->playback_buffers[buff][chan_o].stride = stride_o; data->playback_buffers[buff][chan_o].stride = stride_o;
TRACE_ICE(("pb_buffer[%d][%d] = %#x\n", \ TRACE_ICE(("pb_buffer[%d][%d] = %#x\n", buff, chan_o,
buff, chan_o, data->playback_buffers[buff][chan_o].base)); data->playback_buffers[buff][chan_o].base));
chan_o++; chan_o++;
data->playback_buffers[buff][chan_o].base = card->log_addr_pb + \ data->playback_buffers[buff][chan_o].base = card->log_addr_pb
buf_o * buff + \ + buf_o * buff + SAMPLE_SIZE * SPDIF_RIGHT;
SAMPLE_SIZE * SPDIF_RIGHT;
data->playback_buffers[buff][chan_o].stride = stride_o; data->playback_buffers[buff][chan_o].stride = stride_o;
TRACE_ICE(("pb_buffer[%d][%d] = %#x\n", \ TRACE_ICE(("pb_buffer[%d][%d] = %#x\n", buff, chan_o,
buff, chan_o, data->playback_buffers[buff][chan_o].base)); data->playback_buffers[buff][chan_o].base));
chan_o++; chan_o++;
} }
} }
@@ -498,48 +494,43 @@ ice1712_get_buffers(ice1712 *card, multi_buffer_list *data)
if (data->request_record_channels == card->total_input_channels) { if (data->request_record_channels == card->total_input_channels) {
for (chan_i = 0; chan_i < card->nb_ADC; chan_i++) { for (chan_i = 0; chan_i < card->nb_ADC; chan_i++) {
//Analog STEREO input //Analog STEREO input
data->record_buffers[buff][chan_i].base = card->log_addr_rec + \ data->record_buffers[buff][chan_i].base = card->log_addr_rec
buf_i * buff + \ + buf_i * buff + SAMPLE_SIZE * chan_i;
SAMPLE_SIZE * chan_i;
data->record_buffers[buff][chan_i].stride = stride_i; data->record_buffers[buff][chan_i].stride = stride_i;
TRACE_ICE(("rec_buffer[%d][%d] = %#x\n", \ TRACE_ICE(("rec_buffer[%d][%d] = %#x\n", buff, chan_i,
buff, chan_i, data->record_buffers[buff][chan_i].base)); data->record_buffers[buff][chan_i].base));
} }
if (card->spdif_config & YES_IN_NO_OUT) { if (card->spdif_config & YES_IN_NO_OUT) {
//SPDIF STEREO input //SPDIF STEREO input
data->record_buffers[buff][chan_i].base = card->log_addr_rec + \ data->record_buffers[buff][chan_i].base = card->log_addr_rec
buf_i * buff + \ + buf_i * buff + SAMPLE_SIZE * SPDIF_LEFT;
SAMPLE_SIZE * SPDIF_LEFT;
data->record_buffers[buff][chan_i].stride = stride_i; data->record_buffers[buff][chan_i].stride = stride_i;
TRACE_ICE(("rec_buffer[%d][%d] = %#x\n", \ TRACE_ICE(("rec_buffer[%d][%d] = %#x\n", buff, chan_i,
buff, chan_i, data->record_buffers[buff][chan_i].base)); data->record_buffers[buff][chan_i].base));
chan_i++; chan_i++;
data->record_buffers[buff][chan_i].base = card->log_addr_rec + \ data->record_buffers[buff][chan_i].base = card->log_addr_rec
buf_i * buff + \ + buf_i * buff + SAMPLE_SIZE * SPDIF_RIGHT;
SAMPLE_SIZE * SPDIF_RIGHT;
data->record_buffers[buff][chan_i].stride = stride_i; data->record_buffers[buff][chan_i].stride = stride_i;
TRACE_ICE(("rec_buffer[%d][%d] = %#x\n", \ TRACE_ICE(("rec_buffer[%d][%d] = %#x\n", buff, chan_i,
buff, chan_i, data->record_buffers[buff][chan_i].base)); data->record_buffers[buff][chan_i].base));
chan_i++; chan_i++;
} }
//The digital mixer output //The digital mixer output
data->record_buffers[buff][chan_i].base = card->log_addr_rec + \ data->record_buffers[buff][chan_i].base = card->log_addr_rec
buf_i * buff + \ + buf_i * buff + SAMPLE_SIZE * MIXER_OUT_LEFT;
SAMPLE_SIZE * MIXER_OUT_LEFT;
data->record_buffers[buff][chan_i].stride = stride_i; data->record_buffers[buff][chan_i].stride = stride_i;
TRACE_ICE(("rec_buffer[%d][%d] = %#x\n", \ TRACE_ICE(("rec_buffer[%d][%d] = %#x\n", buff, chan_i,
buff, chan_i, data->record_buffers[buff][chan_i].base)); data->record_buffers[buff][chan_i].base));
chan_i++; chan_i++;
data->record_buffers[buff][chan_i].base = card->log_addr_rec + \ data->record_buffers[buff][chan_i].base = card->log_addr_rec
buf_i * buff + \ + buf_i * buff + SAMPLE_SIZE * MIXER_OUT_RIGHT;
SAMPLE_SIZE * MIXER_OUT_RIGHT;
data->record_buffers[buff][chan_i].stride = stride_i; data->record_buffers[buff][chan_i].stride = stride_i;
TRACE_ICE(("rec_buffer[%d][%d] = %#x\n", \ TRACE_ICE(("rec_buffer[%d][%d] = %#x\n", buff, chan_i,
buff, chan_i, data->record_buffers[buff][chan_i].base)); data->record_buffers[buff][chan_i].base));
chan_i++; chan_i++;
} }
} }
@@ -548,18 +539,24 @@ ice1712_get_buffers(ice1712 *card, multi_buffer_list *data)
data->return_playback_channels = card->total_output_channels; data->return_playback_channels = card->total_output_channels;
data->return_playback_buffer_size = card->output_buffer_size; data->return_playback_buffer_size = card->output_buffer_size;
TRACE_ICE(("return_playback_buffers = %#x\n", data->return_playback_buffers)); TRACE_ICE(("return_playback_buffers = %#x\n",
TRACE_ICE(("return_playback_channels = %#x\n", data->return_playback_channels)); data->return_playback_buffers));
TRACE_ICE(("return_playback_buffer_size = %#x\n", data->return_playback_buffer_size)); TRACE_ICE(("return_playback_channels = %#x\n",
data->return_playback_channels));
TRACE_ICE(("return_playback_buffer_size = %#x\n",
data->return_playback_buffer_size));
data->return_record_buffers = SWAPPING_BUFFERS; data->return_record_buffers = SWAPPING_BUFFERS;
data->return_record_channels = card->total_input_channels; data->return_record_channels = card->total_input_channels;
data->return_record_channels = chan_i; data->return_record_channels = chan_i;
data->return_record_buffer_size = card->input_buffer_size; data->return_record_buffer_size = card->input_buffer_size;
TRACE_ICE(("return_record_buffers = %#x\n", data->return_record_buffers)); TRACE_ICE(("return_record_buffers = %#x\n",
TRACE_ICE(("return_record_channels = %#x\n", data->return_record_channels)); data->return_record_buffers));
TRACE_ICE(("return_record_buffer_size = %#x\n", data->return_record_buffer_size)); TRACE_ICE(("return_record_channels = %#x\n",
data->return_record_channels));
TRACE_ICE(("return_record_buffer_size = %#x\n",
data->return_record_buffer_size));
start_DMA(card); start_DMA(card);
@@ -574,65 +571,66 @@ ice1712_buffer_exchange(ice1712 *card, multi_buffer_info *data)
/* unsigned char peak[MAX_ADC]; /* unsigned char peak[MAX_ADC];
int i; int i;
*/ */
// TRACE_ICE(("Avant Exchange p : %d, r : %d\n", data->playback_buffer_cycle, data->record_buffer_cycle)); // TRACE_ICE(("Avant Exchange p : %d, r : %d\n", data->playback_buffer_cycle,
// data->record_buffer_cycle));
status = acquire_sem_etc(card->buffer_ready_sem, 1, B_RELATIVE_TIMEOUT | B_CAN_INTERRUPT, 50000); status = acquire_sem_etc(card->buffer_ready_sem, 1, B_RELATIVE_TIMEOUT
switch (status) | B_CAN_INTERRUPT, 50000);
{ switch (status) {
case B_NO_ERROR : case B_OK:
// TRACE_ICE(("B_NO_ERROR\n")); // TRACE_ICE(("B_NO_ERROR\n"));
cpu_status = lock(); cpu_status = lock();
// do playback // do playback
data->played_real_time = card->played_time; data->played_real_time = card->played_time;
data->played_frames_count += card->output_buffer_size; data->played_frames_count += card->output_buffer_size;
data->playback_buffer_cycle = (card->buffer/* - 1*/) & 0x1; //Buffer TO fill data->playback_buffer_cycle = (card->buffer/* - 1*/) & 0x1; //Buffer TO fill
// do record // do record
data->recorded_real_time = card->played_time; data->recorded_real_time = card->played_time;
data->recorded_frames_count += card->input_buffer_size; data->recorded_frames_count += card->input_buffer_size;
data->record_buffer_cycle = (card->buffer/* - 1*/) & 0x1; //Buffer filled data->record_buffer_cycle = (card->buffer/* - 1*/) & 0x1; //Buffer filled
data->flags = B_MULTI_BUFFER_PLAYBACK | B_MULTI_BUFFER_RECORD; data->flags = B_MULTI_BUFFER_PLAYBACK | B_MULTI_BUFFER_RECORD;
unlock(cpu_status); unlock(cpu_status);
break; break;
case B_BAD_SEM_ID : case B_BAD_SEM_ID:
TRACE_ICE(("B_BAD_SEM_ID\n")); TRACE_ICE(("B_BAD_SEM_ID\n"));
break; break;
case B_INTERRUPTED : case B_INTERRUPTED:
TRACE_ICE(("B_INTERRUPTED\n")); TRACE_ICE(("B_INTERRUPTED\n"));
break; break;
case B_BAD_VALUE : case B_BAD_VALUE:
TRACE_ICE(("B_BAD_VALUE\n")); TRACE_ICE(("B_BAD_VALUE\n"));
break; break;
case B_WOULD_BLOCK : case B_WOULD_BLOCK:
TRACE_ICE(("B_WOULD_BLOCK\n")); TRACE_ICE(("B_WOULD_BLOCK\n"));
break; break;
case B_TIMED_OUT : case B_TIMED_OUT:
TRACE_ICE(("B_TIMED_OUT\n")); TRACE_ICE(("B_TIMED_OUT\n"));
start_DMA(card); start_DMA(card);
cpu_status = lock(); cpu_status = lock();
data->played_real_time = card->played_time; data->played_real_time = card->played_time;
data->playback_buffer_cycle = 0; data->playback_buffer_cycle = 0;
data->played_frames_count += card->output_buffer_size; data->played_frames_count += card->output_buffer_size;
data->recorded_real_time = card->played_time; data->recorded_real_time = card->played_time;
data->record_buffer_cycle = 0; data->record_buffer_cycle = 0;
data->recorded_frames_count += card->input_buffer_size; data->recorded_frames_count += card->input_buffer_size;
data->flags = B_MULTI_BUFFER_PLAYBACK | B_MULTI_BUFFER_RECORD; data->flags = B_MULTI_BUFFER_PLAYBACK | B_MULTI_BUFFER_RECORD;
unlock(cpu_status); unlock(cpu_status);
break; break;
default : default:
TRACE_ICE(("Default\n")); TRACE_ICE(("Default\n"));
break; break;
} }
@@ -648,9 +646,9 @@ ice1712_buffer_exchange(ice1712 *card, multi_buffer_info *data)
return B_OK; return B_OK;
} }
status_t ice1712_buffer_force_stop(ice1712 *card) status_t ice1712_buffer_force_stop(ice1712 *card)
{ {
write_mt_uint8(card, MT_PROF_PB_CONTROL, 0); write_mt_uint8(card, MT_PROF_PB_CONTROL, 0);
return B_OK; return B_OK;
} }