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
// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef EASYMEDIA_LOCK_H_
#define EASYMEDIA_LOCK_H_
 
#include <assert.h>
#include <pthread.h>
 
#include <atomic>
#include <condition_variable>
#include <mutex>
 
namespace easymedia
{
 
    class LockMutex
    {
      public:
        LockMutex();
        virtual ~LockMutex();
        virtual void lock() = 0;
        virtual void unlock() = 0;
        virtual void wait(){};
        virtual void notify(){};
        void locktimeinc();
        void locktimedec();
#ifndef NDEBUG
      protected:
        std::atomic_int lock_times;
#endif
    };
 
    class NonLockMutex : public LockMutex
    {
      public:
        virtual ~NonLockMutex() = default;
        virtual void lock()
        {
        }
        virtual void unlock()
        {
        }
    };
 
    class ConditionLockMutex : public LockMutex
    {
      public:
        virtual ~ConditionLockMutex() = default;
        virtual void lock() override;
        virtual void unlock() override;
        virtual void wait() override;
        virtual void notify() override;
 
      private:
        std::mutex mtx;
        std::condition_variable_any cond;
    };
 
    class ReadWriteLockMutex : public LockMutex
    {
      public:
        ReadWriteLockMutex();
        virtual ~ReadWriteLockMutex();
        virtual void lock() override;
        virtual void unlock() override;
        void read_lock();
 
        bool valid;
 
      private:
        // if c++17, std::shared_mutex
        pthread_rwlock_t rwlock;
    };
 
    class SpinLockMutex : public LockMutex
    {
      public:
        SpinLockMutex();
        virtual ~SpinLockMutex() = default;
        SpinLockMutex(const SpinLockMutex&) = delete;
        SpinLockMutex& operator=(const SpinLockMutex&) = delete;
        virtual void lock() override;
        virtual void unlock() override;
 
      private:
        std::atomic_flag flag;
    };
 
    class AutoLockMutex
    {
      public:
        AutoLockMutex(LockMutex& lm) : m_lm(lm)
        {
            m_lm.lock();
        }
        ~AutoLockMutex()
        {
            m_lm.unlock();
        }
 
      private:
        LockMutex& m_lm;
    };
 
} // namespace easymedia
 
#endif // #ifndef EASYMEDIA_LOCK_H_