diff --git a/recipes-ccsp/hal/hal-wifi-patches/0048-HAL-refactor-OperatingParameters.patch b/recipes-ccsp/hal/hal-wifi-patches/0048-HAL-refactor-OperatingParameters.patch
new file mode 100644
index 0000000..662b14a
--- /dev/null
+++ b/recipes-ccsp/hal/hal-wifi-patches/0048-HAL-refactor-OperatingParameters.patch
@@ -0,0 +1,509 @@
+From bdb9047c372c2ffa801df4be27be075e20e48084 Mon Sep 17 00:00:00 2001
+From: "Allen.Ye" <allen.ye@mediatek.com>
+Date: Thu, 8 Sep 2022 10:07:20 +0800
+Subject: [PATCH] HAL: refactor OperatingParameters
+
+---
+ source/wifi/wifi_hal.c | 399 +++++++++++++++++++++++++++++++++++++----
+ 1 file changed, 360 insertions(+), 39 deletions(-)
+
+diff --git a/source/wifi/wifi_hal.c b/source/wifi/wifi_hal.c
+index 414b60a..d87fd99 100644
+--- a/source/wifi/wifi_hal.c
++++ b/source/wifi/wifi_hal.c
+@@ -2223,6 +2223,28 @@ INT wifi_setBandSteeringApGroup(char *ApGroup)
+     return RETURN_OK;
+ }
+ 
++INT wifi_getApDTIMInterval(INT apIndex, INT *dtimInterval)
++{
++    char config_file[128] = {'\0'};
++    char buf[128] = {'\0'};
++
++    WIFI_ENTRY_EXIT_DEBUG("Inside %s:%d\n",__func__, __LINE__);
++    if (dtimInterval == NULL)
++        return RETURN_ERR;
++
++    snprintf(config_file, sizeof(config_file), "%s%d.conf", CONFIG_PREFIX, apIndex);
++    wifi_hostapdRead(config_file, "dtime_period", buf, sizeof(buf));
++
++    if (strlen(buf) == 0) {
++        *dtimInterval = 2;
++    } else {
++        *dtimInterval = strtoul(buf, NULL, 10);
++    }
++
++    WIFI_ENTRY_EXIT_DEBUG("Exiting %s:%d\n",__func__, __LINE__);
++    return RETURN_OK;
++}
++
+ INT wifi_setApDTIMInterval(INT apIndex, INT dtimInterval)
+ {
+     struct params params={0};
+@@ -10530,79 +10552,371 @@ int main(int argc,char **argv)
+ 
+ #ifdef WIFI_HAL_VERSION_3
+ 
++INT BitMapToTransmitRates(UINT bitMap, char *BasicRate)
++{
++    WIFI_ENTRY_EXIT_DEBUG("Inside %s:%d\n",__func__, __LINE__);
++    if (bitMap & WIFI_BITRATE_1MBPS)
++        strcat(BasicRate, "1,");
++    if (bitMap & WIFI_BITRATE_2MBPS)
++        strcat(BasicRate, "2,");
++    if (bitMap & WIFI_BITRATE_5_5MBPS)
++        strcat(BasicRate, "5.5,");
++    if (bitMap & WIFI_BITRATE_6MBPS)
++        strcat(BasicRate, "6,");
++    if (bitMap & WIFI_BITRATE_9MBPS)
++        strcat(BasicRate, "9,");
++    if (bitMap & WIFI_BITRATE_11MBPS)
++        strcat(BasicRate, "11,");
++    if (bitMap & WIFI_BITRATE_12MBPS)
++        strcat(BasicRate, "12,");
++    if (bitMap & WIFI_BITRATE_18MBPS)
++        strcat(BasicRate, "18,");
++    if (bitMap & WIFI_BITRATE_24MBPS)
++        strcat(BasicRate, "24,");
++    if (bitMap & WIFI_BITRATE_36MBPS)
++        strcat(BasicRate, "36,");
++    if (bitMap & WIFI_BITRATE_48MBPS)
++        strcat(BasicRate, "48,");
++    if (bitMap & WIFI_BITRATE_54MBPS)
++        strcat(BasicRate, "54,");
++    if (strlen(BasicRate) != 0)     // remove last comma
++        BasicRate[strlen(BasicRate) - 1] = '\0';
++    WIFI_ENTRY_EXIT_DEBUG("Exiting %s:%d\n",__func__, __LINE__);
++    return RETURN_OK;
++}
++
++INT TransmitRatesToBitMap (char *BasicRatesList, UINT *basicRateBitMap)
++{
++    UINT BitMap = 0;
++    char *rate;
++
++    WIFI_ENTRY_EXIT_DEBUG("Inside %s:%d\n",__func__, __LINE__);
++    rate = strtok(BasicRatesList, ",");
++    while(rate != NULL)
++    {
++        if (strcmp(rate, "1") == 0)
++            BitMap |= WIFI_BITRATE_1MBPS;
++        else if (strcmp(rate, "2") == 0)
++            BitMap |= WIFI_BITRATE_2MBPS;
++        else if (strcmp(rate, "5.5") == 0)
++            BitMap |= WIFI_BITRATE_5_5MBPS;
++        else if (strcmp(rate, "6") == 0)
++            BitMap |= WIFI_BITRATE_6MBPS;
++        else if (strcmp(rate, "9") == 0)
++            BitMap |= WIFI_BITRATE_9MBPS;
++        else if (strcmp(rate, "11") == 0)
++            BitMap |= WIFI_BITRATE_11MBPS;
++        else if (strcmp(rate, "12") == 0)
++            BitMap |= WIFI_BITRATE_12MBPS;
++        else if (strcmp(rate, "18") == 0)
++            BitMap |= WIFI_BITRATE_18MBPS;
++        else if (strcmp(rate, "24") == 0)
++            BitMap |= WIFI_BITRATE_24MBPS;
++        else if (strcmp(rate, "36") == 0)
++            BitMap |= WIFI_BITRATE_36MBPS;
++        else if (strcmp(rate, "48") == 0)
++            BitMap |= WIFI_BITRATE_48MBPS;
++        else if (strcmp(rate, "54") == 0)
++            BitMap |= WIFI_BITRATE_54MBPS;
++        rate = strtok(NULL, ",");
++    }
++    *basicRateBitMap = BitMap;
++    WIFI_ENTRY_EXIT_DEBUG("Exiting %s:%d\n",__func__, __LINE__);
++    return RETURN_OK;
++}
++
++// This API is used to configured all radio operation parameter in a single set. it includes channel number, channelWidth, mode and auto chammel configuration.
+ INT wifi_setRadioOperatingParameters(wifi_radio_index_t index, wifi_radio_operationParam_t *operationParam)
+ {
+-    // The only par-radio parameter is a channel number, however there's a 'dynamic' API
+-    // to change it ("wifi_pushRadioChannel2()") that is used instead.
++    char buf[128] = {0};
++    char cmd[128] = {0};
++    char config_file[64] = {0};
++    int bandwidth;
++    wifi_ieee80211_Mode set_mode;
++    wifi_radio_operationParam_t current_param;
++
++    WIFI_ENTRY_EXIT_DEBUG("Inside %s:%d\n",__func__, __LINE__);
++
++    if (wifi_getRadioOperatingParameters(index, &current_param) != RETURN_OK) {
++        fprintf(stderr, "%s: wifi_getRadioOperatingParameters return error.\n", __func__);
++        return RETURN_ERR;
++    }
++    if (current_param.enable != operationParam->enable) {
++        if (wifi_setRadioEnable(index, operationParam->enable) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setRadioEnable return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.autoChannelEnabled != operationParam->autoChannelEnabled) {
++        if (wifi_setRadioAutoChannelEnable(index, operationParam->autoChannelEnabled) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setRadioAutoChannelEnable return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.channelWidth != operationParam->channelWidth || (current_param.channel != operationParam->channel && !operationParam->autoChannelEnabled)) {
++        if (operationParam->channelWidth == WIFI_CHANNELBANDWIDTH_20MHZ)
++            bandwidth = 20;
++        else if (operationParam->channelWidth == WIFI_CHANNELBANDWIDTH_40MHZ)
++            bandwidth = 40;
++        else if (operationParam->channelWidth == WIFI_CHANNELBANDWIDTH_80MHZ)
++            bandwidth = 80;
++        else if (operationParam->channelWidth == WIFI_CHANNELBANDWIDTH_160MHZ)
++            bandwidth = 160;
++        if (wifi_pushRadioChannel2(index, operationParam->channel, bandwidth, operationParam->csa_beacon_count) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_pushRadioChannel2 return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.variant != operationParam->variant) {
++        // Two different definition bit map, so need to check every bit.
++        if (operationParam->variant & WIFI_80211_VARIANT_A)
++            set_mode |= WIFI_MODE_A;
++        if (operationParam->variant & WIFI_80211_VARIANT_B)
++            set_mode |= WIFI_MODE_B;
++        if (operationParam->variant & WIFI_80211_VARIANT_G)
++            set_mode |= WIFI_MODE_G;
++        if (operationParam->variant & WIFI_80211_VARIANT_N)
++            set_mode |= WIFI_MODE_N;
++        if (operationParam->variant & WIFI_80211_VARIANT_AC)
++            set_mode |= WIFI_MODE_AC;
++        if (operationParam->variant & WIFI_80211_VARIANT_AX)
++            set_mode |= WIFI_MODE_AX;
++        // Second parameter is to set channel band width, it is done by wifi_pushRadioChannel2 if changed.
++        memset(buf, 0, sizeof(buf));
++        if (wifi_setRadioMode(index, buf, set_mode) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setRadioMode return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.dtimPeriod != operationParam->dtimPeriod) {
++        if (wifi_setApDTIMInterval(index, operationParam->dtimPeriod) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setApDTIMInterval return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.beaconInterval != operationParam->beaconInterval) {
++        if (wifi_setRadioBeaconPeriod(index, operationParam->beaconInterval) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setRadioBeaconPeriod return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.operationalDataTransmitRates != operationParam->operationalDataTransmitRates) {
++        BitMapToTransmitRates(operationParam->operationalDataTransmitRates, buf);
++        if (wifi_setRadioBasicDataTransmitRates(index, buf) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setRadioBasicDataTransmitRates return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.fragmentationThreshold != operationParam->fragmentationThreshold) {
++        if (wifi_setRadioFragmentationThreshold(index, operationParam->fragmentationThreshold) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setRadioFragmentationThreshold return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.guardInterval != operationParam->guardInterval) {
++        if (wifi_setGuardInterval(index, operationParam->guardInterval) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setGuardInterval return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.transmitPower != operationParam->transmitPower) {
++        if (wifi_setRadioTransmitPower(index, operationParam->transmitPower) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setRadioTransmitPower return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.rtsThreshold != operationParam->rtsThreshold) {
++        if (wifi_setApRtsThreshold(index, operationParam->rtsThreshold) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setApRtsThreshold return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.obssCoex != operationParam->obssCoex) {
++        if (wifi_setRadioObssCoexistenceEnable(index, operationParam->obssCoex) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setRadioObssCoexistenceEnable return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.stbcEnable != operationParam->stbcEnable) {
++        if (wifi_setRadioSTBCEnable(index, operationParam->stbcEnable) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setRadioSTBCEnable return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    if (current_param.greenFieldEnable != operationParam->greenFieldEnable) {
++        if (wifi_setRadio11nGreenfieldEnable(index, operationParam->greenFieldEnable) != RETURN_OK) {
++            fprintf(stderr, "%s: wifi_setRadio11nGreenfieldEnable return error.\n", __func__);
++            return RETURN_ERR;
++        }
++    }
++    WIFI_ENTRY_EXIT_DEBUG("Exiting %s:%d\n",__func__, __LINE__);
++
+     return RETURN_OK;
+ }
+ 
+ INT wifi_getRadioOperatingParameters(wifi_radio_index_t index, wifi_radio_operationParam_t *operationParam)
+ {
+-    INT ret;
+-    char band[128];
++    char band[64] = {0};
++    char buf[256] = {0};
++    char config_file[64] = {0};
++    char cmd[128] = {0};
++    int ret;
++    int mode = 0;
++    wifi_ieee80211_Mode get_mode = 0;
+     ULONG channel;
++    ULONG lval;
+     BOOL enabled;
+-    char buf[256];
+ 
+     WIFI_ENTRY_EXIT_DEBUG("Inside %s:%d\n",__func__, __LINE__);
+     printf("Entering %s index = %d\n", __func__, (int)index);
+ 
+-    ret = wifi_getRadioEnable(index, &enabled);
+-    if (ret != RETURN_OK)
++    memset(operationParam, 0, sizeof(wifi_radio_operationParam_t));
++    snprintf(config_file, sizeof(config_file), "%s%d.conf", CONFIG_PREFIX, index);
++    if (wifi_getRadioEnable(index, &enabled) != RETURN_OK)
+     {
+-        printf("%s: cannot get enabled state for radio index %d\n", __func__,
+-                index);
++        fprintf(stderr, "%s: wifi_getRadioEnable return error.\n", __func__);
+         return RETURN_ERR;
+     }
+     operationParam->enable = enabled;
+ 
+     memset(band, 0, sizeof(band));
+-    ret = wifi_getRadioOperatingFrequencyBand(index, band);
+-    if (ret != RETURN_OK)
++    if (wifi_getRadioOperatingFrequencyBand(index, band) != RETURN_OK)
+     {
+-        printf("%s: cannot get radio band for radio index %d\n", __func__, index);
++        fprintf(stderr, "%s: wifi_getRadioOperatingFrequencyBand return error.\n", __func__);
+         return RETURN_ERR;
+     }
+ 
+     if (!strcmp(band, "2.4GHz"))
+-    {
+         operationParam->band = WIFI_FREQUENCY_2_4_BAND;
+-        operationParam->variant = WIFI_80211_VARIANT_N;
+-    }
+     else if (!strcmp(band, "5GHz"))
+-    {
+         operationParam->band = WIFI_FREQUENCY_5_BAND;
+-        operationParam->variant = WIFI_80211_VARIANT_AC;
+-    }
++    else if (!strcmp(band, "6GHz"))
++        operationParam->band = WIFI_FREQUENCY_6_BAND;
+     else
+     {
+-        printf("%s: cannot decode band for radio index %d ('%s')\n", __func__, index,
++        fprintf(stderr, "%s: cannot decode band for radio index %d ('%s')\n", __func__, index,
+             band);
+     }
+ 
++    wifi_hostapdRead(config_file, "channel", buf, sizeof(buf));
++    if (strcmp(buf, "0") == 0 || strcmp(buf, "acs_survey") == 0) {
++        operationParam->channel = 0;
++        operationParam->autoChannelEnabled = TRUE;
++    } else {
++        operationParam->channel = strtol(buf, NULL, 10);
++        operationParam->autoChannelEnabled = FALSE;
++    }
++
+     memset(buf, 0, sizeof(buf));
+-    ret = wifi_getRadioOperatingChannelBandwidth(index, buf); // XXX: handle errors
+-    // XXX: only handle 20/40/80 modes for now
++    if (wifi_getRadioOperatingChannelBandwidth(index, buf) != RETURN_OK) {
++        fprintf(stderr, "%s: wifi_getRadioOperatingChannelBandwidth return error.\n", __func__);
++        return RETURN_ERR;
++    }
+     if (!strcmp(buf, "20MHz")) operationParam->channelWidth = WIFI_CHANNELBANDWIDTH_20MHZ;
+     else if (!strcmp(buf, "40MHz")) operationParam->channelWidth = WIFI_CHANNELBANDWIDTH_40MHZ;
+     else if (!strcmp(buf, "80MHz")) operationParam->channelWidth = WIFI_CHANNELBANDWIDTH_80MHZ;
++    else if (!strcmp(buf, "160")) operationParam->channelWidth = WIFI_CHANNELBANDWIDTH_160MHZ;
++    else if (!strcmp(buf, "80+80")) operationParam->channelWidth = WIFI_CHANNELBANDWIDTH_80_80MHZ;
+     else
+     {
+-        printf("%s: Unknown HT mode: '%s'\n", __func__, buf);
+-        operationParam->channelWidth = 0;
++        fprintf(stderr, "Unknown channel bandwidth: %s\n", buf);
++        return false;
+     }
+ 
+-    ret = wifi_getRadioChannel(index, &channel);
+-    if (ret != RETURN_OK)
+-    {
+-        printf("%s: Failed to get channel number for radio index %d\n", __func__, index);
+-        channel = 0;
++    if (wifi_getRadioMode(index, buf, &mode) != RETURN_OK) {
++        fprintf(stderr, "%s: wifi_getRadioMode return error.\n", __func__);
++        return RETURN_ERR;
++    }
++    get_mode = (wifi_ieee80211_Mode)mode;
++    if (get_mode & WIFI_MODE_A)
++        operationParam->variant |= WIFI_80211_VARIANT_A;
++    if (get_mode & WIFI_MODE_B)
++        operationParam->variant |= WIFI_80211_VARIANT_B;
++    if (get_mode & WIFI_MODE_G)
++        operationParam->variant |= WIFI_80211_VARIANT_G;
++    if (get_mode & WIFI_MODE_N)
++        operationParam->variant |= WIFI_80211_VARIANT_N;
++    if (get_mode & WIFI_MODE_AC)
++        operationParam->variant |= WIFI_80211_VARIANT_AC;
++    if (get_mode & WIFI_MODE_AX)
++        operationParam->variant |= WIFI_80211_VARIANT_AX;
++    if (wifi_getRadioDCSEnable(index, &operationParam->DCSEnabled) != RETURN_OK) {
++        fprintf(stderr, "%s: wifi_getRadioDCSEnable return error.\n", __func__);
++        return RETURN_ERR;
++    }
++    if (wifi_getApDTIMInterval(index, &operationParam->dtimPeriod) != RETURN_OK) {
++        fprintf(stderr, "%s: wifi_getApDTIMInterval return error.\n", __func__);
++        return RETURN_ERR;
++    }
++    if (wifi_getRadioBeaconPeriod(index, &operationParam->dtimPeriod) != RETURN_OK) {
++        fprintf(stderr, "%s: wifi_getRadioBeaconPeriod return error.\n", __func__);
++        return RETURN_ERR;
++    }
++
++    memset(buf, 0, sizeof(buf));
++    if (wifi_getRadioSupportedDataTransmitRates(index, buf) != RETURN_OK) {
++        fprintf(stderr, "%s: wifi_getRadioSupportedDataTransmitRates return error.\n", __func__);
++        return RETURN_ERR;
++    }
++    TransmitRatesToBitMap(buf, &operationParam->basicDataTransmitRates);
++
++    memset(buf, 0, sizeof(buf));
++    if (wifi_getRadioBasicDataTransmitRates(index, buf) != RETURN_OK) {
++        fprintf(stderr, "%s: wifi_getRadioBasicDataTransmitRates return error.\n", __func__);
++        return RETURN_ERR;
++    }
++    TransmitRatesToBitMap(buf, &operationParam->operationalDataTransmitRates);
++
++    memset(buf, 0, sizeof(buf));
++    wifi_hostapdRead(config_file, "fragm_threshold", buf, sizeof(buf));
++    operationParam->fragmentationThreshold = strtoul(buf, NULL, 10);
++
++    if (wifi_getGuardInterval(index, &operationParam->guardInterval) != RETURN_OK) {
++        fprintf(stderr, "%s: wifi_getGuardInterval return error.\n", __func__);
++        return RETURN_ERR;
++    }
++    if (wifi_getRadioPercentageTransmitPower(index, &operationParam->transmitPower) != RETURN_OK) {
++        fprintf(stderr, "%s: wifi_getRadioPercentageTransmitPower return error.\n", __func__);
++        return RETURN_ERR;
+     }
+-    operationParam->channel = channel;
+-    operationParam->csa_beacon_count = 15; // XXX: hardcoded for now
+ 
+-    operationParam->countryCode = wifi_countrycode_US; // XXX: hardcoded for now
++    memset(buf, 0, sizeof(buf));
++    wifi_hostapdRead(config_file, "rts_threshold", buf, sizeof(buf));
++    if (strcmp(buf, "-1") == 0) {
++        operationParam->rtsThreshold = (UINT)-1;    // maxuimum unsigned integer value
++        operationParam->ctsProtection = FALSE;
++    } else {
++        operationParam->rtsThreshold = strtoul(buf, NULL, 10);
++        operationParam->ctsProtection = TRUE;
++    }
++
++    memset(buf, 0, sizeof(buf));
++    wifi_hostapdRead(config_file, "ht_coex", buf, sizeof(buf));
++    if (strcmp(buf, "0") == 0)
++        operationParam->obssCoex = FALSE;
++    else
++        operationParam->obssCoex = TRUE;
++
++    snprintf(cmd, sizeof(cmd), "cat %s | grep STBC", config_file);
++    _syscmd(cmd, buf, sizeof(buf));
++    if (strlen(buf) != 0)
++        operationParam->stbcEnable = TRUE;
++    else
++        operationParam->stbcEnable = FALSE;
++
++    if (wifi_getRadio11nGreenfieldEnable(index, &operationParam->greenFieldEnable) != RETURN_OK) {
++        fprintf(stderr, "%s: wifi_getRadio11nGreenfieldEnable return error.\n", __func__);
++        return RETURN_ERR;
++    }
++
++    // Below value is hardcoded
++
++    operationParam->numSecondaryChannels = 0;
++    for (int i = 0; i < MAXNUMSECONDARYCHANNELS; i++) {
++        operationParam->channelSecondary[i] = 0;
++    }
++    operationParam->csa_beacon_count = 15;
++    operationParam->countryCode = wifi_countrycode_US;  // need to conver string to corresponding enum
+ 
+     WIFI_ENTRY_EXIT_DEBUG("Exiting %s:%d\n",__func__, __LINE__);
+     return RETURN_OK;
+@@ -10784,6 +11098,7 @@ static int getRadioCapabilities(int radioIndex, wifi_radio_capabilities_t *rcap)
+     wifi_channels_list_t *chlistp;
+     CHAR output_string[64];
+     CHAR pchannels[128];
++    wifi_band band;
+ 
+     if(rcap == NULL)
+     {
+@@ -10791,11 +11106,14 @@ static int getRadioCapabilities(int radioIndex, wifi_radio_capabilities_t *rcap)
+     }
+ 
+     rcap->numSupportedFreqBand = 1;
+-    if (1 == radioIndex)
+-      rcap->band[0] = WIFI_FREQUENCY_5_BAND;
+-    else
+-      rcap->band[0] = WIFI_FREQUENCY_2_4_BAND;
++    band = wifi_index_to_band(radioIndex);
+ 
++    if (band == band_2_4)
++        rcap->band[0] = WIFI_FREQUENCY_2_4_BAND;
++    else if (band == band_5)
++        rcap->band[0] = WIFI_FREQUENCY_5_BAND;
++    else if (band == band_6)
++        rcap->band[0] = WIFI_FREQUENCY_6_BAND;
+ 
+     chlistp = &(rcap->channel_list[0]);
+     memset(pchannels, 0, sizeof(pchannels));
+@@ -10854,7 +11172,7 @@ static int getRadioCapabilities(int radioIndex, wifi_radio_capabilities_t *rcap)
+                                 WIFI_CHANNELBANDWIDTH_40MHZ);
+ 
+     }
+-    else if (rcap->band[i] & (WIFI_FREQUENCY_5_BAND )) {
++    else if (rcap->band[i] & (WIFI_FREQUENCY_5_BAND ) || rcap->band[i] & (WIFI_FREQUENCY_6_BAND)) {
+         rcap->channelWidth[i] |= (WIFI_CHANNELBANDWIDTH_20MHZ |
+                                 WIFI_CHANNELBANDWIDTH_40MHZ |
+                                 WIFI_CHANNELBANDWIDTH_80MHZ | WIFI_CHANNELBANDWIDTH_160MHZ);
+@@ -10864,10 +11182,13 @@ static int getRadioCapabilities(int radioIndex, wifi_radio_capabilities_t *rcap)
+     /* mode - all supported variants */
+     // rcap->mode[i] = WIFI_80211_VARIANT_H;
+     if (rcap->band[i] & WIFI_FREQUENCY_2_4_BAND ) {
+-        rcap->mode[i] = (WIFI_80211_VARIANT_N);
++        rcap->mode[i] = ( WIFI_80211_VARIANT_B | WIFI_80211_VARIANT_G | WIFI_80211_VARIANT_N | WIFI_80211_VARIANT_AX );
+     }
+     else if (rcap->band[i] & WIFI_FREQUENCY_5_BAND ) {
+-        rcap->mode[i] = ( WIFI_80211_VARIANT_AC );
++        rcap->mode[i] = ( WIFI_80211_VARIANT_A | WIFI_80211_VARIANT_N | WIFI_80211_VARIANT_AC | WIFI_80211_VARIANT_AX );
++    }
++    else if (rcap->band[i] & WIFI_FREQUENCY_6_BAND) {
++        rcap->mode[i] = ( WIFI_80211_VARIANT_AX );
+     }
+     rcap->maxBitRate[i] = ( rcap->band[i] & WIFI_FREQUENCY_2_4_BAND ) ? 300 :
+         ((rcap->band[i] & WIFI_FREQUENCY_5_BAND) ? 1734 : 0);
+@@ -10878,7 +11199,7 @@ static int getRadioCapabilities(int radioIndex, wifi_radio_capabilities_t *rcap)
+         rcap->supportedBitRate[i] |= (WIFI_BITRATE_6MBPS | WIFI_BITRATE_9MBPS |
+                                     WIFI_BITRATE_11MBPS | WIFI_BITRATE_12MBPS);
+     }
+-    else if (rcap->band[i] & (WIFI_FREQUENCY_5_BAND )) {
++    else if (rcap->band[i] & (WIFI_FREQUENCY_5_BAND ) | rcap->band[i] & (WIFI_FREQUENCY_6_BAND )) {
+         rcap->supportedBitRate[i] |= (WIFI_BITRATE_6MBPS | WIFI_BITRATE_9MBPS |
+                                     WIFI_BITRATE_12MBPS | WIFI_BITRATE_18MBPS | WIFI_BITRATE_24MBPS |
+                                     WIFI_BITRATE_36MBPS | WIFI_BITRATE_48MBPS | WIFI_BITRATE_54MBPS);
+-- 
+2.18.0
+