/*
 * Copyright 2004-2015 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Jérôme Duval, jerome.duval@free.fr
 *              Marcus Overhagen, marcus@overhagen.de
 *              Jérôme Lévêque, leveque.jerome@gmail.com
 */


#include "ice1712_reg.h"
#include "io.h"
#include "multi.h"
#include "util.h"

#include <string.h>
#include "debug.h"

status_t ice1712Settings_apply(ice1712 *card);

static void ice1712Buffer_Start(ice1712 *card);
static uint32 ice1712UI_GetCombo(ice1712 *card, uint32 index);
static void ice1712UI_SetCombo(ice1712 *card, uint32 index, uint32 value);
static uint32 ice1712UI_GetOutput(ice1712 *card, uint32 index);
static void ice1712UI_SetOutput(ice1712 *card, uint32 index, uint32 value);
static void ice1712UI_GetVolume(ice1712 *card, multi_mix_value *mmv);
static void ice1712UI_SetVolume(ice1712 *card, multi_mix_value *mmv);
static void ice1712UI_CreateOutput(ice1712 *card, multi_mix_control **p_mmc,
        int32 output, int32 parent);
static void ice1712UI_CreateCombo(multi_mix_control **p_mmc,
        const char *values[], int32 parent, int32 nb_combo, const char *name);
static void ice1712UI_CreateChannel(multi_mix_control **p_mmc,
        int32 channel, int32 parent, const char* name);
static int32 ice1712UI_CreateGroup(multi_mix_control **p_mmc,
        int32 index, int32 parent, enum strind_id string, const char* name);
static int32 nb_control_created;

#define AUTHORIZED_RATE (B_SR_SAME_AS_INPUT | B_SR_96000 \
        | B_SR_88200 | B_SR_48000 | B_SR_44100)
#define AUTHORIZED_SAMPLE_SIZE (B_FMT_24BIT)

#define MAX_CONTROL     32

//ICE1712 Multi - Buffer
//----------------------

void
ice1712Buffer_Start(ice1712 *card)
{
        uint16 size = card->buffer_size * MAX_DAC;

        write_mt_uint8(card, MT_PROF_PB_CONTROL, 0);

        write_mt_uint32(card, MT_PROF_PB_DMA_BASE_ADDRESS,
                (uint32)(card->phys_pb.address));
        write_mt_uint16(card, MT_PROF_PB_DMA_COUNT_ADDRESS,
                (size * SWAPPING_BUFFERS) - 1);
        //We want interrupt only from playback
        write_mt_uint16(card, MT_PROF_PB_DMA_TERM_COUNT, size - 1);
        ITRACE("SIZE DMA PLAYBACK %#x\n", size);

        size = card->buffer_size * MAX_ADC;

        write_mt_uint32(card, MT_PROF_REC_DMA_BASE_ADDRESS,
                (uint32)(card->phys_rec.address));
        write_mt_uint16(card, MT_PROF_REC_DMA_COUNT_ADDRESS,
                (size * SWAPPING_BUFFERS) - 1);
        //We do not want any interrupt from the record
        write_mt_uint16(card, MT_PROF_REC_DMA_TERM_COUNT, 0);
        ITRACE("SIZE DMA RECORD %#x\n", size);

        //Enable output AND Input from Analog CODEC
        switch (card->config.product) {
        //TODO: find correct value for all card
                case ICE1712_SUBDEVICE_DELTA66:
                case ICE1712_SUBDEVICE_DELTA44:
                case ICE1712_SUBDEVICE_AUDIOPHILE_2496:
                case ICE1712_SUBDEVICE_DELTADIO2496:
                case ICE1712_SUBDEVICE_DELTA410:
                case ICE1712_SUBDEVICE_DELTA1010LT:
                case ICE1712_SUBDEVICE_DELTA1010:
                        codec_write(card, AK45xx_CLOCK_FORMAT_REGISTER, 0x69);
                        codec_write(card, AK45xx_RESET_REGISTER, 0x03);
                        break;
                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_1);
                        break;
        }

        //Set Data Format for SPDif codec
        switch (card->config.product) {
        //TODO: find correct value for all card
                case ICE1712_SUBDEVICE_DELTA1010:
                        break;
                case ICE1712_SUBDEVICE_DELTADIO2496:
                        break;
                case ICE1712_SUBDEVICE_DELTA66:
                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_1);
                        break;
                case ICE1712_SUBDEVICE_AUDIOPHILE_2496:
                        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, 0x41);
                        break;
                case ICE1712_SUBDEVICE_DELTA410:
                        break;
                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_1);
//                      ak45xx_write_gpio(ice, reg_addr, data,
//                              DELTA1010LT_CODEC_CS_2);
//                      ak45xx_write_gpio(ice, reg_addr, data,
//                              DELTA1010LT_CODEC_CS_3);
                        break;
                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_1);
                        break;
        }

        card->buffer = 1;
        write_mt_uint8(card, MT_PROF_PB_CONTROL, 5);
}


status_t
ice1712Buffer_Exchange(ice1712 *card, multi_buffer_info *data)
{
        multi_buffer_info buffer_info;

#ifdef __HAIKU__
        if (user_memcpy(&buffer_info, data, sizeof(buffer_info)) < B_OK)
                return B_BAD_ADDRESS;
#else
        memcpy(&buffer_info, data, sizeof(buffer_info));
#endif

        buffer_info.flags = B_MULTI_BUFFER_PLAYBACK | B_MULTI_BUFFER_RECORD;

        if (acquire_sem_etc(card->buffer_ready_sem, 1, B_RELATIVE_TIMEOUT
                | B_CAN_INTERRUPT, 50000) == B_TIMED_OUT) {
                ITRACE("buffer_exchange timeout\n");
        };

        // Playback buffers info
        buffer_info.played_real_time = card->played_time;
        buffer_info.played_frames_count = card->frames_count;
        buffer_info.playback_buffer_cycle = (card->buffer - 1)
                % SWAPPING_BUFFERS; //Buffer played

        // Record buffers info
        buffer_info.recorded_real_time = card->played_time;
        buffer_info.recorded_frames_count = card->frames_count;
        buffer_info.record_buffer_cycle = (card->buffer - 1)
                % SWAPPING_BUFFERS; //Buffer filled

#ifdef __HAIKU__
        if (user_memcpy(data, &buffer_info, sizeof(buffer_info)) < B_OK)
                return B_BAD_ADDRESS;
#else
        memcpy(data, &buffer_info, sizeof(buffer_info));
#endif

        return B_OK;
}


status_t
ice1712Buffer_Stop(ice1712 *card)
{
        write_mt_uint8(card, MT_PROF_PB_CONTROL, 0);

        card->played_time = 0;
        card->frames_count = 0;
        card->buffer = 0;

        return B_OK;
}

//ICE1712 Multi - Description
//---------------------------

status_t
ice1712Get_Description(ice1712 *card, multi_description *data)
{
        int chan = 0, i, size;

        data->interface_version = B_CURRENT_INTERFACE_VERSION;
        data->interface_minimum = B_CURRENT_INTERFACE_VERSION;

        switch (card->config.product) {
                case ICE1712_SUBDEVICE_DELTA1010:
                        strncpy(data->friendly_name, "Delta 1010", 32);
                        break;
                case ICE1712_SUBDEVICE_DELTADIO2496:
                        strncpy(data->friendly_name, "Delta DIO 2496", 32);
                        break;
                case ICE1712_SUBDEVICE_DELTA66:
                        strncpy(data->friendly_name, "Delta 66", 32);
                        break;
                case ICE1712_SUBDEVICE_DELTA44:
                        strncpy(data->friendly_name, "Delta 44", 32);
                        break;
                case ICE1712_SUBDEVICE_AUDIOPHILE_2496:
                        strncpy(data->friendly_name, "Audiophile 2496", 32);
                        break;
                case ICE1712_SUBDEVICE_DELTA410:
                        strncpy(data->friendly_name, "Delta 410", 32);
                        break;
                case ICE1712_SUBDEVICE_DELTA1010LT:
                        strncpy(data->friendly_name, "Delta 1010 LT", 32);
                        break;
                case ICE1712_SUBDEVICE_VX442:
                        strncpy(data->friendly_name, "VX 442", 32);
                        break;

                default:
                        strncpy(data->friendly_name, "Unknow device", 32);
                        break;
        }

        strncpy(data->vendor_info, "Haiku", 32);

        data->output_channel_count = card->total_output_channels;
        data->input_channel_count = card->total_input_channels;
        data->output_bus_channel_count = 0;
        data->input_bus_channel_count = 0;
        data->aux_bus_channel_count = 0;

        size =  data->output_channel_count + data->input_channel_count
                + data->output_bus_channel_count + data->input_bus_channel_count
                + data->aux_bus_channel_count;

        ITRACE_VV("request_channel_count = %" B_PRIi32 "\n",
                data->request_channel_count);

        if (size <= data->request_channel_count) {
                for (i = 0; i < card->config.nb_DAC; i++) {
                //Analog STEREO output
                        data->channels[chan].channel_id = chan;
                        data->channels[chan].kind = B_MULTI_OUTPUT_CHANNEL;
                        data->channels[chan].designations = B_CHANNEL_STEREO_BUS
                                | (((i & 1) == 0) ? B_CHANNEL_LEFT : B_CHANNEL_RIGHT);
                        data->channels[chan].connectors = 0;
                        chan++;
                }

                if (card->config.spdif & SPDIF_OUT_PRESENT) {
                //SPDIF STEREO output
                        data->channels[chan].channel_id = chan;
                        data->channels[chan].kind = B_MULTI_OUTPUT_CHANNEL;
                        data->channels[chan].designations = B_CHANNEL_STEREO_BUS
                                | B_CHANNEL_LEFT;
                        data->channels[chan].connectors = 0;
                        chan++;
                        data->channels[chan].channel_id = chan;
                        data->channels[chan].kind = B_MULTI_OUTPUT_CHANNEL;
                        data->channels[chan].designations = B_CHANNEL_STEREO_BUS
                                | B_CHANNEL_RIGHT;
                        data->channels[chan].connectors = 0;
                        chan++;
                }

                for (i = 0; i < card->config.nb_ADC; i++) {
                //Analog STEREO input
                        data->channels[chan].channel_id = chan;
                        data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
                        data->channels[chan].designations = B_CHANNEL_STEREO_BUS
                                | (((i & 1) == 0) ? B_CHANNEL_LEFT : B_CHANNEL_RIGHT);
                        data->channels[chan].connectors = 0;
                        chan++;
                }

                if (card->config.spdif & SPDIF_IN_PRESENT) {
                //SPDIF STEREO input
                        data->channels[chan].channel_id = chan;
                        data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
                        data->channels[chan].designations = B_CHANNEL_STEREO_BUS
                                | B_CHANNEL_LEFT;
                        data->channels[chan].connectors = 0;
                        chan++;
                        data->channels[chan].channel_id = chan;
                        data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
                        data->channels[chan].designations = B_CHANNEL_STEREO_BUS
                                | B_CHANNEL_RIGHT;
                        data->channels[chan].connectors = 0;
                        chan++;
                }

                //The digital mixer output (it's an Input for Haiku)
                data->channels[chan].channel_id = chan;
                data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
                data->channels[chan].designations = B_CHANNEL_STEREO_BUS
                        | B_CHANNEL_LEFT;
                data->channels[chan].connectors = 0;
                chan++;
                data->channels[chan].channel_id = chan;
                data->channels[chan].kind = B_MULTI_INPUT_CHANNEL;
                data->channels[chan].designations = B_CHANNEL_STEREO_BUS
                        | B_CHANNEL_RIGHT;
                data->channels[chan].connectors = 0;
                chan++;
        }

        ITRACE("output_channel_count = %" B_PRIi32 "\n",
                data->output_channel_count);
        ITRACE("input_channel_count = %" B_PRIi32 "\n",
                data->input_channel_count);
        ITRACE("output_bus_channel_count = %" B_PRIi32 "\n",
                data->output_bus_channel_count);
        ITRACE("input_bus_channel_count = %" B_PRIi32 "\n",
                data->input_bus_channel_count);

        data->output_rates = data->input_rates = AUTHORIZED_RATE;
        data->min_cvsr_rate = 44100;
        data->max_cvsr_rate = 96000;

        data->output_formats = data->input_formats = AUTHORIZED_SAMPLE_SIZE;
        data->lock_sources = B_MULTI_LOCK_INTERNAL | B_MULTI_LOCK_SPDIF;
        data->timecode_sources = 0;
        data->interface_flags = B_MULTI_INTERFACE_PLAYBACK
                | B_MULTI_INTERFACE_RECORD;
        data->start_latency = 0;

        strcpy(data->control_panel,"");

        return B_OK;
}


status_t
ice1712Get_Channel(ice1712 *card, multi_channel_enable *data)
{
        int i, total_channel;
        uint8 reg;

        total_channel = card->total_output_channels + card->total_input_channels;
        for (i = 0; i < total_channel; i++)
                B_SET_CHANNEL(data->enable_bits, i, true);

        reg = read_mt_uint8(card, MT_SAMPLING_RATE_SELECT);

        if (reg == 0x10)
                data->lock_source = B_MULTI_LOCK_SPDIF;
        else
                data->lock_source = B_MULTI_LOCK_INTERNAL;

        return B_OK;
}


status_t
ice1712Set_Channel(ice1712 *card, multi_channel_enable *data)
{
        int i;
        int total_channel;

        total_channel = card->total_output_channels + card->total_input_channels;
        for (i = 0; i < total_channel; i++)
                ITRACE_VV("set_enabled_channels %d : %s\n", i,
                        B_TEST_CHANNEL(data->enable_bits, i) ? "enabled": "disabled");

        ITRACE_VV("lock_source %" B_PRIx32 "\n", data->lock_source);
        ITRACE_VV("lock_data %" B_PRIx32 "\n", data->lock_data);

        if (data->lock_source == B_MULTI_LOCK_SPDIF)
                write_mt_uint8(card, MT_SAMPLING_RATE_SELECT, 0x10);
        else
                write_mt_uint8(card, MT_SAMPLING_RATE_SELECT,
                        card->config.samplingRate);

        card->config.lockSource = data->lock_source;

        return B_OK;
}


status_t
ice1712Get_Format(ice1712 *card, multi_format_info *data)
{
        uint8 sr = read_mt_uint8(card, MT_SAMPLING_RATE_SELECT);

        switch (sr) {
                case ICE1712_SAMPLERATE_48K:
                        data->input.rate = data->output.rate = B_SR_48000;
                        data->input.cvsr = data->output.cvsr = 48000.0f;
                        break;
                case ICE1712_SAMPLERATE_96K:
                        data->input.rate = data->output.rate = B_SR_96000;
                        data->input.cvsr = data->output.cvsr = 96000.0f;
                        break;
                case ICE1712_SAMPLERATE_44K1:
                        data->input.rate = data->output.rate = B_SR_44100;
                        data->input.cvsr = data->output.cvsr = 44100.0f;
                        break;
                case ICE1712_SAMPLERATE_88K2:
                        data->input.rate = data->output.rate = B_SR_88200;
                        data->input.cvsr = data->output.cvsr = 88200.0f;
                        break;
        }

        data->timecode_kind = 0;
        data->output_latency = data->input_latency = 0;
        data->output.format = data->input.format = AUTHORIZED_SAMPLE_SIZE;

        ITRACE("Sampling Rate = %f\n", data->input.cvsr);

        return B_OK;
}


status_t
ice1712Set_Format(ice1712 *card, multi_format_info *data)
{
        ITRACE("Input Sampling Rate = %" B_PRIu32 "\n",
                data->input.rate);
        ITRACE("Output Sampling Rate = %" B_PRIu32 "\n",
                data->output.rate);

        //We can't have a different rate for input and output
        //so just wait to change our sample rate when
        //media server will do what we need
        //Lie to it and say we are living in wonderland
        if (data->input.rate != data->output.rate)
                return B_OK;

        if (card->config.lockSource == B_MULTI_LOCK_INTERNAL) {
                switch (data->output.rate) {
                        case B_SR_96000:
                                card->config.samplingRate = 0x07;
                                break;
                        case B_SR_88200:
                                card->config.samplingRate = 0x0B;
                                break;
                        case B_SR_48000:
                                card->config.samplingRate = 0x00;
                                break;
                        case B_SR_44100:
                                card->config.samplingRate = 0x08;
                                break;
                }
                write_mt_uint8(card, MT_SAMPLING_RATE_SELECT,
                        card->config.samplingRate);
        }
        ITRACE("New rate = %#x\n", read_mt_uint8(card, MT_SAMPLING_RATE_SELECT));

        return B_OK;
}

//ICE1712 Multi - UI
//------------------

static const char *Clock[] = {
        "Internal",
        "Digital",
        NULL,
};

static const char *DigitalFormat[] = {
        "Consumer",
        "Professional",
        NULL,
};

static const char *DigitalEmphasis[] = {
        "None",
        "CCITT",
        "15/50usec",
        NULL,
};

static const char *DigitalCopyMode[] = {
        "Original",
        "1st Generation",
        "No SCMS",
        NULL,
};

static const char **SettingsGeneral[] = {
        Clock,
        NULL,
};

static const char **SettingsDigital[] = {
        DigitalFormat,
        DigitalEmphasis,
        DigitalCopyMode,
        NULL,
};

static const char *string_list[] = {
        "Setup",
        "General",
        "Digital",
        "Output Selection",

        "Internal Mixer",

        //General settings
        "Master clock",
        "reserved_0",
        "reserved_1",

        //Digital settings
        "Output format",
        "Emphasis",
        "Copy mode",

        //Output Selection
        "Output 1", //11
        "Output 2",
        "Output 3",
        "Output 4",
        "Digital Output", //15

        "Haiku output", //16

        "Input 1", //17
        "Input 2",
        "Input 3",
        "Input 4",
        "Digital Input", //21
        "Internal mixer", //22
};


/*
 * This will create a Tab
 */
int32
ice1712UI_CreateGroup(multi_mix_control **p_mmc, int32 index,
        int32 parent, enum strind_id string, const char* name)
{
        multi_mix_control *mmc = *p_mmc;
        int32 group;

        mmc->id = ICE1712_MULTI_CONTROL_FIRSTID + ICE1712_MULTI_SET_INDEX(index);
        mmc->parent = parent;
        mmc->flags = B_MULTI_MIX_GROUP;
        mmc->master = CONTROL_IS_MASTER;
        mmc->string = string;

        group = mmc->id;

        if (name != NULL)
                strcpy(mmc->name, name);

        ITRACE_VV("Create Group: ID %#" B_PRIx32 "\n", mmc->id);

        nb_control_created++; mmc++;
        (*p_mmc) = mmc;

        return group;
}


/*
 * This will create a Slider with a "Mute" CheckBox
 */
void
ice1712UI_CreateChannel(multi_mix_control **p_mmc, int32 channel,
        int32 parent, const char* name)
{
        int32 id = ICE1712_MULTI_CONTROL_FIRSTID
                + ICE1712_MULTI_CONTROL_TYPE_VOLUME
                + ICE1712_MULTI_SET_CHANNEL(channel);
        multi_mix_control *mmc = *p_mmc;
        multi_mix_control control;

        control.master = CONTROL_IS_MASTER;
        control.parent = parent;
        control.gain.max_gain = 0.0;
        control.gain.min_gain = -144.0;
        control.gain.granularity = 1.5;

        //The Mute Checkbox
        control.id = id++;
        control.flags = B_MULTI_MIX_ENABLE;
        control.string = S_MUTE;
        *mmc = control;
        mmc++;

        ITRACE_VV("Create Channel (Mute): ID %#" B_PRIx32 "\n", control.id);

        //The Left Slider
        control.string = S_null;
        control.id = id++;
        control.flags = B_MULTI_MIX_GAIN;
        if (name != NULL)
                strcpy(control.name, name);
        *mmc = control;
        mmc++;

        ITRACE_VV("Create Channel (Left): ID %#" B_PRIx32 "\n", control.id);

        //The Right Slider
        control.master = control.id; //The Id of the Left Slider
        control.id = id++;
        *mmc = control;
        mmc++;

        ITRACE_VV("Create Channel (Right): ID %#" B_PRIx32 "\n", control.id);

        nb_control_created += 3;
        (*p_mmc) = mmc;
}


void
ice1712UI_CreateCombo(multi_mix_control **p_mmc, const char *values[],
        int32 parent, int32 nb_combo, const char *name)
{
        int32 id = ICE1712_MULTI_CONTROL_FIRSTID
                + ICE1712_MULTI_CONTROL_TYPE_COMBO
                + ICE1712_MULTI_SET_CHANNEL(nb_combo);
        multi_mix_control *mmc = *p_mmc;
        int32 parentControl, i;

        //The label
        parentControl = mmc->id = id++;
        mmc->flags = B_MULTI_MIX_MUX;
        mmc->parent = parent;
        strcpy(mmc->name, name);

        ITRACE_VV("Create Combo (label): ID %#" B_PRIx32 "\n", parentControl);

        nb_control_created++; mmc++;

        //The values
        for (i = 0; values[i] != NULL; i++) {
                mmc->id = id++;
                mmc->flags = B_MULTI_MIX_MUX_VALUE;
                mmc->parent = parentControl;
                strcpy(mmc->name, values[i]);

                ITRACE_VV("Create Combo (value): ID %#" B_PRIx32 "\n", mmc->id);

                nb_control_created++; mmc++;
        }

        (*p_mmc) = mmc;
}


/*
 * This will create all possible value for the output
 * output 0 -> 3 (physical stereo output) 4 is the Digital
 */
void
ice1712UI_CreateOutput(ice1712 *card, multi_mix_control **p_mmc,
        int32 output, int32 parent)
{
        int32 id = ICE1712_MULTI_CONTROL_FIRSTID
                + ICE1712_MULTI_CONTROL_TYPE_OUTPUT
                + ICE1712_MULTI_SET_CHANNEL(output);
        multi_mix_control *mmc = *p_mmc;
        int32 parentControl, i;

        //The label
        parentControl = mmc->id = id++;
        mmc->flags = B_MULTI_MIX_MUX;
        mmc->parent = parent;
        strcpy(mmc->name, string_list[11 + output]);
        nb_control_created++; mmc++;

        ITRACE_VV("Create Output (label): ID %#" B_PRIx32 "\n", parentControl);

        //Haiku output
        mmc->id = id++;
        mmc->flags = B_MULTI_MIX_MUX_VALUE;
        mmc->parent = parentControl;
        strcpy(mmc->name, string_list[16]);

        ITRACE_VV("Create Output (Haiku): ID %#" B_PRIx32 "\n", mmc->id);

        nb_control_created++; mmc++;

        //Physical Input
        for (i = 0; i < card->config.nb_DAC; i += 2) {
                mmc->id = id++;
                mmc->flags = B_MULTI_MIX_MUX_VALUE;
                mmc->parent = parentControl;
                strcpy(mmc->name, string_list[17 + (i / 2)]);

                ITRACE_VV("Create Output (Physical In): ID %#" B_PRIx32 "\n", mmc->id);

                nb_control_created++; mmc++;
        }

        //Physical Digital Input
        if (card->config.spdif & SPDIF_IN_PRESENT) {
                mmc->id = id++;
                mmc->flags = B_MULTI_MIX_MUX_VALUE;
                mmc->parent = parentControl;
                strcpy(mmc->name, string_list[21]);

                ITRACE_VV("Create Output (Digital In) ID %#" B_PRIx32 "\n", mmc->id);

                nb_control_created++; mmc++;
        }

        //Internal mixer only for Output 1 and Digital Output
        if ((output == 0) || (output == 4)) {
                mmc->id = id++;
                mmc->flags = B_MULTI_MIX_MUX_VALUE;
                mmc->parent = parentControl;
                strcpy(mmc->name, string_list[22]);

                ITRACE_VV("Create Output (Mix); ID %#" B_PRIx32 "\n", mmc->id);

                nb_control_created++; mmc++;
        }

        (*p_mmc) = mmc;
}


uint32
ice1712UI_GetCombo(ice1712 *card, uint32 index)
{
        uint32 value = 0;

        switch (index) {
                case 0:
                        value = card->settings.clock;
                        break;

                case 1:
                        value = card->settings.outFormat;
                        break;

                case 2:
                        value = card->settings.emphasis;
                        break;

                case 3:
                        value = card->settings.copyMode;
                        break;
        }

        ITRACE_VV("Get combo: %" B_PRIu32 ", %" B_PRIu32 "\n",
                index, value);

        return value;
}


void
ice1712UI_SetCombo(ice1712 *card, uint32 index, uint32 value)
{
        ITRACE_VV("Set combo: %" B_PRIu32 ", %" B_PRIu32 "\n", index, value);

        switch (index) {
                case 0:
                        if (value < 2)
                                card->settings.clock = value;
                        break;

                case 1:
                        if (value < 2)
                                card->settings.outFormat = value;
                        break;

                case 2:
                        if (value < 3)
                                card->settings.emphasis = value;
                        break;

                case 3:
                        if (value < 3)
                                card->settings.copyMode = value;
                        break;
        }
}


uint32
ice1712UI_GetOutput(ice1712 *card, uint32 index)
{
        uint32 value = 0;

        if (index < 5)
                value = card->settings.output[index];

        ITRACE_VV("Get output: %" B_PRIu32 ", %" B_PRIu32 "\n", index, value);

        return value;
}


void
ice1712UI_SetOutput(ice1712 *card, uint32 index, uint32 value)
{
        if (index < 5)
                card->settings.output[index] = value;

        ITRACE_VV("Set output: %" B_PRIu32 ", %" B_PRIu32 "\n", index, value);
}


void
ice1712UI_GetVolume(ice1712 *card, multi_mix_value *mmv)
{
        ice1712Volume *vol;
        uint32 chan = ICE1712_MULTI_GET_CHANNEL(mmv->id);

        ITRACE_VV("Get volume\n");

        if (chan < ICE1712_HARDWARE_VOLUME) {
                vol = card->settings.playback;
        } else {
                vol = card->settings.record;
                chan -= ICE1712_HARDWARE_VOLUME;
        }

        //chan is normaly <= ICE1712_HARDWARE_VOLUME
        switch (ICE1712_MULTI_GET_INDEX(mmv->id)) {
                case 0: //Mute
                        mmv->enable = vol[chan].mute | vol[chan + 1].mute;
                        ITRACE_VV("     Get mute %d for channel %d or %d\n",
                                mmv->enable, (int)chan, (int)chan + 1);
                        break;

                case 2: //Right channel
                        chan++;
                        //No break
                case 1: //Left channel
                        mmv->gain = vol[chan].volume;
                        ITRACE_VV("     Get Volume %f for channel %d\n",
                                mmv->gain, (int)chan);
                        break;
        }
}


void
ice1712UI_SetVolume(ice1712 *card, multi_mix_value *mmv)
{
        ice1712Volume *vol;
        uint32 chan = ICE1712_MULTI_GET_CHANNEL(mmv->id);

        ITRACE_VV("Set volume\n");

        if (chan < ICE1712_HARDWARE_VOLUME) {
                vol = card->settings.playback;
        } else {
                vol = card->settings.record;
                chan -= ICE1712_HARDWARE_VOLUME;
        }

        //chan is normaly <= ICE1712_HARDWARE_VOLUME
        switch (ICE1712_MULTI_GET_INDEX(mmv->id)) {
                case 0: //Mute
                        vol[chan].mute = mmv->enable;
                        vol[chan + 1].mute = mmv->enable;
                        ITRACE_VV("     Change mute to %d for channel %d and %d\n",
                                mmv->enable, (int)chan, (int)chan + 1);
                        break;

                case 2: //Right channel
                        chan++;
                        //No break
                case 1: //Left channel
                        vol[chan].volume = mmv->gain;
                        ITRACE_VV("     Change Volume to %f for channel %d\n",
                                mmv->gain, (int)chan);
                        break;
        }
}

//ICE1712 Multi - MIX
//-------------------

status_t
ice1712Get_MixValue(ice1712 *card, multi_mix_value_info *data)
{
        int i;

        for (i = 0; i < data->item_count; i++) {
                multi_mix_value *mmv = &(data->values[i]);
                ITRACE_VV("Get Mix: Id %" B_PRIu32 "\n", mmv->id);
                switch (mmv->id & ICE1712_MULTI_CONTROL_TYPE_MASK) {
                        case ICE1712_MULTI_CONTROL_TYPE_COMBO:
                                mmv->mux = ice1712UI_GetCombo(card,
                                        ICE1712_MULTI_GET_CHANNEL(mmv->id));
                                break;

                        case ICE1712_MULTI_CONTROL_TYPE_VOLUME:
                                ice1712UI_GetVolume(card, mmv);
                                break;

                        case ICE1712_MULTI_CONTROL_TYPE_OUTPUT:
                                mmv->mux = ice1712UI_GetOutput(card,
                                        ICE1712_MULTI_GET_CHANNEL(mmv->id));
                                break;

                        default:
                                ITRACE_VV("Get Mix: unknow %" B_PRIu32 "\n", mmv->id);
                                break;
                }
        }

        return B_OK;
}


status_t
ice1712Set_MixValue(ice1712 *card, multi_mix_value_info *data)
{
        int i;

        for (i = 0; i < data->item_count; i++) {
                multi_mix_value *mmv = &(data->values[i]);
                ITRACE_VV("Set Mix: Id %" B_PRIu32 "\n", mmv->id);
                switch (mmv->id & ICE1712_MULTI_CONTROL_TYPE_MASK) {
                        case ICE1712_MULTI_CONTROL_TYPE_COMBO:
                                ice1712UI_SetCombo(card,
                                        ICE1712_MULTI_GET_CHANNEL(mmv->id), mmv->mux);
                                break;

                        case ICE1712_MULTI_CONTROL_TYPE_VOLUME:
                                ice1712UI_SetVolume(card, mmv);
                                break;

                        case ICE1712_MULTI_CONTROL_TYPE_OUTPUT:
                                ice1712UI_SetOutput(card,
                                        ICE1712_MULTI_GET_CHANNEL(mmv->id), mmv->mux);
                                break;

                        default:
                                ITRACE_VV("Set Mix: unknow %" B_PRIu32 "\n", mmv->id);
                                break;
                }
        }

        return ice1712Settings_apply(card);
}


/*
 * Not implemented
 */
status_t
ice1712Get_MixValueChannel(ice1712 *card, multi_mix_channel_info *data)
{
        return B_OK;
}


status_t
ice1712Get_MixValueControls(ice1712 *card, multi_mix_control_info *mmci)
{
        int32 i;
        uint32 parentTab, parentTabColumn;
        multi_mix_control *mmc = mmci->controls;
        uint32 group = 0, combo = 0, channel = 0;

        nb_control_created = 0;

        ITRACE_VV("Get MixValue Channels: Max %" B_PRIi32 "\n", mmci->control_count);

        //Cleaning
        memset(mmc, 0, mmci->control_count * sizeof(multi_mix_control));

        //Setup tab
        parentTab = ice1712UI_CreateGroup(&mmc, group++,
                CONTROL_IS_MASTER, S_SETUP, NULL);

        //General Settings
        parentTabColumn = ice1712UI_CreateGroup(&mmc, group++, parentTab,
                S_null, string_list[1]);
        for (i = 0; SettingsGeneral[i] != NULL; i++) {
                ice1712UI_CreateCombo(&mmc, SettingsGeneral[i], parentTabColumn,
                        combo++, string_list[5 + i]);
        }

        //Digital Settings
        parentTabColumn = ice1712UI_CreateGroup(&mmc, group++, parentTab,
                S_null, string_list[2]);
        for (i = 0; SettingsDigital[i] != NULL; i++) {
                ice1712UI_CreateCombo(&mmc, SettingsDigital[i], parentTabColumn,
                        combo++, string_list[8 + i]);
        }

        //Output Selection Settings
        parentTabColumn = ice1712UI_CreateGroup(&mmc, group++, parentTab,
                S_null, string_list[3]);
        for (i = 0; i < card->config.nb_DAC; i += 2) {
                ice1712UI_CreateOutput(card, &mmc, i / 2, parentTabColumn);
        }

        if (card->config.spdif & SPDIF_OUT_PRESENT) {
                ice1712UI_CreateOutput(card, &mmc, 4, parentTabColumn);
        }

        //Internal Mixer Tab
        //Output
        parentTab = ice1712UI_CreateGroup(&mmc, group++, CONTROL_IS_MASTER,
                S_null, string_list[4]);

        for (i = 0; i < card->config.nb_DAC; i += 2) {
                parentTabColumn = ice1712UI_CreateGroup(&mmc, group++,
                        parentTab, S_null, string_list[(i / 2) + 11]);
                ice1712UI_CreateChannel(&mmc, channel++, parentTabColumn, NULL);
        }

        if (card->config.spdif & SPDIF_OUT_PRESENT) {
                parentTabColumn = ice1712UI_CreateGroup(&mmc, group++,
                        parentTab, S_null, string_list[15]);
                ice1712UI_CreateChannel(&mmc, ICE1712_HARDWARE_VOLUME - 2,
                        parentTabColumn, NULL);
        }

        //Input
        channel = ICE1712_HARDWARE_VOLUME;
        for (i = 0; i < card->config.nb_ADC; i += 2) {
                parentTabColumn = ice1712UI_CreateGroup(&mmc, group++,
                        parentTab, S_null, string_list[(i / 2) + 17]);
                ice1712UI_CreateChannel(&mmc, channel++, parentTabColumn, NULL);
        }

        if (card->config.spdif & SPDIF_IN_PRESENT) {
                parentTabColumn = ice1712UI_CreateGroup(&mmc, group++,
                        parentTab, S_null, string_list[21]);
                ice1712UI_CreateChannel(&mmc, 2 * ICE1712_HARDWARE_VOLUME - 2,
                        parentTabColumn, NULL);
        }

        mmci->control_count = nb_control_created;
        ITRACE_VV("Get MixValue Channels: Returned %" B_PRIi32 "\n",
                mmci->control_count);

        return B_OK;
}


/*
 * Not implemented
 */
status_t
ice1712Get_MixValueConnections(ice1712 *card,
        multi_mix_connection_info *data)
{
        data->actual_count = 0;
        return B_OK;
}


status_t
ice1712Buffer_Get(ice1712 *card, multi_buffer_list *data)
{
        const size_t stride_o = MAX_DAC * SAMPLE_SIZE;
        const size_t stride_i = MAX_ADC * SAMPLE_SIZE;
        const uint32 buf_o = stride_o * card->buffer_size;
        const uint32 buf_i = stride_i * card->buffer_size;
        int buff, chan_i = 0, chan_o = 0;

        ITRACE_VV("flags = %#" B_PRIx32 "\n", data->flags);
        ITRACE_VV("request_playback_buffers = %" B_PRIu32 "\n",
                        data->request_playback_buffers);
        ITRACE_VV("request_playback_channels = %" B_PRIu32 "\n",
                        data->request_playback_channels);
        ITRACE_VV("request_playback_buffer_size = %" B_PRIx32 "\n",
                        data->request_playback_buffer_size);
        ITRACE_VV("request_record_buffers = %" B_PRIu32 "\n",
                        data->request_record_buffers);
        ITRACE_VV("request_record_channels = %" B_PRIu32 "\n",
                        data->request_record_channels);
        ITRACE_VV("request_record_buffer_size = %" B_PRIx32 "\n",
                        data->request_record_buffer_size);

        for (buff = 0; buff < SWAPPING_BUFFERS; buff++) {
                if (data->request_playback_channels == card->total_output_channels) {
                        for (chan_o = 0; chan_o < card->config.nb_DAC; chan_o++) {
                        //Analog STEREO output
                                data->playback_buffers[buff][chan_o].base =
                                        (char*)(card->log_addr_pb + buf_o * buff
                                                + SAMPLE_SIZE * chan_o);
                                data->playback_buffers[buff][chan_o].stride = stride_o;
                                ITRACE_VV("pb_buffer[%d][%d] = %p\n", buff, chan_o,
                                        data->playback_buffers[buff][chan_o].base);
                        }

                        if (card->config.spdif & SPDIF_OUT_PRESENT) {
                        //SPDIF STEREO output
                                data->playback_buffers[buff][chan_o].base =
                                        (char*)(card->log_addr_pb + buf_o * buff
                                                + SAMPLE_SIZE * SPDIF_LEFT);
                                data->playback_buffers[buff][chan_o].stride = stride_o;
                                ITRACE_VV("pb_buffer[%d][%d] = %p\n", buff, chan_o,
                                        data->playback_buffers[buff][chan_o].base);

                                chan_o++;
                                data->playback_buffers[buff][chan_o].base =
                                        (char*)(card->log_addr_pb + buf_o * buff
                                                + SAMPLE_SIZE * SPDIF_RIGHT);
                                data->playback_buffers[buff][chan_o].stride = stride_o;
                                ITRACE_VV("pb_buffer[%d][%d] = %p\n", buff, chan_o,
                                        data->playback_buffers[buff][chan_o].base);
                                chan_o++;
                        }
                }

                if (data->request_record_channels ==
                        card->total_input_channels) {
                        for (chan_i = 0; chan_i < card->config.nb_ADC; chan_i++) {
                        //Analog STEREO input
                                data->record_buffers[buff][chan_i].base =
                                        (char*)(card->log_addr_rec + buf_i * buff
                                                + SAMPLE_SIZE * chan_i);
                                data->record_buffers[buff][chan_i].stride = stride_i;
                                ITRACE_VV("rec_buffer[%d][%d] = %p\n", buff, chan_i,
                                        data->record_buffers[buff][chan_i].base);
                        }

                        if (card->config.spdif & SPDIF_IN_PRESENT) {
                        //SPDIF STEREO input
                                data->record_buffers[buff][chan_i].base =
                                        (char*)(card->log_addr_rec + buf_i * buff
                                                + SAMPLE_SIZE * SPDIF_LEFT);
                                data->record_buffers[buff][chan_i].stride = stride_i;
                                ITRACE_VV("rec_buffer[%d][%d] = %p\n", buff, chan_i,
                                        data->record_buffers[buff][chan_i].base);

                                chan_i++;
                                data->record_buffers[buff][chan_i].base =
                                        (char*)(card->log_addr_rec + buf_i * buff
                                                + SAMPLE_SIZE * SPDIF_RIGHT);
                                data->record_buffers[buff][chan_i].stride = stride_i;
                                ITRACE_VV("rec_buffer[%d][%d] = %p\n", buff, chan_i,
                                        data->record_buffers[buff][chan_i].base);
                                chan_i++;
                        }

                        //The digital mixer output
                        data->record_buffers[buff][chan_i].base =
                                (char*)(card->log_addr_rec + buf_i * buff
                                        + SAMPLE_SIZE * MIXER_OUT_LEFT);
                        data->record_buffers[buff][chan_i].stride = stride_i;
                        ITRACE_VV("rec_buffer[%d][%d] = %p\n", buff, chan_i,
                                        data->record_buffers[buff][chan_i].base);

                        chan_i++;
                        data->record_buffers[buff][chan_i].base =
                                (char*)(card->log_addr_rec + buf_i * buff
                                        + SAMPLE_SIZE * MIXER_OUT_RIGHT);
                        data->record_buffers[buff][chan_i].stride = stride_i;
                        ITRACE_VV("rec_buffer[%d][%d] = %p\n", buff, chan_i,
                                        data->record_buffers[buff][chan_i].base);
                        chan_i++;
                }
        }

        data->return_playback_buffers = SWAPPING_BUFFERS;
        data->return_playback_channels = card->total_output_channels;
        data->return_playback_buffer_size = card->buffer_size;

        ITRACE("return_playback_buffers = %" B_PRIi32 "\n",
                data->return_playback_buffers);
        ITRACE("return_playback_channels = %" B_PRIi32 "\n",
                data->return_playback_channels);
        ITRACE("return_playback_buffer_size = %" B_PRIu32 "\n",
                data->return_playback_buffer_size);

        data->return_record_buffers = SWAPPING_BUFFERS;
        data->return_record_channels = card->total_input_channels;
        data->return_record_channels = chan_i;
        data->return_record_buffer_size = card->buffer_size;

        ITRACE("return_record_buffers = %" B_PRIi32 "\n",
                data->return_record_buffers);
        ITRACE("return_record_channels = %" B_PRIi32 "\n",
                data->return_record_channels);
        ITRACE("return_record_buffer_size = %" B_PRIu32 "\n",
                data->return_record_buffer_size);

        ice1712Buffer_Start(card);

        return B_OK;
}