跳转至

第六章：芯片实现详解

深入解析 WiFi 芯片的硬件实现：射频前端、基带处理器、MAC 处理器的架构设计与 Verilog 代码实现

6.1 WiFi SoC 总体架构

6.1.1 典型 WiFi SoC 框图

 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
┌─────────────────────────────────────────────────────────┐
│                    WiFi SoC 芯片                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌─────────────────────────────────────────────────┐   │
│  │                    射频前端 (RF)                 │   │
│  │  ┌───────┐  ┌───────┐  ┌───────┐  ┌───────┐   │   │
│  │  │  PA   │  │  LNA  │  │  Mixer│  │  PLL  │   │   │
│  │  │功率放大│  │低噪放大│  │ 混频器 │  │锁相环 │   │   │
│  │  └───────┘  └───────┘  └───────┘  └───────┘   │   │
│  │                                                  │   │
│  │  支持频段：2.4 GHz / 5 GHz / 6 GHz (WiFi 6E/7)  │   │
│  │  支持带宽：20/40/80/160/320 MHz                  │   │
│  └─────────────────────────────────────────────────┘   │
│                              │                          │
│                              ▼                          │
│  ┌─────────────────────────────────────────────────┐   │
│  │                  模拟基带 (Analog BB)            │   │
│  │  ┌───────┐  ┌───────┐  ┌───────┐  ┌───────┐   │   │
│  │  │  DAC  │  │  ADC  │  │  LPF  │  │  VGA  │   │   │
│  │  │数模转换│  │模数转换│  │低通滤波│  │可变增益│   │   │
│  │  └───────┘  └───────┘  └───────┘  └───────┘   │   │
│  │                                                  │   │
│  │  DAC/ADC 分辨率：10-14 bit                        │   │
│  │  采样率：80-320 Msps (取决于带宽)                 │   │
│  └─────────────────────────────────────────────────┘   │
│                              │                          │
│                              ▼                          │
│  ┌─────────────────────────────────────────────────┐   │
│  │                  数字基带 (Digital BB)           │   │
│  │  ┌───────┐  ┌───────┐  ┌───────┐  ┌───────┐   │   │
│  │  │ OFDM  │  │  FEC  │  │ MIMO  │  │  EQ   │   │   │
│  │  │调制解调│  │编解码  │  │预编码 │  │ 均衡器 │   │   │
│  │  └───────┘  └───────┘  └───────┘  └───────┘   │   │
│  │  ┌───────┐  ┌───────┐  ┌───────┐  ┌───────┐   │   │
│  │  │Scrambler│Interleaver│Channel │  FFT/ │   │   │
│  │  │ 扰码器  │  交织器  │  估计   │  IFFT │   │   │
│  │  └───────┘  └───────┘  └───────┘  └───────┘   │   │
│  └─────────────────────────────────────────────────┘   │
│                              │                          │
│                              ▼                          │
│  ┌─────────────────────────────────────────────────┐   │
│  │                    MAC 处理器                    │   │
│  │  ┌─────────────────────────────────────────┐   │   │
│  │  │         ARM Cortex-M / RISC-V           │   │   │
│  │  │         (运行 MAC 协议栈)                  │   │   │
│  │  └─────────────────────────────────────────┘   │   │
│  │  ┌───────┐  ┌───────┐  ┌───────┐  ┌───────┐   │   │
│  │  │ 加密  │  │ 帧构建 │  │ CSMA/ │  │  DMA  │   │   │
│  │  │ 引擎  │  │ 解析器 │  │  CA   │  │控制器 │   │   │
│  │  └───────┘  └───────┘  └───────┘  └───────┘   │   │
│  └─────────────────────────────────────────────────┘   │
│                              │                          │
│                              ▼                          │
│  ┌─────────────────────────────────────────────────┐   │
│  │                    主机接口 (HCI)                │   │
│  │     PCIe / USB / SDIO / SPI                     │   │
│  └─────────────────────────────────────────────────┘   │
│                                                         │
│  ┌─────────────────────────────────────────────────┐   │
│  │                    电源管理 (PMU)                │   │
│  │     LDO / DC-DC / 睡眠控制                       │   │
│  └─────────────────────────────────────────────────┘   │
│                                                         │
└─────────────────────────────────────────────────────────┘

6.1.2 芯片工艺与集成度

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
┌─────────────────────────────────────────────────────────┐
│              现代 WiFi SoC 集成度                         │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  工艺节点：                                             │
│  ├─ 28 nm CMOS (主流)                                  │
│  ├─ 22 nm CMOS (高端)                                  │
│  └─ 16/12 nm (WiFi 7 旗舰)                              │
│                                                         │
│  集成度：                                               │
│  ├─ 单芯片集成 RF + BB + MAC                           │
│  ├─ 多核处理器 (应用核 + 网络核)                        │
│  ├─ 大容量片上 SRAM                                    │
│  └─ 硬件加密引擎                                       │
│                                                         │
│  典型芯片 (以 MediaTek Filogic 880 为例):                │
│  ├─ 工艺：12 nm                                        │
│  ├─ 处理器：三核 Cortex-A53 + NPU                      │
│  ├─ WiFi: 802.11be (WiFi 7), 4×4 MIMO                  │
│  ├─ 蓝牙：Bluetooth 5.3                                │
│  └─ 封装：14×14 mm BGA                                 │
│                                                         │
└─────────────────────────────────────────────────────────┘

6.2 射频前端设计

6.2.1 发射链路

 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
// WiFi 发射机顶层模块
module wifi_transmitter (
    input wire clk,              // 系统时钟 (40/80 MHz)
    input wire reset_n,          // 复位
    input wire [11:0] tx_data_i, // 基带 I 路输入
    input wire [11:0] tx_data_q, // 基带 Q 路输入
    input wire tx_enable,        // 发送使能
    input wire [15:0] freq_ctrl, // 频率控制字
    input wire [2:0] tx_gain,    // 发射增益控制
    output wire rf_enable,       // RF 使能
    output wire pa_enable,       // 功率放大器使能
    output wire [5:0] pa_bias    // PA 偏置控制
);

// 1. 数字上变频
wire [15:0] upconv_i, upconv_q;
digital_up_converter u_duc (
    .clk(clk),
    .reset_n(reset_n),
    .baseband_i(tx_data_i),
    .baseband_q(tx_data_q),
    .rf_i(upconv_i),
    .rf_q(upconv_q),
    .freq_ctrl(freq_ctrl),
    .enable(tx_enable)
);

// 2. DAC 接口
wire [11:0] dac_i, dac_q;
wire dac_clk;
dac_interface u_dac (
    .clk(clk),
    .reset_n(reset_n),
    .data_i(upconv_i),
    .data_q(upconv_q),
    .dac_i(dac_i),
    .dac_q(dac_q),
    .dac_clk(dac_clk),
    .enable(tx_enable)
);

// 3. 频率合成器控制
wire pll_locked;
pll_controller u_pll (
    .clk(clk),
    .reset_n(reset_n),
    .freq_ctrl(freq_ctrl),
    .pll_enable(rf_enable),
    .locked(pll_locked)
);

// 4. PA 控制 (带 ramp-up/ramp-down)
pa_controller u_pa (
    .clk(clk),
    .reset_n(reset_n),
    .tx_enable(tx_enable & pll_locked),
    .tx_gain(tx_gain),
    .pa_enable(pa_enable),
    .pa_bias(pa_bias)
);

assign rf_enable = tx_enable & pll_locked;

endmodule

6.2.2 接收链路

 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
// WiFi 接收机顶层模块
module wifi_receiver (
    input wire clk,
    input wire reset_n,
    input wire [11:0] adc_i,     // ADC I 路输入
    input wire [11:0] adc_q,     // ADC Q 路输入
    input wire rx_enable,        // 接收使能
    input wire [15:0] freq_ctrl, // 频率控制字
    output wire [11:0] rx_data_i,// 基带 I 路输出
    output wire [11:0] rx_data_q,// 基带 Q 路输出
    output wire rx_valid,        // 数据有效
    output wire [7:0] rssi_out,  // RSSI 输出
    output wire carrier_sense    // 载波检测
);

// 1. 数字下变频
wire [15:0] baseband_i, baseband_q;
digital_down_converter u_ddc (
    .clk(clk),
    .reset_n(reset_n),
    .adc_i(adc_i),
    .adc_q(adc_q),
    .baseband_i(baseband_i),
    .baseband_q(baseband_q),
    .freq_ctrl(freq_ctrl),
    .enable(rx_enable)
);

// 2. 低通滤波器
wire [11:0] filtered_i, filtered_q;
low_pass_filter u_lpf (
    .clk(clk),
    .reset_n(reset_n),
    .i_in(baseband_i),
    .q_in(baseband_q),
    .i_out(filtered_i),
    .q_out(filtered_q),
    .enable(rx_enable)
);

// 3. 自动增益控制 (AGC)
wire [11:0] agc_i, agc_q;
wire [7:0] agc_gain;
agc_controller u_agc (
    .clk(clk),
    .reset_n(reset_n),
    .i_in(filtered_i),
    .q_in(filtered_q),
    .i_out(agc_i),
    .q_out(agc_q),
    .gain(agc_gain),
    .enable(rx_enable)
);

// 4. RSSI 计算
rssicalculator u_rssi (
    .clk(clk),
    .reset_n(reset_n),
    .i_in(agc_i),
    .q_in(agc_q),
    .rssi(rssi_out),
    .enable(rx_enable)
);

// 5. 载波检测
carrier_detector u_cd (
    .clk(clk),
    .reset_n(reset_n),
    .rssi(rssi_out),
    .carrier_sense(carrier_sense),
    .enable(rx_enable)
);

assign rx_data_i = agc_i;
assign rx_data_q = agc_q;
assign rx_valid = rx_enable & carrier_sense;

endmodule

6.2.3 频率合成器 (PLL)

 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
// 小数分频 PLL 控制器
module wifi_pll_controller (
    input wire clk,           // 参考时钟 (40 MHz)
    input wire reset_n,
    input wire [15:0] freq_ctrl,  // 频率控制字
    output wire pll_enable,       // PLL 使能
    output wire pll_locked,       // 锁定指示
    output reg [23:0] div_ratio,  // 分频比输出
    input wire lock_detected      // 锁定检测输入
);

// WiFi 频率映射
// freq_ctrl = 0 → 2412 MHz (信道 1)
// freq_ctrl = 13 → 2472 MHz (信道 13)
// freq_ctrl = 36 → 5180 MHz (信道 36)
// ...

localparam REAL F_REF = 40.0;  // 40 MHz 参考

reg [15:0] channel_num;
reg [23:0] integer_part;
reg [19:0] fractional_part;

// 频率计算
always @(*) begin
    case (freq_ctrl[15:14])
        2'b00: begin  // 2.4 GHz
            integer_part = 24'd60 + (freq_ctrl[13:0] * 24'd1);  // 60 = 2400/40
        end
        2'b01: begin  // 5 GHz
            integer_part = 24'd129 + (freq_ctrl[13:0] * 24'd1); // 129 = 5160/40
        end
        2'b10: begin  // 6 GHz
            integer_part = 24'd148 + (freq_ctrl[13:0] * 24'd1); // 148 = 5920/40
        end
        default: begin
            integer_part = 24'd60;
        end
    endcase
    fractional_part = 20'd0;  // 简化，实际需要精确计算
    div_ratio = {integer_part, fractional_part};
end

// 锁定检测同步
reg [2:0] lock_sync;
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        lock_sync <= 3'b000;
    end else begin
        lock_sync <= {lock_sync[1:0], lock_detected};
    end
end

assign pll_locked = &lock_sync;  // 连续 3 次检测到锁定
assign pll_enable = 1'b1;  // 常开

endmodule

6.3 基带处理器

6.3.1 FFT/IFFT 引擎

 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
// 64 点 FFT/IFFT 引擎 (基 4 算法)
module fft_64_engine (
    input wire clk,
    input wire reset_n,
    input wire [11:0] data_in_real,
    input wire [11:0] data_in_imag,
    input wire [5:0] addr_in,
    output wire [11:0] data_out_real,
    output wire [11:0] data_out_imag,
    input wire fft_start,
    input wire fft_dir,  // 0=FFT, 1=IFFT
    output wire fft_done
);

// 6 级基 4 蝶形运算
// 每级 16 个蝶形单元

// 旋转因子查找表
reg [11:0] twiddle_real [0:63];
reg [11:0] twiddle_imag [0:63];

// 蝶形运算单元
wire [11:0] butterfly_out_real [0:63];
wire [11:0] butterfly_out_imag [0:63];

// 流水线寄存器
reg [11:0] pipeline_real [5:0][0:63];
reg [11:0] pipeline_imag [5:0][0:63];

// 基 4 蝶形运算
// X0' = X0 + X1 + X2 + X3
// X1' = X0 - jX1 - X2 + jX3
// X2' = X0 - X1 + X2 - X3
// X3' = X0 + jX1 - X2 - jX3

// 详细实现需要大量逻辑，此处为框架
// 实际实现需要：
// 1. 6 级流水线
// 2. 每级 16 个基 4 蝶形单元
// 3. 旋转因子乘法
// 4. 定点数饱和处理

assign fft_done = /* 流水线延迟后 */;

endmodule

// 256 点 FFT (WiFi 6 20/40 MHz)
module fft_256_engine (
    input wire clk,
    input wire reset_n,
    // ... 类似 64 点 FFT，但规模更大
);

// 512/1024/2048 点 FFT (WiFi 6 80/160/320 MHz)
// 使用多级延迟反馈 (MDF) 架构节省资源

endmodule

6.3.2 MIMO 预编码器

 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
// MIMO 预编码器 (SVD 波束赋形)
module mimo_precoder (
    input wire clk,
    input wire reset_n,
    input wire [11:0] data_in [0:3],   // 4 空间流输入
    input wire [11:0] channel_matrix [0:15], // 4×4 信道矩阵
    output wire [11:0] data_out [0:3], // 4 天线输出
    input wire enable,
    input wire [1:0] num_streams       // 空间流数量
);

// SVD 分解：H = U × Σ × V^H
// 预编码矩阵：W = V

// 1. 信道矩阵奇异值分解
wire [11:0] U_matrix [0:15];
wire [11:0] Sigma_matrix [0:3];
wire [11:0] V_matrix [0:15];

svd_decomposer u_svd (
    .clk(clk),
    .reset_n(reset_n),
    .channel(channel_matrix),
    .U(U_matrix),
    .Sigma(Sigma_matrix),
    .V(V_matrix),
    .enable(enable)
);

// 2. 预编码矩阵乘法：y = V × x
wire [23:0] mult_result [0:3];
genvar i, j;
generate
    for (i = 0; i < 4; i = i + 1) begin
        assign mult_result[i] = 0;
        for (j = 0; j < 4; j = j + 1) begin
            if (j < num_streams) begin
                assign mult_result[i] = mult_result[i] + 
                    $signed(V_matrix[i*4+j]) * $signed(data_in[j]);
            end
        end
    end
endgenerate

// 3. 输出截断
always @(posedge clk) begin
    if (enable) begin
        data_out[0] <= mult_result[0][23:12];
        data_out[1] <= mult_result[1][23:12];
        data_out[2] <= mult_result[2][23:12];
        data_out[3] <= mult_result[3][23:12];
    end
end

endmodule

6.4 MAC 处理器

6.4.1 帧构建引擎

  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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
// MAC 帧构建器
module mac_frame_builder (
    input wire clk,
    input wire reset_n,

    // 输入数据
    input wire [7:0] payload_in,
    input wire payload_valid,
    input wire payload_last,

    // 帧参数
    input wire [1:0] frame_type,     // 00=管理，01=控制，10=数据
    input wire [3:0] subtype,        // 子类型
    input wire [47:0] addr1,         // 目的地址
    input wire [47:0] addr2,         // 源地址
    input wire [47:0] addr3,         // BSSID
    input wire [15:0] duration,      // 持续时间
    input wire [15:0] seq_ctrl,      // 序列控制

    // 输出
    output wire [7:0] frame_out,
    output wire frame_valid,
    output wire frame_last,

    // 控制
    input wire start,
    output wire busy,
    output wire done
);

// 状态机
localparam STATE_IDLE = 3'd0;
localparam STATE_FC = 3'd1;      // Frame Control
localparam STATE_DURATION = 3'd2;
localparam STATE_ADDR1 = 3'd3;
localparam STATE_ADDR2 = 3'd4;
localparam STATE_ADDR3 = 3'd5;
localparam STATE_SEQ = 3'd6;
localparam STATE_PAYLOAD = 3'd7;
localparam STATE_FCS = 3'd8;
localparam STATE_DONE = 3'd9;

reg [3:0] state;
reg [2:0] byte_count;
reg [31:0] fcs_calc;

// Frame Control 字段
wire [15:0] frame_control;
assign frame_control = {
    2'b00,           // Protocol Version
    frame_type,      // Type
    subtype,         // Subtype
    2'b00,           // To DS, From DS
    1'b0,            // More Fragments
    1'b0,            // Retry
    1'b0,            // Power Management
    1'b0,            // More Data
    1'b0,            // Protected Frame
    1'b0             // Order
};

// FCS 计算 (CRC-32)
crc32_calculator u_crc (
    .clk(clk),
    .reset_n(reset_n),
    .data_in(frame_out),
    .crc_out(fcs_calc),
    .enable(frame_valid),
    .calc_start(start),
    .calc_done(fcs_done)
);

// 主状态机
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        state <= STATE_IDLE;
        byte_count <= 3'd0;
        frame_out <= 8'd0;
        frame_valid <= 1'b0;
        frame_last <= 1'b0;
        busy <= 1'b0;
        done <= 1'b0;
    end else begin
        case (state)
            STATE_IDLE: begin
                if (start) begin
                    state <= STATE_FC;
                    byte_count <= 3'd0;
                    busy <= 1'b1;
                    done <= 1'b0;
                end
            end

            STATE_FC: begin
                frame_out <= frame_control[7:0];
                frame_valid <= 1'b1;
                if (byte_count == 3'd1) begin
                    state <= STATE_DURATION;
                    byte_count <= 3'd0;
                end else begin
                    byte_count <= byte_count + 1'b1;
                end
            end

            STATE_DURATION: begin
                // 输出 Duration 字段 (2 bytes)
                frame_out <= (byte_count == 3'd0) ? duration[7:0] : duration[15:8];
                if (byte_count == 3'd1) begin
                    state <= STATE_ADDR1;
                    byte_count <= 3'd0;
                end else begin
                    byte_count <= byte_count + 1'b1;
                end
            end

            STATE_ADDR1: begin
                // 输出 Address 1 (6 bytes)
                frame_out <= addr1[byte_count*8 +: 8];
                if (byte_count == 3'd5) begin
                    state <= STATE_ADDR2;
                    byte_count <= 3'd0;
                end else begin
                    byte_count <= byte_count + 1'b1;
                end
            end

            // ... 类似处理 Address 2, 3, Sequence Control

            STATE_PAYLOAD: begin
                frame_out <= payload_in;
                frame_valid <= payload_valid;
                if (payload_last) begin
                    state <= STATE_FCS;
                    byte_count <= 3'd0;
                end
            end

            STATE_FCS: begin
                // 输出 FCS (4 bytes, 小端)
                frame_out <= fcs_calc[byte_count*8 +: 8];
                frame_valid <= 1'b1;
                if (byte_count == 3'd3) begin
                    state <= STATE_DONE;
                    frame_last <= 1'b1;
                end else begin
                    byte_count <= byte_count + 1'b1;
                end
            end

            STATE_DONE: begin
                done <= 1'b1;
                busy <= 1'b0;
                state <= STATE_IDLE;
                frame_last <= 1'b0;
            end
        endcase
    end
end

endmodule

6.4.2 CSMA/CA 状态机

  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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
// CSMA/CA 控制器
module csma_ca_controller (
    input wire clk,
    input wire reset_n,

    // 物理层接口
    input wire carrier_sense,    // 载波检测
    input wire rx_valid,         // 接收有效

    // MAC 层接口
    input wire tx_request,       // 发送请求
    output wire tx_enable,       // 发送使能
    input wire tx_done,          // 发送完成
    input wire ack_received,     // 收到 ACK

    // 参数
    input wire [4:0] aifsn,      // 仲裁帧间间隔
    input wire [9:0] cw_min,     // 最小竞争窗口
    input wire [9:0] cw_max,     // 最大竞争窗口

    // 状态输出
    output reg [9:0] backoff_counter,
    output reg channel_busy,
    output reg tx_retry
);

// 状态机
localparam STATE_IDLE = 3'd0;
localparam STATE_DIFS = 3'd1;
localparam STATE_BACKOFF = 3'd2;
localparam STATE_TX = 3'd3;
localparam STATE_WAIT_ACK = 3'd4;
localparam STATE_RETRY = 3'd5;

reg [2:0] state;
reg [9:0] cw_current;  // 当前竞争窗口
reg [3:0] retry_count;
reg [9:0] slot_counter;

// 时隙计数器 (9 μs for 802.11a/n/ac)
localparam SLOT_TIME = 10;  // 假设 100 MHz 时钟，9 μs = 1000 周期

// 随机数生成器
wire [9:0] random_num;
trng_simple u_trng (
    .clk(clk),
    .reset_n(reset_n),
    .random(random_num),
    .enable(tx_request)
);

// 主状态机
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        state <= STATE_IDLE;
        cw_current <= cw_min;
        retry_count <= 4'd0;
        backoff_counter <= 10'd0;
        tx_enable <= 1'b0;
        channel_busy <= 1'b0;
        tx_retry <= 1'b0;
    end else begin
        case (state)
            STATE_IDLE: begin
                tx_enable <= 1'b0;
                tx_retry <= 1'b0;
                if (tx_request && !carrier_sense) begin
                    state <= STATE_DIFS;
                    slot_counter <= 10'd0;
                    channel_busy <= 1'b0;
                end else if (carrier_sense) begin
                    channel_busy <= 1'b1;
                end
            end

            STATE_DIFS: begin
                // 等待 DIFS/AIFS 时间
                if (carrier_sense) begin
                    slot_counter <= 10'd0;  // 重新计数
                end else if (slot_counter >= AIFS * SLOT_TIME) begin
                    // DIFS 结束，开始退避
                    backoff_counter <= random_num % cw_current;
                    state <= STATE_BACKOFF;
                    slot_counter <= 10'd0;
                end else begin
                    slot_counter <= slot_counter + 1'b1;
                end
            end

            STATE_BACKOFF: begin
                if (carrier_sense) begin
                    // 信道忙，暂停退避
                    channel_busy <= 1'b1;
                end else begin
                    channel_busy <= 1'b0;
                    if (slot_counter >= SLOT_TIME) begin
                        // 空闲时隙，退避计数器减 1
                        slot_counter <= 10'd0;
                        if (backoff_counter > 10'd0) begin
                            backoff_counter <= backoff_counter - 1'b1;
                        end else begin
                            // 退避结束，开始发送
                            state <= STATE_TX;
                            tx_enable <= 1'b1;
                        end
                    end else begin
                        slot_counter <= slot_counter + 1'b1;
                    end
                end
            end

            STATE_TX: begin
                tx_enable <= 1'b1;
                if (tx_done) begin
                    tx_enable <= 1'b0;
                    state <= STATE_WAIT_ACK;
                    slot_counter <= 10'd0;
                end
            end

            STATE_WAIT_ACK: begin
                // 等待 ACK (SIFS + ACK 时间)
                if (ack_received) begin
                    // 发送成功
                    state <= STATE_IDLE;
                    cw_current <= cw_min;  // 重置 CW
                    retry_count <= 4'd0;
                end else if (slot_counter >= ACK_TIMEOUT) begin
                    // ACK 超时
                    state <= STATE_RETRY;
                end else begin
                    slot_counter <= slot_counter + 1'b1;
                end
            end

            STATE_RETRY: begin
                if (retry_count < MAX_RETRY) begin
                    // 重传
                    retry_count <= retry_count + 1'b1;
                    cw_current <= cw_current * 2;  // 加倍 CW
                    if (cw_current > cw_max) begin
                        cw_current <= cw_max;
                    end
                    tx_retry <= 1'b1;
                    state <= STATE_DIFS;
                    slot_counter <= 10'd0;
                end else begin
                    // 达到最大重试次数，放弃
                    state <= STATE_IDLE;
                    cw_current <= cw_min;
                    retry_count <= 4'd0;
                end
            end
        endcase
    end
end

localparam AIFS = 2;  // 默认 AIFSN
localparam ACK_TIMEOUT = 1000;  // ACK 超时 (时隙数)
localparam MAX_RETRY = 7;  // 最大重试次数

endmodule

6.5 低功耗设计

6.5.1 时钟门控

 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
// 时钟门控单元
module clock_gating_cell (
    input wire clk_in,
    input wire enable,
    output wire clk_out
);

reg enable_reg;

// 负边沿触发，避免毛刺
always @(negedge clk_in or negedge enable) begin
    if (!enable)
        enable_reg <= 1'b0;
    else
        enable_reg <= 1'b1;
end

assign clk_out = clk_in & enable_reg;

endmodule

// 模块级时钟门控
module wifi_with_clock_gating (
    input wire clk,
    input wire reset_n,
    input wire [1:0] power_mode,  // 00=Active, 01=Doze, 10=Deep Sleep
    // ... 其他端口
);

wire clk_rf, clk_bb, clk_mac;

// 根据功耗模式门控时钟
assign clk_rf = (power_mode == 2'b00) ? clk : 1'b0;   // 仅 Active 开启 RF
assign clk_bb = (power_mode != 2'b11) ? clk : 1'b0;   // Deep Sleep 关闭基带
assign clk_mac = (power_mode == 2'b00) ? clk : 1'b0;  // 仅 Active 开启 MAC

// 实例化带时钟门控的模块
rf_front_end u_rf (
    .clk(clk_rf),
    // ...
);

baseband_processor u_bb (
    .clk(clk_bb),
    // ...
);

mac_processor u_mac (
    .clk(clk_mac),
    // ...
);

endmodule

6.5.2 电源门控

 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
// 电源域控制器
module power_domain_controller (
    input wire clk,
    input wire reset_n,
    input wire [1:0] sleep_mode,
    output wire pwr_rf,      // RF 电源使能
    output wire pwr_bb,      // 基带电源使能
    output wire pwr_pll,     // PLL 电源使能
    output wire pwr_mac,     // MAC 电源使能
    output wire pwr_io       // IO 电源使能
);

// 电源模式定义
localparam ACTIVE = 2'b00;
localparam DOZE = 2'b01;
localparam DEEP_SLEEP = 2'b10;
localparam OFF = 2'b11;

always @(*) begin
    case (sleep_mode)
        ACTIVE: begin
            pwr_rf = 1'b1;
            pwr_bb = 1'b1;
            pwr_pll = 1'b1;
            pwr_mac = 1'b1;
            pwr_io = 1'b1;
        end
        DOZE: begin
            pwr_rf = 1'b0;  // 关闭 RF
            pwr_bb = 1'b0;  // 关闭基带
            pwr_pll = 1'b0; // 关闭 PLL
            pwr_mac = 1'b1; // 保持 MAC (监听 Beacon)
            pwr_io = 1'b1;
        end
        DEEP_SLEEP: begin
            pwr_rf = 1'b0;
            pwr_bb = 1'b0;
            pwr_pll = 1'b0;
            pwr_mac = 1'b0;  // 仅保留唤醒逻辑
            pwr_io = 1'b0;
        end
        OFF: begin
            pwr_rf = 1'b0;
            pwr_bb = 1'b0;
            pwr_pll = 1'b0;
            pwr_mac = 1'b0;
            pwr_io = 1'b0;
        end
    endcase
end

endmodule

6.6 本章小结

本章深入讲解了 WiFi 芯片的硬件实现：

  1. SoC 架构：RF、模拟基带、数字基带、MAC 处理器、接口
  2. 射频前端：发射/接收链路、频率合成器
  3. 基带处理器：FFT/IFFT、MIMO 预编码、均衡器
  4. MAC 处理器：帧构建、CSMA/CA 状态机
  5. 低功耗设计：时钟门控、电源门控、功耗模式

下一章将详细讲解安全加密机制。

上一章：05-MAC 层架构
下一章：07-安全加密机制