if (rt2x00_has_cap_bt_coexist(rt2x00dev)) {
                if (rt2x00_rt_rev_gte(rt2x00dev, RT5390, REV_RT5390F)) {
                        /* r55/r59 value array of channel 1~14 */
-                       static const char r55_bt_rev[] = {0x83, 0x83,
+                       static const u8 r55_bt_rev[] = {0x83, 0x83,
                                0x83, 0x73, 0x73, 0x63, 0x53, 0x53,
                                0x53, 0x43, 0x43, 0x43, 0x43, 0x43};
-                       static const char r59_bt_rev[] = {0x0e, 0x0e,
+                       static const u8 r59_bt_rev[] = {0x0e, 0x0e,
                                0x0e, 0x0e, 0x0e, 0x0b, 0x0a, 0x09,
                                0x07, 0x07, 0x07, 0x07, 0x07, 0x07};
 
                        rt2800_rfcsr_write(rt2x00dev, 59,
                                           r59_bt_rev[idx]);
                } else {
-                       static const char r59_bt[] = {0x8b, 0x8b, 0x8b,
+                       static const u8 r59_bt[] = {0x8b, 0x8b, 0x8b,
                                0x8b, 0x8b, 0x8b, 0x8b, 0x8a, 0x89,
                                0x88, 0x88, 0x86, 0x85, 0x84};
 
                }
        } else {
                if (rt2x00_rt_rev_gte(rt2x00dev, RT5390, REV_RT5390F)) {
-                       static const char r55_nonbt_rev[] = {0x23, 0x23,
+                       static const u8 r55_nonbt_rev[] = {0x23, 0x23,
                                0x23, 0x23, 0x13, 0x13, 0x03, 0x03,
                                0x03, 0x03, 0x03, 0x03, 0x03, 0x03};
-                       static const char r59_nonbt_rev[] = {0x07, 0x07,
+                       static const u8 r59_nonbt_rev[] = {0x07, 0x07,
                                0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
                                0x07, 0x07, 0x06, 0x05, 0x04, 0x04};
 
                } else if (rt2x00_rt(rt2x00dev, RT5390) ||
                           rt2x00_rt(rt2x00dev, RT5392) ||
                           rt2x00_rt(rt2x00dev, RT6352)) {
-                       static const char r59_non_bt[] = {0x8f, 0x8f,
+                       static const u8 r59_non_bt[] = {0x8f, 0x8f,
                                0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8d,
                                0x8a, 0x88, 0x88, 0x87, 0x87, 0x86};
 
                        rt2800_rfcsr_write(rt2x00dev, 59,
                                           r59_non_bt[idx]);
                } else if (rt2x00_rt(rt2x00dev, RT5350)) {
-                       static const char r59_non_bt[] = {0x0b, 0x0b,
+                       static const u8 r59_non_bt[] = {0x0b, 0x0b,
                                0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a,
                                0x0a, 0x09, 0x08, 0x07, 0x07, 0x06};
 
        rt2800_bbp_write(rt2x00dev, 159, cal != 0xff ? cal : 0);
 }
 
-static char rt2800_txpower_to_dev(struct rt2x00_dev *rt2x00dev,
+static s8 rt2800_txpower_to_dev(struct rt2x00_dev *rt2x00dev,
                                  unsigned int channel,
-                                 char txpower)
+                                 s8 txpower)
 {
        if (rt2x00_rt(rt2x00dev, RT3593) ||
            rt2x00_rt(rt2x00dev, RT3883))
                txpower = rt2x00_get_field8(txpower, EEPROM_TXPOWER_ALC);
 
        if (channel <= 14)
-               return clamp_t(char, txpower, MIN_G_TXPOWER, MAX_G_TXPOWER);
+               return clamp_t(s8, txpower, MIN_G_TXPOWER, MAX_G_TXPOWER);
 
        if (rt2x00_rt(rt2x00dev, RT3593) ||
            rt2x00_rt(rt2x00dev, RT3883))
-               return clamp_t(char, txpower, MIN_A_TXPOWER_3593,
+               return clamp_t(s8, txpower, MIN_A_TXPOWER_3593,
                               MAX_A_TXPOWER_3593);
        else
-               return clamp_t(char, txpower, MIN_A_TXPOWER, MAX_A_TXPOWER);
+               return clamp_t(s8, txpower, MIN_A_TXPOWER, MAX_A_TXPOWER);
 }
 
 static void rt3883_bbp_adjust(struct rt2x00_dev *rt2x00dev,
        u8 bytevalue = 0;
        int rcalcode;
        u8 r_cal_code = 0;
-       char d1 = 0, d2 = 0;
+       s8 d1 = 0, d2 = 0;
        u8 rfvalue;
        u32 MAC_RF_BYPASS0, MAC_RF_CONTROL0, MAC_PWR_PIN_CFG;
        u32 maccfg;
        if (bytevalue > 128)
                d1 = bytevalue - 256;
        else
-               d1 = (char)bytevalue;
+               d1 = (s8)bytevalue;
        rt2800_bbp_write(rt2x00dev, 22, 0x0);
        rt2800_rfcsr_write_bank(rt2x00dev, 0, 35, 0x01);
 
        if (bytevalue > 128)
                d2 = bytevalue - 256;
        else
-               d2 = (char)bytevalue;
+               d2 = (s8)bytevalue;
        rt2800_bbp_write(rt2x00dev, 22, 0x0);
 
        rcalcode = rt2800_calcrcalibrationcode(rt2x00dev, d1, d2);
 static u32 rt2800_do_sqrt_accumulation(u32 si)
 {
        u32 root, root_pre, bit;
-       char i;
+       s8 i;
 
        bit = 1 << 15;
        root = 0;
                               u8 alc_idx, u8 dc_result[][RF_ALC_NUM][2])
 {
        u32 p0 = 0, p1 = 0, pf = 0;
-       char idx0 = 0, idx1 = 0;
+       s8 idx0 = 0, idx1 = 0;
        u8 idxf[] = {0x00, 0x00};
        u8 ibit = 0x20;
        u8 iorq;
-       char bidx;
+       s8 bidx;
 
        rt2800_bbp_write(rt2x00dev, 158, 0xb0);
        rt2800_bbp_write(rt2x00dev, 159, 0x80);
 static void rt2800_iq_search(struct rt2x00_dev *rt2x00dev, u8 ch_idx, u8 *ges, u8 *pes)
 {
        u32 p0 = 0, p1 = 0, pf = 0;
-       char perr = 0, gerr = 0, iq_err = 0;
-       char pef = 0, gef = 0;
-       char psta, pend;
-       char gsta, gend;
+       s8 perr = 0, gerr = 0, iq_err = 0;
+       s8 pef = 0, gef = 0;
+       s8 psta, pend;
+       s8 gsta, gend;
 
        u8 ibit = 0x20;
        u8 first_search = 0x00, touch_neg_max = 0x00;
-       char idx0 = 0, idx1 = 0;
+       s8 idx0 = 0, idx1 = 0;
        u8 gop;
        u8 bbp = 0;
-       char bidx;
+       s8 bidx;
 
        for (bidx = 5; bidx >= 1; bidx--) {
                for (gop = 0; gop < 2; gop++) {
        return 0;
 }
 
-static char rt2800_lp_tx_filter_bw_cal(struct rt2x00_dev *rt2x00dev)
+static s8 rt2800_lp_tx_filter_bw_cal(struct rt2x00_dev *rt2x00dev)
 {
        unsigned int cnt;
        u8 bbp_val;
-       char cal_val;
+       s8 cal_val;
 
        rt2800_bbp_dcoc_write(rt2x00dev, 0, 0x82);
 
        u8 rx_filter_target_20m = 0x27, rx_filter_target_40m = 0x31;
        int loop = 0, is_ht40, cnt;
        u8 bbp_val, rf_val;
-       char cal_r32_init, cal_r32_val, cal_diff;
+       s8 cal_r32_init, cal_r32_val, cal_diff;
        u8 saverfb5r00, saverfb5r01, saverfb5r03, saverfb5r04, saverfb5r05;
        u8 saverfb5r06, saverfb5r07;
        u8 saverfb5r08, saverfb5r17, saverfb5r18, saverfb5r19, saverfb5r20;
 {
        struct hw_mode_spec *spec = &rt2x00dev->spec;
        struct channel_info *info;
-       char *default_power1;
-       char *default_power2;
-       char *default_power3;
+       s8 *default_power1;
+       s8 *default_power2;
+       s8 *default_power3;
        unsigned int i, tx_chains, rx_chains;
        u32 reg;