diff options
Diffstat (limited to 'amdgpu/amdgpu_device.c')
-rw-r--r-- | amdgpu/amdgpu_device.c | 92 |
1 files changed, 50 insertions, 42 deletions
diff --git a/amdgpu/amdgpu_device.c b/amdgpu/amdgpu_device.c index f4ede031..d81efcf8 100644 --- a/amdgpu/amdgpu_device.c +++ b/amdgpu/amdgpu_device.c | |||
@@ -28,10 +28,6 @@ | |||
28 | * | 28 | * |
29 | */ | 29 | */ |
30 | 30 | ||
31 | #ifdef HAVE_CONFIG_H | ||
32 | #include "config.h" | ||
33 | #endif | ||
34 | |||
35 | #include <sys/stat.h> | 31 | #include <sys/stat.h> |
36 | #include <errno.h> | 32 | #include <errno.h> |
37 | #include <string.h> | 33 | #include <string.h> |
@@ -44,7 +40,6 @@ | |||
44 | #include "amdgpu_internal.h" | 40 | #include "amdgpu_internal.h" |
45 | #include "util_hash_table.h" | 41 | #include "util_hash_table.h" |
46 | #include "util_math.h" | 42 | #include "util_math.h" |
47 | #include "amdgpu_asic_id.h" | ||
48 | 43 | ||
49 | #define PTR_TO_UINT(x) ((unsigned)((intptr_t)(x))) | 44 | #define PTR_TO_UINT(x) ((unsigned)((intptr_t)(x))) |
50 | #define UINT_TO_PTR(x) ((void *)((intptr_t)(x))) | 45 | #define UINT_TO_PTR(x) ((void *)((intptr_t)(x))) |
@@ -131,10 +126,8 @@ static int amdgpu_get_auth(int fd, int *auth) | |||
131 | 126 | ||
132 | static void amdgpu_device_free_internal(amdgpu_device_handle dev) | 127 | static void amdgpu_device_free_internal(amdgpu_device_handle dev) |
133 | { | 128 | { |
134 | amdgpu_vamgr_deinit(dev->vamgr); | 129 | amdgpu_vamgr_deinit(&dev->vamgr_32); |
135 | free(dev->vamgr); | 130 | amdgpu_vamgr_deinit(&dev->vamgr); |
136 | amdgpu_vamgr_deinit(dev->vamgr_32); | ||
137 | free(dev->vamgr_32); | ||
138 | util_hash_table_destroy(dev->bo_flink_names); | 131 | util_hash_table_destroy(dev->bo_flink_names); |
139 | util_hash_table_destroy(dev->bo_handles); | 132 | util_hash_table_destroy(dev->bo_handles); |
140 | pthread_mutex_destroy(&dev->bo_table_mutex); | 133 | pthread_mutex_destroy(&dev->bo_table_mutex); |
@@ -142,6 +135,7 @@ static void amdgpu_device_free_internal(amdgpu_device_handle dev) | |||
142 | close(dev->fd); | 135 | close(dev->fd); |
143 | if ((dev->flink_fd >= 0) && (dev->fd != dev->flink_fd)) | 136 | if ((dev->flink_fd >= 0) && (dev->fd != dev->flink_fd)) |
144 | close(dev->flink_fd); | 137 | close(dev->flink_fd); |
138 | free(dev->marketing_name); | ||
145 | free(dev); | 139 | free(dev); |
146 | } | 140 | } |
147 | 141 | ||
@@ -187,6 +181,8 @@ int amdgpu_device_initialize(int fd, | |||
187 | fd_tab = util_hash_table_create(fd_hash, fd_compare); | 181 | fd_tab = util_hash_table_create(fd_hash, fd_compare); |
188 | r = amdgpu_get_auth(fd, &flag_auth); | 182 | r = amdgpu_get_auth(fd, &flag_auth); |
189 | if (r) { | 183 | if (r) { |
184 | fprintf(stderr, "%s: amdgpu_get_auth (1) failed (%i)\n", | ||
185 | __func__, r); | ||
190 | pthread_mutex_unlock(&fd_mutex); | 186 | pthread_mutex_unlock(&fd_mutex); |
191 | return r; | 187 | return r; |
192 | } | 188 | } |
@@ -194,6 +190,8 @@ int amdgpu_device_initialize(int fd, | |||
194 | if (dev) { | 190 | if (dev) { |
195 | r = amdgpu_get_auth(dev->fd, &flag_authexist); | 191 | r = amdgpu_get_auth(dev->fd, &flag_authexist); |
196 | if (r) { | 192 | if (r) { |
193 | fprintf(stderr, "%s: amdgpu_get_auth (2) failed (%i)\n", | ||
194 | __func__, r); | ||
197 | pthread_mutex_unlock(&fd_mutex); | 195 | pthread_mutex_unlock(&fd_mutex); |
198 | return r; | 196 | return r; |
199 | } | 197 | } |
@@ -209,6 +207,7 @@ int amdgpu_device_initialize(int fd, | |||
209 | 207 | ||
210 | dev = calloc(1, sizeof(struct amdgpu_device)); | 208 | dev = calloc(1, sizeof(struct amdgpu_device)); |
211 | if (!dev) { | 209 | if (!dev) { |
210 | fprintf(stderr, "%s: calloc failed\n", __func__); | ||
212 | pthread_mutex_unlock(&fd_mutex); | 211 | pthread_mutex_unlock(&fd_mutex); |
213 | return -ENOMEM; | 212 | return -ENOMEM; |
214 | } | 213 | } |
@@ -244,38 +243,47 @@ int amdgpu_device_initialize(int fd, | |||
244 | 243 | ||
245 | /* Check if acceleration is working. */ | 244 | /* Check if acceleration is working. */ |
246 | r = amdgpu_query_info(dev, AMDGPU_INFO_ACCEL_WORKING, 4, &accel_working); | 245 | r = amdgpu_query_info(dev, AMDGPU_INFO_ACCEL_WORKING, 4, &accel_working); |
247 | if (r) | 246 | if (r) { |
247 | fprintf(stderr, "%s: amdgpu_query_info(ACCEL_WORKING) failed (%i)\n", | ||
248 | __func__, r); | ||
248 | goto cleanup; | 249 | goto cleanup; |
250 | } | ||
249 | if (!accel_working) { | 251 | if (!accel_working) { |
252 | fprintf(stderr, "%s: AMDGPU_INFO_ACCEL_WORKING = 0\n", __func__); | ||
250 | r = -EBADF; | 253 | r = -EBADF; |
251 | goto cleanup; | 254 | goto cleanup; |
252 | } | 255 | } |
253 | 256 | ||
254 | r = amdgpu_query_gpu_info_init(dev); | 257 | r = amdgpu_query_gpu_info_init(dev); |
255 | if (r) | 258 | if (r) { |
259 | fprintf(stderr, "%s: amdgpu_query_gpu_info_init failed\n", __func__); | ||
256 | goto cleanup; | 260 | goto cleanup; |
261 | } | ||
257 | 262 | ||
258 | dev->vamgr = calloc(1, sizeof(struct amdgpu_bo_va_mgr)); | 263 | start = dev->dev_info.virtual_address_offset; |
259 | if (dev->vamgr == NULL) | 264 | max = MIN2(dev->dev_info.virtual_address_max, 0x100000000ULL); |
260 | goto cleanup; | 265 | amdgpu_vamgr_init(&dev->vamgr_32, start, max, |
266 | dev->dev_info.virtual_address_alignment); | ||
261 | 267 | ||
262 | amdgpu_vamgr_init(dev->vamgr, dev->dev_info.virtual_address_offset, | 268 | start = max; |
263 | dev->dev_info.virtual_address_max, | 269 | max = MAX2(dev->dev_info.virtual_address_max, 0x100000000ULL); |
270 | amdgpu_vamgr_init(&dev->vamgr, start, max, | ||
264 | dev->dev_info.virtual_address_alignment); | 271 | dev->dev_info.virtual_address_alignment); |
265 | 272 | ||
266 | max = MIN2(dev->dev_info.virtual_address_max, 0xffffffff); | 273 | start = dev->dev_info.high_va_offset; |
267 | start = amdgpu_vamgr_find_va(dev->vamgr, | 274 | max = MIN2(dev->dev_info.high_va_max, (start & ~0xffffffffULL) + |
268 | max - dev->dev_info.virtual_address_offset, | 275 | 0x100000000ULL); |
269 | dev->dev_info.virtual_address_alignment, 0); | 276 | amdgpu_vamgr_init(&dev->vamgr_high_32, start, max, |
270 | if (start > 0xffffffff) | ||
271 | goto free_va; /* shouldn't get here */ | ||
272 | |||
273 | dev->vamgr_32 = calloc(1, sizeof(struct amdgpu_bo_va_mgr)); | ||
274 | if (dev->vamgr_32 == NULL) | ||
275 | goto free_va; | ||
276 | amdgpu_vamgr_init(dev->vamgr_32, start, max, | ||
277 | dev->dev_info.virtual_address_alignment); | 277 | dev->dev_info.virtual_address_alignment); |
278 | 278 | ||
279 | start = max; | ||
280 | max = MAX2(dev->dev_info.high_va_max, (start & ~0xffffffffULL) + | ||
281 | 0x100000000ULL); | ||
282 | amdgpu_vamgr_init(&dev->vamgr_high, start, max, | ||
283 | dev->dev_info.virtual_address_alignment); | ||
284 | |||
285 | amdgpu_parse_asic_ids(dev); | ||
286 | |||
279 | *major_version = dev->major_version; | 287 | *major_version = dev->major_version; |
280 | *minor_version = dev->minor_version; | 288 | *minor_version = dev->minor_version; |
281 | *device_handle = dev; | 289 | *device_handle = dev; |
@@ -284,13 +292,6 @@ int amdgpu_device_initialize(int fd, | |||
284 | 292 | ||
285 | return 0; | 293 | return 0; |
286 | 294 | ||
287 | free_va: | ||
288 | r = -ENOMEM; | ||
289 | amdgpu_vamgr_free_va(dev->vamgr, start, | ||
290 | max - dev->dev_info.virtual_address_offset); | ||
291 | amdgpu_vamgr_deinit(dev->vamgr); | ||
292 | free(dev->vamgr); | ||
293 | |||
294 | cleanup: | 295 | cleanup: |
295 | if (dev->fd >= 0) | 296 | if (dev->fd >= 0) |
296 | close(dev->fd); | 297 | close(dev->fd); |
@@ -307,14 +308,21 @@ int amdgpu_device_deinitialize(amdgpu_device_handle dev) | |||
307 | 308 | ||
308 | const char *amdgpu_get_marketing_name(amdgpu_device_handle dev) | 309 | const char *amdgpu_get_marketing_name(amdgpu_device_handle dev) |
309 | { | 310 | { |
310 | const struct amdgpu_asic_id_table_t *t = amdgpu_asic_id_table; | 311 | return dev->marketing_name; |
312 | } | ||
311 | 313 | ||
312 | while (t->did) { | 314 | int amdgpu_query_sw_info(amdgpu_device_handle dev, enum amdgpu_sw_info info, |
313 | if ((t->did == dev->info.asic_id) && | 315 | void *value) |
314 | (t->rid == dev->info.pci_rev_id)) | 316 | { |
315 | return t->marketing_name; | 317 | uint32_t *val32 = (uint32_t*)value; |
316 | t++; | 318 | |
319 | switch (info) { | ||
320 | case amdgpu_sw_info_address32_hi: | ||
321 | if (dev->vamgr_high_32.va_max) | ||
322 | *val32 = (dev->vamgr_high_32.va_max - 1) >> 32; | ||
323 | else | ||
324 | *val32 = (dev->vamgr_32.va_max - 1) >> 32; | ||
325 | return 0; | ||
317 | } | 326 | } |
318 | 327 | return -EINVAL; | |
319 | return NULL; | ||
320 | } | 328 | } |