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
|
/* ========================================
Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
======================================== */
/* ========================================
Revision History:
31/01/24: Add kDeviceCnt (amlel)
15/11/24: Add NE_DEVICE macro, to inherit from device object.
======================================== */
#ifndef KERNELKIT_DEVICEMGR_H
#define KERNELKIT_DEVICEMGR_H
/* @note Device Mgr. */
/* @file KernelKit/DeviceMgr.h */
/* @brief Device abstraction and I/O buffer. */
#include <NeKit/ErrorOr.h>
#include <NeKit/Ref.h>
#define kDeviceMgrRootDirPath "/devices/"
#define NE_DEVICE : public ::Kernel::IDevice
// Last Rev: Wed, May 27, 2025 6:22 PM
namespace Kernel {
template <typename T>
class IDevice;
template <typename T>
class IOBuf;
/***********************************************************************************/
/// @brief Device contract interface, represents an HW device.
/***********************************************************************************/
template <typename T>
class IDevice {
public:
IDevice() = default;
explicit IDevice(void (*Out)(IDevice<T>*, T), void (*In)(IDevice<T>*, T)) : fOut(Out), fIn(In) {}
virtual ~IDevice() = default;
public:
using Type = T;
using TypeRef = T&;
using ConstType = const T&;
using TypePtr = T*;
IDevice& operator=(const IDevice<T>&) = default;
IDevice(const IDevice<T>&) = default;
public:
virtual IDevice<T>& operator<<(T Data) {
fOut(this, Data);
return *this;
}
virtual IDevice<T>& operator>>(T Data) {
fIn(this, Data);
return *this;
}
virtual const char* Name() const { return "/devices/null"; }
operator bool() { return fOut && fIn; }
Bool operator!() { return !fOut || !fIn; }
protected:
Void (*fOut)(IDevice<T>*, T Data) = {nullptr};
Void (*fIn)(IDevice<T>*, T Data) = {nullptr};
};
///
/// @brief Input Output abstract class.
/// Used mainly to communicate between OS to hardware.
///
template <typename T>
class IOBuf final {
public:
explicit IOBuf(T dma_addr) : fData(dma_addr) {
// At least pass something valid when instancating this struct.
MUST_PASS(fData);
}
IOBuf& operator=(const IOBuf<T>&) = default;
IOBuf(const IOBuf<T>&) = default;
~IOBuf() = default;
public:
template <typename R>
R operator->() const {
return fData;
}
template <typename R>
R& operator[](Size index) const {
return fData[index];
}
private:
T fData;
};
///! @brief Device enum types.
enum {
kDeviceTypeInvalid = 0,
kDeviceTypeIDE = 100,
kDeviceTypeEthernet,
kDeviceTypeWiFi,
kDeviceTypeFW,
kDeviceTypeBT,
kDeviceTypeRS232,
kDeviceTypeSCSI,
kDeviceTypeAHCI,
kDeviceTypeMBCI,
kDeviceTypeATA,
kDeviceTypeUSB,
kDeviceTypeAPM, // Adv. Pwr. Mgmt.
kDeviceTypePCI,
kDeviceTypeVGA,
kDeviceTypeGPU,
kDeviceTypeCount,
};
} // namespace Kernel
#endif
|
