hc
2024-08-16 62c46c9150c4afde7e5b25436263fddf79d66f0b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
// SPDX-License-Identifier: ISC
/*
 * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
 * Copyright (C) 2018 Lorenzo Bianconi <lorenzo.bianconi83@gmail.com>
 */
 
#include <linux/kernel.h>
#include <linux/firmware.h>
#include <linux/delay.h>
 
#include "mt76x2.h"
#include "mcu.h"
#include "eeprom.h"
 
int mt76x2_mcu_set_channel(struct mt76x02_dev *dev, u8 channel, u8 bw,
              u8 bw_index, bool scan)
{
   struct {
       u8 idx;
       u8 scan;
       u8 bw;
       u8 _pad0;
 
       __le16 chainmask;
       u8 ext_chan;
       u8 _pad1;
 
   } __packed __aligned(4) msg = {
       .idx = channel,
       .scan = scan,
       .bw = bw,
       .chainmask = cpu_to_le16(dev->chainmask),
   };
 
   /* first set the channel without the extension channel info */
   mt76_mcu_send_msg(dev, CMD_SWITCH_CHANNEL_OP, &msg, sizeof(msg), true);
 
   usleep_range(5000, 10000);
 
   msg.ext_chan = 0xe0 + bw_index;
   return mt76_mcu_send_msg(dev, CMD_SWITCH_CHANNEL_OP, &msg, sizeof(msg),
                true);
}
EXPORT_SYMBOL_GPL(mt76x2_mcu_set_channel);
 
int mt76x2_mcu_load_cr(struct mt76x02_dev *dev, u8 type, u8 temp_level,
              u8 channel)
{
   struct {
       u8 cr_mode;
       u8 temp;
       u8 ch;
       u8 _pad0;
 
       __le32 cfg;
   } __packed __aligned(4) msg = {
       .cr_mode = type,
       .temp = temp_level,
       .ch = channel,
   };
   u32 val;
 
   val = BIT(31);
   val |= (mt76x02_eeprom_get(dev, MT_EE_NIC_CONF_0) >> 8) & 0x00ff;
   val |= (mt76x02_eeprom_get(dev, MT_EE_NIC_CONF_1) << 8) & 0xff00;
   msg.cfg = cpu_to_le32(val);
 
   /* first set the channel without the extension channel info */
   return mt76_mcu_send_msg(dev, CMD_LOAD_CR, &msg, sizeof(msg), true);
}
EXPORT_SYMBOL_GPL(mt76x2_mcu_load_cr);
 
int mt76x2_mcu_init_gain(struct mt76x02_dev *dev, u8 channel, u32 gain,
            bool force)
{
   struct {
       __le32 channel;
       __le32 gain_val;
   } __packed __aligned(4) msg = {
       .channel = cpu_to_le32(channel),
       .gain_val = cpu_to_le32(gain),
   };
 
   if (force)
       msg.channel |= cpu_to_le32(BIT(31));
 
   return mt76_mcu_send_msg(dev, CMD_INIT_GAIN_OP, &msg, sizeof(msg),
                true);
}
EXPORT_SYMBOL_GPL(mt76x2_mcu_init_gain);
 
int mt76x2_mcu_tssi_comp(struct mt76x02_dev *dev,
            struct mt76x2_tssi_comp *tssi_data)
{
   struct {
       __le32 id;
       struct mt76x2_tssi_comp data;
   } __packed __aligned(4) msg = {
       .id = cpu_to_le32(MCU_CAL_TSSI_COMP),
       .data = *tssi_data,
   };
 
   return mt76_mcu_send_msg(dev, CMD_CALIBRATION_OP, &msg, sizeof(msg),
                true);
}
EXPORT_SYMBOL_GPL(mt76x2_mcu_tssi_comp);