Lines Matching refs:device
207 /* Be careful here. The device might not have been initialized. This can
350 "Failed to open device %s",
411 "Unable to allocate memory to store device name");
539 mesa_logd("Found compatible render device '%s'.",
545 mesa_logd("Found compatible primary device '%s'.",
1114 static VkResult pvr_device_init_compute_fence_program(struct pvr_device *device)
1116 const struct pvr_device_info *dev_info = &device->pdevice->dev_info;
1154 staging_buffer = vk_alloc(&device->vk.alloc,
1159 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
1168 result = pvr_gpu_upload_pds(device,
1176 &device->pds_compute_fence_program);
1178 vk_free(&device->vk.alloc, staging_buffer);
1184 struct pvr_device *device,
1192 const struct pvr_device_info *dev_info = &device->pdevice->dev_info;
1221 staging_buffer = vk_alloc(&device->vk.alloc,
1226 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
1244 result = pvr_gpu_upload_pds(device,
1254 vk_free(&device->vk.alloc, staging_buffer);
1265 staging_buffer = vk_realloc(&device->vk.alloc,
1271 pvr_bo_free(device, sw_compute_barrier_upload_out->pvr_bo);
1273 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
1292 result = pvr_gpu_upload_pds(device,
1302 vk_free(&device->vk.alloc, staging_buffer);
1303 pvr_bo_free(device, sw_compute_barrier_upload_out->pvr_bo);
1308 vk_free(&device->vk.alloc, staging_buffer);
1313 static VkResult pvr_device_init_compute_idfwdf_state(struct pvr_device *device)
1324 pvr_hard_code_get_idfwdf_program(&device->pdevice->dev_info,
1329 device->idfwdf_state.usc_shareds = usc_shareds;
1332 result = pvr_gpu_upload_usc(device,
1336 &device->idfwdf_state.usc);
1342 result = pvr_bo_alloc(device,
1343 device->heaps.general_heap,
1347 &device->idfwdf_state.store_bo);
1351 result = pvr_bo_alloc(device,
1352 device->heaps.general_heap,
1356 &device->idfwdf_state.shareds_bo);
1389 .addr = device->idfwdf_state.store_bo->vma->dev_addr,
1392 result = pvr_pack_tex_state(device, &tex_info, image_state);
1398 dword_ptr = (uint32_t *)device->idfwdf_state.shareds_bo->bo->map;
1407 dword_ptr[0] = HIGH_32(device->idfwdf_state.store_bo->vma->dev_addr.addr);
1408 dword_ptr[1] = LOW_32(device->idfwdf_state.store_bo->vma->dev_addr.addr);
1428 pvr_bo_cpu_unmap(device, device->idfwdf_state.shareds_bo);
1433 device,
1434 device->idfwdf_state.usc->vma->dev_addr,
1437 device->idfwdf_state.shareds_bo->vma->dev_addr,
1438 &device->idfwdf_state.pds,
1439 &device->idfwdf_state.sw_compute_barrier_pds);
1446 pvr_bo_free(device, device->idfwdf_state.shareds_bo);
1449 pvr_bo_free(device, device->idfwdf_state.store_bo);
1452 pvr_bo_free(device, device->idfwdf_state.usc);
1457 static void pvr_device_finish_compute_idfwdf_state(struct pvr_device *device)
1459 pvr_bo_free(device, device->idfwdf_state.pds.pvr_bo);
1460 pvr_bo_free(device, device->idfwdf_state.sw_compute_barrier_pds.pvr_bo);
1461 pvr_bo_free(device, device->idfwdf_state.shareds_bo);
1462 pvr_bo_free(device, device->idfwdf_state.store_bo);
1463 pvr_bo_free(device, device->idfwdf_state.usc);
1483 static VkResult pvr_device_init_nop_program(struct pvr_device *device)
1486 rogue_get_slc_cache_line_size(&device->pdevice->dev_info);
1492 result = pvr_gpu_upload_usc(device,
1496 &device->nop_program.usc);
1502 device->nop_program.usc->vma->dev_addr.addr,
1512 staging_buffer = vk_alloc(&device->vk.alloc,
1517 result = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
1524 result = pvr_gpu_upload_pds(device,
1532 &device->nop_program.pds);
1536 vk_free(&device->vk.alloc, staging_buffer);
1541 vk_free(&device->vk.alloc, staging_buffer);
1544 pvr_bo_free(device, device->nop_program.usc);
1549 static void pvr_device_init_default_sampler_state(struct pvr_device *device)
1551 pvr_csb_pack (&device->input_attachment_sampler, TEXSTATE_SAMPLER, sampler) {
1571 struct pvr_device *device;
1576 device = vk_alloc2(&pdevice->vk.instance->alloc,
1578 sizeof(*device),
1581 if (!device)
1592 result = vk_device_init(&device->vk,
1600 device->render_fd = open(pdevice->render_path, O_RDWR | O_CLOEXEC);
1601 if (device->render_fd < 0) {
1604 "Failed to open device %s",
1610 device->master_fd = open(pdevice->master_path, O_RDWR | O_CLOEXEC);
1612 device->master_fd = -1;
1614 vk_device_set_drm_fd(&device->vk, device->render_fd);
1616 device->instance = instance;
1617 device->pdevice = pdevice;
1619 device->ws = pvr_winsys_create(device->master_fd,
1620 device->render_fd,
1621 &device->vk.alloc);
1622 if (!device->ws) {
1627 device->ws->ops->get_heaps_info(device->ws, &device->heaps);
1629 result = pvr_free_list_create(device,
1635 &device->global_free_list);
1639 result = pvr_device_init_nop_program(device);
1643 result = pvr_device_init_compute_fence_program(device);
1647 result = pvr_device_init_compute_idfwdf_state(device);
1651 result = pvr_queues_create(device, pCreateInfo);
1655 pvr_device_init_default_sampler_state(device);
1658 memcpy(&device->features,
1660 sizeof(device->features));
1668 &device->pixel_event_data_size_in_dwords);
1670 device->global_queue_job_count = 0;
1671 device->global_queue_present_count = 0;
1673 *pDevice = pvr_device_to_handle(device);
1678 pvr_device_finish_compute_idfwdf_state(device);
1681 pvr_bo_free(device, device->pds_compute_fence_program.pvr_bo);
1684 pvr_bo_free(device, device->nop_program.pds.pvr_bo);
1685 pvr_bo_free(device, device->nop_program.usc);
1688 pvr_free_list_destroy(device->global_free_list);
1691 pvr_winsys_destroy(device->ws);
1694 if (device->master_fd >= 0)
1695 close(device->master_fd);
1697 close(device->render_fd);
1700 vk_device_finish(&device->vk);
1703 vk_free(&device->vk.alloc, device);
1711 PVR_FROM_HANDLE(pvr_device, device, _device);
1713 pvr_queues_destroy(device);
1714 pvr_device_finish_compute_idfwdf_state(device);
1715 pvr_bo_free(device, device->pds_compute_fence_program.pvr_bo);
1716 pvr_bo_free(device, device->nop_program.pds.pvr_bo);
1717 pvr_bo_free(device, device->nop_program.usc);
1718 pvr_free_list_destroy(device->global_free_list);
1719 pvr_winsys_destroy(device->ws);
1720 close(device->render_fd);
1721 vk_device_finish(&device->vk);
1722 vk_free(&device->vk.alloc, device);
1742 PVR_FROM_HANDLE(pvr_device, device, _device);
1750 mem = vk_object_alloc(&device->vk,
1755 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
1773 ALIGN_POT(pAllocateInfo->allocationSize, device->ws->page_size);
1779 result = device->ws->ops->buffer_create_from_fd(device->ws,
1794 result = vk_errorf(device,
1800 device->ws->ops->buffer_destroy(mem->bo);
1816 * used when binding device memory (see pvr_bind_memory()) to ensure the
1819 const uint64_t alignment = device->heaps.general_heap->page_size;
1822 * device->pdevice->memory.memoryTypes[pAllocateInfo->memoryTypeIndex].propertyFlags.
1828 result = device->ws->ops->buffer_create(device->ws,
1843 vk_object_free(&device->vk, pAllocator, mem);
1852 PVR_FROM_HANDLE(pvr_device, device, _device);
1861 return device->ws->ops->buffer_get_fd(mem->bo, pFd);
1870 PVR_FROM_HANDLE(pvr_device, device, _device);
1882 (1 << device->pdevice->memory.memoryTypeCount) - 1;
1885 return vk_error(device, VK_ERROR_INVALID_EXTERNAL_HANDLE);
1893 PVR_FROM_HANDLE(pvr_device, device, _device);
1899 device->ws->ops->buffer_destroy(mem->bo);
1901 vk_object_free(&device->vk, pAllocator, mem);
1911 PVR_FROM_HANDLE(pvr_device, device, _device);
1941 map = device->ws->ops->buffer_map(mem->bo);
1943 return vk_error(device, VK_ERROR_MEMORY_MAP_FAILED);
1952 PVR_FROM_HANDLE(pvr_device, device, _device);
1958 device->ws->ops->buffer_unmap(mem->bo);
1977 VkDevice device,
1985 void pvr_GetDeviceMemoryCommitment(VkDevice device,
1992 VkResult pvr_bind_memory(struct pvr_device *device,
2001 size + (offset & (device->heaps.general_heap->page_size - 1));
2018 vma = device->ws->ops->heap_alloc(device->heaps.general_heap,
2022 return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
2024 dev_addr = device->ws->ops->vma_map(vma, mem->bo, offset, size);
2026 device->ws->ops->heap_free(vma);
2027 return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
2036 void pvr_unbind_memory(struct pvr_device *device, struct pvr_winsys_vma *vma)
2038 device->ws->ops->vma_unmap(vma);
2039 device->ws->ops->heap_free(vma);
2046 PVR_FROM_HANDLE(pvr_device, device, _device);
2053 VkResult result = pvr_bind_memory(device,
2063 pvr_unbind_memory(device, buffer->vma);
2124 PVR_FROM_HANDLE(pvr_device, device, _device);
2136 vk_buffer_create(&device->vk, pCreateInfo, pAllocator, sizeof(*buffer));
2138 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
2151 PVR_FROM_HANDLE(pvr_device, device, _device);
2158 pvr_unbind_memory(device, buffer->vma);
2160 vk_buffer_destroy(&device->vk, pAllocator, &buffer->vk);
2163 VkResult pvr_gpu_upload(struct pvr_device *device,
2175 result = pvr_bo_alloc(device,
2185 pvr_bo_cpu_unmap(device, pvr_bo);
2192 VkResult pvr_gpu_upload_usc(struct pvr_device *device,
2207 result = pvr_bo_alloc(device,
2208 device->heaps.usc_heap,
2217 pvr_bo_cpu_unmap(device, pvr_bo);
2225 * \brief Upload PDS program data and code segments from host memory to device
2228 * \param[in] device Logical device pointer.
2243 VkResult pvr_gpu_upload_pds(struct pvr_device *device,
2270 result = pvr_bo_alloc(device,
2271 device->heaps.pds_heap,
2283 device->heaps.pds_heap->base_addr.addr;
2300 device->heaps.pds_heap->base_addr.addr;
2310 pvr_bo_cpu_unmap(device, pds_upload_out->pvr_bo);
2316 pvr_framebuffer_create_ppp_state(struct pvr_device *device,
2320 rogue_get_slc_cache_line_size(&device->pdevice->dev_info);
2346 result = pvr_gpu_upload(device,
2347 device->heaps.general_heap,
2398 PVR_FROM_HANDLE(pvr_device, device, _device);
2408 PVR_RENDER_TARGETS_PER_FRAMEBUFFER(&device->pdevice->dev_info);
2422 &device->vk.alloc,
2425 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
2427 vk_object_base_init(&device->vk,
2442 result = pvr_framebuffer_create_ppp_state(device, framebuffer);
2450 result = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
2459 pvr_bo_free(device, framebuffer->ppp_state_bo);
2463 vk_free2(&device->vk.alloc, pAllocator, framebuffer);
2472 PVR_FROM_HANDLE(pvr_device, device, _device);
2480 pvr_bo_free(device, framebuffer->ppp_state_bo);
2482 vk_free2(&device->vk.alloc, pAllocator, framebuffer);
2564 PVR_FROM_HANDLE(pvr_device, device, _device);
2575 sampler = vk_object_alloc(&device->vk,
2580 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
2585 if (PVR_HAS_QUIRK(&device->pdevice->dev_info, 51025)) {
2620 const struct pvr_device_info *dev_info = &device->pdevice->dev_info;
2664 if (PVR_HAS_QUIRK(&device->pdevice->dev_info, 51025) &&
2701 PVR_FROM_HANDLE(pvr_device, device, _device);
2707 vk_object_free(&device->vk, pAllocator, sampler);
2716 PVR_FROM_HANDLE(pvr_device, device, _device);
2723 * structure for the physical device is supported for the resource.
2728 (1ul << device->pdevice->memory.memoryTypeCount) - 1;
2739 PVR_FROM_HANDLE(pvr_device, device, _device);
2747 * structure for the physical device is supported for the resource.
2752 (1ul << device->pdevice->memory.memoryTypeCount) - 1;