add wifi6 8852be driver

hc

2024-12-19 9370bb92b2d16684ee45cf24e879c93c509162da

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
163
164
165
166
167
168
/*
 * Copyright (C) 2004 PathScale, Inc
 * Copyright (C) 2004 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 * Licensed under the GPL
 */
 
#include <errno.h>
#include <stdlib.h>
#include <sys/ptrace.h>
#ifdef __i386__
#include <sys/user.h>
#endif
#include <longjmp.h>
#include <sysdep/ptrace_user.h>
#include <sys/uio.h>
#include <asm/sigcontext.h>
#include <linux/elf.h>
 
int have_xstate_support;
 
int save_i387_registers(int pid, unsigned long *fp_regs)
{
    if (ptrace(PTRACE_GETFPREGS, pid, 0, fp_regs) < 0)
        return -errno;
    return 0;
}
 
int save_fp_registers(int pid, unsigned long *fp_regs)
{
#ifdef PTRACE_GETREGSET
    struct iovec iov;
 
    if (have_xstate_support) {
        iov.iov_base = fp_regs;
        iov.iov_len = FP_SIZE * sizeof(unsigned long);
        if (ptrace(PTRACE_GETREGSET, pid, NT_X86_XSTATE, &iov) < 0)
            return -errno;
        return 0;
    } else
#endif
        return save_i387_registers(pid, fp_regs);
}
 
int restore_i387_registers(int pid, unsigned long *fp_regs)
{
    if (ptrace(PTRACE_SETFPREGS, pid, 0, fp_regs) < 0)
        return -errno;
    return 0;
}
 
int restore_fp_registers(int pid, unsigned long *fp_regs)
{
#ifdef PTRACE_SETREGSET
    struct iovec iov;
    if (have_xstate_support) {
        iov.iov_base = fp_regs;
        iov.iov_len = FP_SIZE * sizeof(unsigned long);
        if (ptrace(PTRACE_SETREGSET, pid, NT_X86_XSTATE, &iov) < 0)
            return -errno;
        return 0;
    } else
#endif
        return restore_i387_registers(pid, fp_regs);
}
 
#ifdef __i386__
int have_fpx_regs = 1;
int save_fpx_registers(int pid, unsigned long *fp_regs)
{
    if (ptrace(PTRACE_GETFPXREGS, pid, 0, fp_regs) < 0)
        return -errno;
    return 0;
}
 
int restore_fpx_registers(int pid, unsigned long *fp_regs)
{
    if (ptrace(PTRACE_SETFPXREGS, pid, 0, fp_regs) < 0)
        return -errno;
    return 0;
}
 
int get_fp_registers(int pid, unsigned long *regs)
{
    if (have_fpx_regs)
        return save_fpx_registers(pid, regs);
    else
        return save_fp_registers(pid, regs);
}
 
int put_fp_registers(int pid, unsigned long *regs)
{
    if (have_fpx_regs)
        return restore_fpx_registers(pid, regs);
    else
        return restore_fp_registers(pid, regs);
}
 
void arch_init_registers(int pid)
{
    struct user_fpxregs_struct fpx_regs;
    int err;
 
    err = ptrace(PTRACE_GETFPXREGS, pid, 0, &fpx_regs);
    if (!err)
        return;
 
    if (errno != EIO)
        panic("check_ptrace : PTRACE_GETFPXREGS failed, errno = %d",
              errno);
 
    have_fpx_regs = 0;
}
#else
 
int get_fp_registers(int pid, unsigned long *regs)
{
    return save_fp_registers(pid, regs);
}
 
int put_fp_registers(int pid, unsigned long *regs)
{
    return restore_fp_registers(pid, regs);
}
 
void arch_init_registers(int pid)
{
#ifdef PTRACE_GETREGSET
    void * fp_regs;
    struct iovec iov;
 
    fp_regs = malloc(FP_SIZE * sizeof(unsigned long));
    if(fp_regs == NULL)
        return;
 
    iov.iov_base = fp_regs;
    iov.iov_len = FP_SIZE * sizeof(unsigned long);
    if (ptrace(PTRACE_GETREGSET, pid, NT_X86_XSTATE, &iov) == 0)
        have_xstate_support = 1;
 
    free(fp_regs);
#endif
}
#endif
 
unsigned long get_thread_reg(int reg, jmp_buf *buf)
{
    switch (reg) {
#ifdef __i386__
    case HOST_IP:
        return buf[0]->__eip;
    case HOST_SP:
        return buf[0]->__esp;
    case HOST_BP:
        return buf[0]->__ebp;
#else
    case HOST_IP:
        return buf[0]->__rip;
    case HOST_SP:
        return buf[0]->__rsp;
    case HOST_BP:
        return buf[0]->__rbp;
#endif
    default:
        printk(UM_KERN_ERR "get_thread_regs - unknown register %d\n",
               reg);
        return 0;
    }
}