1 /*
2 * Copyright © 2014 Advanced Micro Devices, Inc.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sub license, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
15 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16 * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
17 * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20 * USE OR OTHER DEALINGS IN THE SOFTWARE.
21 *
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
24 * of the Software.
25 */
26
27 /**
28 ***************************************************************************************************
29 * @file addrobject.cpp
30 * @brief Contains the AddrObject base class implementation.
31 ***************************************************************************************************
32 */
33
34 #include "addrinterface.h"
35 #include "addrobject.h"
36
37 /**
38 ***************************************************************************************************
39 * AddrObject::AddrObject
40 *
41 * @brief
42 * Constructor for the AddrObject class.
43 ***************************************************************************************************
44 */
AddrObject()45 AddrObject::AddrObject()
46 {
47 m_client.handle = NULL;
48 m_client.callbacks.allocSysMem = NULL;
49 m_client.callbacks.freeSysMem = NULL;
50 m_client.callbacks.debugPrint = NULL;
51 }
52
53 /**
54 ***************************************************************************************************
55 * AddrObject::AddrObject
56 *
57 * @brief
58 * Constructor for the AddrObject class.
59 ***************************************************************************************************
60 */
AddrObject(const AddrClient * pClient)61 AddrObject::AddrObject(const AddrClient* pClient)
62 {
63 m_client = *pClient;
64 }
65
66 /**
67 ***************************************************************************************************
68 * AddrObject::~AddrObject
69 *
70 * @brief
71 * Destructor for the AddrObject class.
72 ***************************************************************************************************
73 */
~AddrObject()74 AddrObject::~AddrObject()
75 {
76 }
77
78 /**
79 ***************************************************************************************************
80 * AddrObject::ClientAlloc
81 *
82 * @brief
83 * Calls instanced allocSysMem inside AddrClient
84 ***************************************************************************************************
85 */
ClientAlloc(size_t objSize,const AddrClient * pClient)86 VOID* AddrObject::ClientAlloc(
87 size_t objSize, ///< [in] Size to allocate
88 const AddrClient* pClient) ///< [in] Client pointer
89 {
90 VOID* pObjMem = NULL;
91
92 if (pClient->callbacks.allocSysMem != NULL)
93 {
94 ADDR_ALLOCSYSMEM_INPUT allocInput = {0};
95
96 allocInput.size = sizeof(ADDR_ALLOCSYSMEM_INPUT);
97 allocInput.flags.value = 0;
98 allocInput.sizeInBytes = static_cast<UINT_32>(objSize);
99 allocInput.hClient = pClient->handle;
100
101 pObjMem = pClient->callbacks.allocSysMem(&allocInput);
102 }
103
104 return pObjMem;
105 }
106
107 /**
108 ***************************************************************************************************
109 * AddrObject::AddrMalloc
110 *
111 * @brief
112 * A wrapper of ClientAlloc
113 ***************************************************************************************************
114 */
AddrMalloc(size_t objSize) const115 VOID* AddrObject::AddrMalloc(
116 size_t objSize) const ///< [in] Size to allocate
117 {
118 return ClientAlloc(objSize, &m_client);
119 }
120
121 /**
122 ***************************************************************************************************
123 * AddrObject::ClientFree
124 *
125 * @brief
126 * Calls freeSysMem inside AddrClient
127 ***************************************************************************************************
128 */
ClientFree(VOID * pObjMem,const AddrClient * pClient)129 VOID AddrObject::ClientFree(
130 VOID* pObjMem, ///< [in] User virtual address to free.
131 const AddrClient* pClient) ///< [in] Client pointer
132 {
133 if (pClient->callbacks.freeSysMem != NULL)
134 {
135 if (pObjMem != NULL)
136 {
137 ADDR_FREESYSMEM_INPUT freeInput = {0};
138
139 freeInput.size = sizeof(ADDR_FREESYSMEM_INPUT);
140 freeInput.hClient = pClient->handle;
141 freeInput.pVirtAddr = pObjMem;
142
143 pClient->callbacks.freeSysMem(&freeInput);
144 }
145 }
146 }
147
148 /**
149 ***************************************************************************************************
150 * AddrObject::AddrFree
151 *
152 * @brief
153 * A wrapper of ClientFree
154 ***************************************************************************************************
155 */
AddrFree(VOID * pObjMem) const156 VOID AddrObject::AddrFree(
157 VOID* pObjMem) const ///< [in] User virtual address to free.
158 {
159 ClientFree(pObjMem, &m_client);
160 }
161
162 /**
163 ***************************************************************************************************
164 * AddrObject::operator new
165 *
166 * @brief
167 * Allocates memory needed for AddrObject object. (with ADDR_CLIENT_HANDLE)
168 *
169 * @return
170 * Returns NULL if unsuccessful.
171 ***************************************************************************************************
172 */
operator new(size_t objSize,const AddrClient * pClient)173 VOID* AddrObject::operator new(
174 size_t objSize, ///< [in] Size to allocate
175 const AddrClient* pClient) ///< [in] Client pointer
176 {
177 return ClientAlloc(objSize, pClient);
178 }
179
180
181 /**
182 ***************************************************************************************************
183 * AddrObject::operator delete
184 *
185 * @brief
186 * Frees AddrObject object memory.
187 ***************************************************************************************************
188 */
operator delete(VOID * pObjMem,const AddrClient * pClient)189 VOID AddrObject::operator delete(
190 VOID* pObjMem, ///< [in] User virtual address to free.
191 const AddrClient* pClient) ///< [in] Client handle
192 {
193 ClientFree(pObjMem, pClient);
194 }
195
196 /**
197 ***************************************************************************************************
198 * AddrObject::operator delete
199 *
200 * @brief
201 * Frees AddrObject object memory.
202 ***************************************************************************************************
203 */
operator delete(VOID * pObjMem)204 VOID AddrObject::operator delete(
205 VOID* pObjMem) ///< [in] User virtual address to free.
206 {
207 AddrObject* pObj = static_cast<AddrObject*>(pObjMem);
208 ClientFree(pObjMem, &pObj->m_client);
209 }
210
211 /**
212 ***************************************************************************************************
213 * AddrObject::DebugPrint
214 *
215 * @brief
216 * Print debug message
217 *
218 * @return
219 * N/A
220 ***************************************************************************************************
221 */
DebugPrint(const CHAR * pDebugString,...) const222 VOID AddrObject::DebugPrint(
223 const CHAR* pDebugString, ///< [in] Debug string
224 ...) const
225 {
226 #if DEBUG
227 if (m_client.callbacks.debugPrint != NULL)
228 {
229 va_list ap;
230
231 va_start(ap, pDebugString);
232
233 ADDR_DEBUGPRINT_INPUT debugPrintInput = {0};
234
235 debugPrintInput.size = sizeof(ADDR_DEBUGPRINT_INPUT);
236 debugPrintInput.pDebugString = const_cast<CHAR*>(pDebugString);
237 debugPrintInput.hClient = m_client.handle;
238 va_copy(debugPrintInput.ap, ap);
239
240 m_client.callbacks.debugPrint(&debugPrintInput);
241
242 va_end(ap);
243 }
244 #endif
245 }
246
247