static void Isw5010da_initialize__(Isw5010da_t *pThis) {
    uint32_t snr;
    g_parallelSnrNums = 2;
    pThis->snr = Sys_readSerialNumberFromFlash() & 0xFFFFFUL;
    dwIndoorFunctionKey_t indoorFunctionKey = DWINDOOR_FUNCTIONKEY_NONE;
    DeviceParam_initialize(DEVICEPARAM_SNR_OWN, pThis->snr);
    DeviceParam_initialize(DEVICEPARAM_INFO_CLASS, DEVICE_CLASS_INDOOR_HANDSFREE);

    /*ModularBus parameters*/
    DeviceParam_initialize(DEVICEPARAM_INFO_MODULARBUS_TYPE, 0x02);
    DeviceParam_initialize(DEVICEPARAM_INFO_MODULARBUS_SUBTYPE, 0x02);
    DeviceParam_initialize(DEVICEPARAM_INFO_MODULARBUS_SPECIAL_PARAMETER, 0x00);
    DeviceParam_initialize(DEVICEPARAM_INFO_MODULARBUS_VERSION, 0x0E);
    DeviceParam_initialize(DEVICEPARAM_SNR_MODULARBUS, pThis->snr & 0xFFFFFUL);

    /*Eeprom location 0x00*/
    DeviceParam_initialize(DEVICEPARAM_INFO_ID_CODE, (pThis->eeprom.buffer[0] & 0xF0) >> 4);
    DeviceParam_initialize(DEVICEPARAM_INFO_HW_VERSION, DEVICE_HW_VERSION);
    DeviceParam_initialize(DEVICEPARAM_INFO_FW_VERSION, DEVICE_FW_VERSION);

    /*EEPROM locatio 0x02*/
    /*Eeprom location 0x03 lower nibble and locations 0x04, 0x05*/
    snr = convert3BytesBigEndianTo32Bit(&pThis->eeprom.buffer[0x03]) & 0xFFFFFUL;
    DeviceParam_initialize(DEVICEPARAM_COMM_REDIRECTION_OUT_SNR, snr);
    DeviceParam_initialize(DEVICEPARAM_INDOOR_INTERNAL_CALL_SNR, snr);

    /*Eeprom location 0x06 lower nibble and locations 0x07, 0x08*/
    snr = convert3BytesBigEndianTo32Bit(&pThis->eeprom.buffer[0x06]) & 0xFFFFFUL;
    DeviceParam_initialize(DEVICEPARAM_SNR_PARALLEL_2, snr);

    /*Eeprom location 0x09 lower nibble and locations 0x0A, 0x0B*/
    snr = convert3BytesBigEndianTo32Bit(&pThis->eeprom.buffer[0x09]) & 0xFFFFFUL;
    DeviceParam_initialize(DEVICEPARAM_SNR_PARALLEL_1, snr);

    /*Eeprom location 0x0C bit 0*/
    DeviceState_initialize(DEVICESTATE_RINGER_SUPPRESSED,
            GET_BIT(pThis->eeprom.buffer[0x0C], 0) == 1 ? TRUE : FALSE);

    /*Eeprom location 0x0C bit 1*/

    /*Eeprom location 0x0D higher nibble*/
    switch ((pThis->eeprom.buffer[0x0D] & 0x30)) {
        case 0x00: {                                                          /* control function */
            indoorFunctionKey = DWINDOOR_FUNCTIONKEY_CONTROL_FUNCTION;
            break;
        }
        case 0x10: {                                                            /* door automatic */
            DeviceState_initialize(DEVICESTATE_COMM_REDIRECTION_OUT_ACTIVE, FALSE);
            indoorFunctionKey = DWINDOOR_FUNCTIONKEY_DOOR_AUTOMATIC;
            DeviceState_initialize(DEVICESTATE_COMM_DOOR_AUTOMATIC_ACTIVE,
                    GET_BIT(pThis->eeprom.buffer[0x0C], 1) == 1 ? TRUE : FALSE);
            if (GET_BIT(pThis->eeprom.buffer[0x0C], 1) == 1) {
                LedManager_passEvent_setLedOn(LED_TOE);
            } else {
                LedManager_passEvent_setLedOff(LED_TOE);
            }
            break;
        }
        case 0x20: {                                                               /* redirection */
            DeviceState_initialize(DEVICESTATE_COMM_DOOR_AUTOMATIC_ACTIVE, FALSE);
            indoorFunctionKey = DWINDOOR_FUNCTIONKEY_REDIRECTION;
            DeviceState_initialize(DEVICESTATE_COMM_REDIRECTION_OUT_ACTIVE,
                    GET_BIT(pThis->eeprom.buffer[0x0C], 1) == 1 ? TRUE : FALSE);
            break;
        }
        case 0x30: {                                                             /* internal call */
            indoorFunctionKey = DWINDOOR_FUNCTIONKEY_INTERNAL_CALL;
            break;
        }
        default: {
            break;
        }
    }
    switch ((pThis->eeprom.buffer[0x0D] & 0x06) >> 1) {
        case 0x00: {
            pThis->lightFunction = LIGHT_FUNC;
            g_parallelSnrNums = 2;
            break;
        }
        case 0x01: {
            pThis->lightFunction = CONTROL_FUNC_9;
            g_parallelSnrNums = 2;
            break;
        }
        case 0x02: {
            pThis->lightFunction = INTERN_CALL_FUNC;
            g_parallelSnrNums = 1;
            break;
        }
        default: {
            pThis->lightFunction = LIGHT_FUNC;
            g_parallelSnrNums = 2;
        }
    }
    pThis->intCall2Snr = convert3BytesBigEndianTo32Bit(&pThis->eeprom.buffer[0x06]) & 0xFFFFFUL;

    DeviceParam_initialize(DEVICEPARAM_INDOOR_FUNCTIONKEY, indoorFunctionKey);

    /*eeprom address 0x0F*/
    DeviceState_initialize(DEVICESTATE_COMM_FLATDOOR_OPENER_ENABLED,
            GET_BIT(pThis->eeprom.buffer[0x0F], 0) == 1 ? TRUE : FALSE);
    DeviceParam_initialize(DEVICEPARAM_COMM_MANUAL_TALKING_DIRECTION, /*when TRUE no handsfree mode available*/
            GET_BIT(pThis->eeprom.buffer[0x0F], 3) == 0 ? FALSE : TRUE);
    DeviceParam_initialize(DEVICEPARAM_INDOOR_AUTO_ANSWER_INTERNAL_CALL,
            GET_BIT(pThis->eeprom.buffer[0x0F], 4) == 1 ? TRUE : FALSE);
    DeviceParam_initialize(DEVICEPARAM_INDOOR_RINGTONE_ADJUSTMENT_LOCK,
            GET_BIT(pThis->eeprom.buffer[0x0F], 5) == 1 ? TRUE : FALSE);
    DeviceParam_initialize(DEVICEPARAM_INDOOR_RINGTONE_SUPPRESSION_LOCK,
            GET_BIT(pThis->eeprom.buffer[0x0F], 6) == 1 ? TRUE : FALSE);
    pThis->ambSwitchLock = GET_BIT(pThis->eeprom.buffer[0x0F], 7) == 1 ? TRUE: FALSE;

    /*Eeprom locations 0x011, 0x12, 0x13*/
    /*Eeprom location 0x14*/
    DeviceParam_initialize(DEVICEPARAM_RINGER_LOUDNESS, pThis->eeprom.buffer[0x14] & 0x07);
    pThis->ringtoneLoudness =  pThis->eeprom.buffer[0x14] & 0x07;
    pThis->prevRingtoneLoudness = pThis->ringtoneLoudness;

    /*Eeprom location 0x15*/
    pThis->speechLoudnessOut = pThis->eeprom.buffer[0x15] & 0x07;
    pThis->prevSpeechLoudness = pThis->speechLoudness;
    DeviceParam_initialize(DEVICEPARAM_AUDIO_OUTDOOR_SPEECH_LOUDNESS,
            pThis->speechLoudnessOut);

    if (GET_BIT(pThis->eeprom.buffer[0x17], 2) == 1) {         /* speech loudness separation */
        pThis->speechLoudnessIn = (pThis->eeprom.buffer[0x15] & 0x70) >> 4;
        DeviceParam_initialize(DEVICEPARAM_AUDIO_INDOOR_SPEECH_LOUDNESS,
                pThis->speechLoudnessIn);
        pThis->inOutLoudnessSeparation = TRUE;
    } else {
        pThis->speechLoudnessIn = pThis->speechLoudnessOut;
        /* same loudness for indoor and outdoor speech */
        DeviceParam_initialize(DEVICEPARAM_AUDIO_INDOOR_SPEECH_LOUDNESS,
                pThis->speechLoudnessIn);
        pThis->inOutLoudnessSeparation = FALSE;
    }
    /*Eeprom location 0x16*/
    DeviceParam_initialize(DEVICEPARAM_RINGER_OUTDOOR_BORDER_ADDRESS,
            pThis->eeprom.buffer[0x16] & 0x3F);

    /*Eeprom location 0x17 bit 0*/
    DeviceParam_initialize(DEVICEPARAM_COMM_TALK_TIME_LIMIT,
            (GET_BIT(pThis->eeprom.buffer[0x17], 0) == 1 ? 0 : 120));
    if (GET_BIT (pThis->eeprom.buffer[0x17], 1) == 1) {
        if (GET_BIT (pThis->eeprom.buffer[0x17], 3) == 1) {
            pThis->ambLedBehavior = STANDARD_OFF_IN_QUIET;
        } else {
            pThis->ambLedBehavior = ALLWAYS_OFF;
        }
        LedManager_passEvent_setLedOff(LED_AMB);
    } else {
        if (GET_BIT (pThis->eeprom.buffer[0x17], 3) == 1) {
            pThis->ambLedBehavior = STANDARD_ON_IN_QUIET;
        } else {
            pThis->ambLedBehavior = ALLWAYS_ON;
        }
        LedManager_passEvent_setLedOn(LED_AMB);
    }

    if (GET_BIT(pThis->eeprom.buffer[0x17], 4) == 0x01) {
        DwComm_passEvent_requestDoorOpenerLong();
        pThis->isDoorOpenerLong = TRUE;
    } else {
        pThis->isDoorOpenerLong = FALSE;
    }

    if (GET_BIT(pThis->eeprom.buffer[0x17], 5) == 0x01) {
        DwComm_passEvent_requestDoorAutoDelayed();
        pThis->isDoorOpenerDelayed = TRUE;
    } else {
        pThis->isDoorOpenerDelayed = FALSE;
        pThis->doorOpenerDelay = 0;
    }

    /*Eeprom location 0x18*/
    DeviceParam_initialize(DEVICEPARAM_RINGER_OUTDOOR_INCALL_1, pThis->eeprom.buffer[0x18]);

    /*Eeprom location 0x19*/
    DeviceParam_initialize(DEVICEPARAM_RINGER_INDOOR_INCALL, pThis->eeprom.buffer[0x19]);

    /*Eeprom location 0x1A*/
    DeviceParam_initialize(DEVICEPARAM_RINGER_FLATDOOR_INCALL, pThis->eeprom.buffer[0x1A]);

    /*Eeprom location 0x1B*/
    if (pThis->eeprom.buffer[0x1B] == 0xFF) {
        g_allAsCallsRingSame = TRUE;
        DeviceParam_initialize(DEVICEPARAM_RINGER_OUTDOOR_INCALL_2, pThis->eeprom.buffer[0x18]);
    } else {
        g_allAsCallsRingSame = FALSE;
        DeviceParam_initialize(DEVICEPARAM_RINGER_OUTDOOR_INCALL_2, pThis->eeprom.buffer[0x1B]);
    }

    /*Eeprom location 0x1C */
    DeviceParam_initialize(DEVICEPARAM_COMM_SEND_CALLER_ID, TRUE);
    /*Eeprom location 0x20*/
    g_volumeValue = pThis->eeprom.buffer[0x20 + (pThis->eeprom.buffer[0x14] & 0x07)];
}