15b5c4e40SEvgeny Pinchuk /* 25b5c4e40SEvgeny Pinchuk * Copyright 2014 Advanced Micro Devices, Inc. 35b5c4e40SEvgeny Pinchuk * 45b5c4e40SEvgeny Pinchuk * Permission is hereby granted, free of charge, to any person obtaining a 55b5c4e40SEvgeny Pinchuk * copy of this software and associated documentation files (the "Software"), 65b5c4e40SEvgeny Pinchuk * to deal in the Software without restriction, including without limitation 75b5c4e40SEvgeny Pinchuk * the rights to use, copy, modify, merge, publish, distribute, sublicense, 85b5c4e40SEvgeny Pinchuk * and/or sell copies of the Software, and to permit persons to whom the 95b5c4e40SEvgeny Pinchuk * Software is furnished to do so, subject to the following conditions: 105b5c4e40SEvgeny Pinchuk * 115b5c4e40SEvgeny Pinchuk * The above copyright notice and this permission notice shall be included in 125b5c4e40SEvgeny Pinchuk * all copies or substantial portions of the Software. 135b5c4e40SEvgeny Pinchuk * 145b5c4e40SEvgeny Pinchuk * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 155b5c4e40SEvgeny Pinchuk * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 165b5c4e40SEvgeny Pinchuk * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 175b5c4e40SEvgeny Pinchuk * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 185b5c4e40SEvgeny Pinchuk * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 195b5c4e40SEvgeny Pinchuk * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 205b5c4e40SEvgeny Pinchuk * OTHER DEALINGS IN THE SOFTWARE. 215b5c4e40SEvgeny Pinchuk */ 225b5c4e40SEvgeny Pinchuk 235b5c4e40SEvgeny Pinchuk #include <linux/types.h> 245b5c4e40SEvgeny Pinchuk #include <linux/kernel.h> 255b5c4e40SEvgeny Pinchuk #include <linux/pci.h> 265b5c4e40SEvgeny Pinchuk #include <linux/errno.h> 275b5c4e40SEvgeny Pinchuk #include <linux/acpi.h> 285b5c4e40SEvgeny Pinchuk #include <linux/hash.h> 295b5c4e40SEvgeny Pinchuk #include <linux/cpufreq.h> 30f7c826adSAlexey Skidanov #include <linux/log2.h> 31520b8fb7SFelix Kuehling #include <linux/dmi.h> 32520b8fb7SFelix Kuehling #include <linux/atomic.h> 335b5c4e40SEvgeny Pinchuk 345b5c4e40SEvgeny Pinchuk #include "kfd_priv.h" 355b5c4e40SEvgeny Pinchuk #include "kfd_crat.h" 365b5c4e40SEvgeny Pinchuk #include "kfd_topology.h" 37851a645eSFelix Kuehling #include "kfd_device_queue_manager.h" 3864d1c3a4SFelix Kuehling #include "kfd_iommu.h" 395a75ea56SFelix Kuehling #include "kfd_svm.h" 405b87245fSAmber Lin #include "amdgpu_amdkfd.h" 410dee45a2SEric Huang #include "amdgpu_ras.h" 425b5c4e40SEvgeny Pinchuk 434f449311SHarish Kasiviswanathan /* topology_device_list - Master list of all topology devices */ 444f449311SHarish Kasiviswanathan static struct list_head topology_device_list; 45520b8fb7SFelix Kuehling static struct kfd_system_properties sys_props; 465b5c4e40SEvgeny Pinchuk 475b5c4e40SEvgeny Pinchuk static DECLARE_RWSEM(topology_lock); 48520b8fb7SFelix Kuehling static atomic_t topology_crat_proximity_domain; 495b5c4e40SEvgeny Pinchuk 503a87177eSHarish Kasiviswanathan struct kfd_topology_device *kfd_topology_device_by_proximity_domain( 513a87177eSHarish Kasiviswanathan uint32_t proximity_domain) 523a87177eSHarish Kasiviswanathan { 533a87177eSHarish Kasiviswanathan struct kfd_topology_device *top_dev; 543a87177eSHarish Kasiviswanathan struct kfd_topology_device *device = NULL; 553a87177eSHarish Kasiviswanathan 563a87177eSHarish Kasiviswanathan down_read(&topology_lock); 573a87177eSHarish Kasiviswanathan 583a87177eSHarish Kasiviswanathan list_for_each_entry(top_dev, &topology_device_list, list) 593a87177eSHarish Kasiviswanathan if (top_dev->proximity_domain == proximity_domain) { 603a87177eSHarish Kasiviswanathan device = top_dev; 613a87177eSHarish Kasiviswanathan break; 623a87177eSHarish Kasiviswanathan } 633a87177eSHarish Kasiviswanathan 643a87177eSHarish Kasiviswanathan up_read(&topology_lock); 653a87177eSHarish Kasiviswanathan 663a87177eSHarish Kasiviswanathan return device; 673a87177eSHarish Kasiviswanathan } 683a87177eSHarish Kasiviswanathan 6944d8cc6fSYong Zhao struct kfd_topology_device *kfd_topology_device_by_id(uint32_t gpu_id) 705b5c4e40SEvgeny Pinchuk { 7144d8cc6fSYong Zhao struct kfd_topology_device *top_dev = NULL; 7244d8cc6fSYong Zhao struct kfd_topology_device *ret = NULL; 735b5c4e40SEvgeny Pinchuk 745b5c4e40SEvgeny Pinchuk down_read(&topology_lock); 755b5c4e40SEvgeny Pinchuk 765b5c4e40SEvgeny Pinchuk list_for_each_entry(top_dev, &topology_device_list, list) 775b5c4e40SEvgeny Pinchuk if (top_dev->gpu_id == gpu_id) { 7844d8cc6fSYong Zhao ret = top_dev; 795b5c4e40SEvgeny Pinchuk break; 805b5c4e40SEvgeny Pinchuk } 815b5c4e40SEvgeny Pinchuk 825b5c4e40SEvgeny Pinchuk up_read(&topology_lock); 835b5c4e40SEvgeny Pinchuk 8444d8cc6fSYong Zhao return ret; 8544d8cc6fSYong Zhao } 8644d8cc6fSYong Zhao 8744d8cc6fSYong Zhao struct kfd_dev *kfd_device_by_id(uint32_t gpu_id) 8844d8cc6fSYong Zhao { 8944d8cc6fSYong Zhao struct kfd_topology_device *top_dev; 9044d8cc6fSYong Zhao 9144d8cc6fSYong Zhao top_dev = kfd_topology_device_by_id(gpu_id); 9244d8cc6fSYong Zhao if (!top_dev) 9344d8cc6fSYong Zhao return NULL; 9444d8cc6fSYong Zhao 9544d8cc6fSYong Zhao return top_dev->gpu; 965b5c4e40SEvgeny Pinchuk } 975b5c4e40SEvgeny Pinchuk 985b5c4e40SEvgeny Pinchuk struct kfd_dev *kfd_device_by_pci_dev(const struct pci_dev *pdev) 995b5c4e40SEvgeny Pinchuk { 1005b5c4e40SEvgeny Pinchuk struct kfd_topology_device *top_dev; 1015b5c4e40SEvgeny Pinchuk struct kfd_dev *device = NULL; 1025b5c4e40SEvgeny Pinchuk 1035b5c4e40SEvgeny Pinchuk down_read(&topology_lock); 1045b5c4e40SEvgeny Pinchuk 1055b5c4e40SEvgeny Pinchuk list_for_each_entry(top_dev, &topology_device_list, list) 1063704d56eSFelix Kuehling if (top_dev->gpu && top_dev->gpu->pdev == pdev) { 1075b5c4e40SEvgeny Pinchuk device = top_dev->gpu; 1085b5c4e40SEvgeny Pinchuk break; 1095b5c4e40SEvgeny Pinchuk } 1105b5c4e40SEvgeny Pinchuk 1115b5c4e40SEvgeny Pinchuk up_read(&topology_lock); 1125b5c4e40SEvgeny Pinchuk 1135b5c4e40SEvgeny Pinchuk return device; 1145b5c4e40SEvgeny Pinchuk } 1155b5c4e40SEvgeny Pinchuk 116574c4183SGraham Sider struct kfd_dev *kfd_device_by_adev(const struct amdgpu_device *adev) 1171dde0ea9SFelix Kuehling { 1181dde0ea9SFelix Kuehling struct kfd_topology_device *top_dev; 1191dde0ea9SFelix Kuehling struct kfd_dev *device = NULL; 1201dde0ea9SFelix Kuehling 1211dde0ea9SFelix Kuehling down_read(&topology_lock); 1221dde0ea9SFelix Kuehling 1231dde0ea9SFelix Kuehling list_for_each_entry(top_dev, &topology_device_list, list) 124574c4183SGraham Sider if (top_dev->gpu && top_dev->gpu->adev == adev) { 1251dde0ea9SFelix Kuehling device = top_dev->gpu; 1261dde0ea9SFelix Kuehling break; 1271dde0ea9SFelix Kuehling } 1281dde0ea9SFelix Kuehling 1291dde0ea9SFelix Kuehling up_read(&topology_lock); 1301dde0ea9SFelix Kuehling 1311dde0ea9SFelix Kuehling return device; 1321dde0ea9SFelix Kuehling } 1331dde0ea9SFelix Kuehling 1343a87177eSHarish Kasiviswanathan /* Called with write topology_lock acquired */ 1355b5c4e40SEvgeny Pinchuk static void kfd_release_topology_device(struct kfd_topology_device *dev) 1365b5c4e40SEvgeny Pinchuk { 1375b5c4e40SEvgeny Pinchuk struct kfd_mem_properties *mem; 1385b5c4e40SEvgeny Pinchuk struct kfd_cache_properties *cache; 1395b5c4e40SEvgeny Pinchuk struct kfd_iolink_properties *iolink; 140f4757347SAmber Lin struct kfd_perf_properties *perf; 1415b5c4e40SEvgeny Pinchuk 1425b5c4e40SEvgeny Pinchuk list_del(&dev->list); 1435b5c4e40SEvgeny Pinchuk 1445b5c4e40SEvgeny Pinchuk while (dev->mem_props.next != &dev->mem_props) { 1455b5c4e40SEvgeny Pinchuk mem = container_of(dev->mem_props.next, 1465b5c4e40SEvgeny Pinchuk struct kfd_mem_properties, list); 1475b5c4e40SEvgeny Pinchuk list_del(&mem->list); 1485b5c4e40SEvgeny Pinchuk kfree(mem); 1495b5c4e40SEvgeny Pinchuk } 1505b5c4e40SEvgeny Pinchuk 1515b5c4e40SEvgeny Pinchuk while (dev->cache_props.next != &dev->cache_props) { 1525b5c4e40SEvgeny Pinchuk cache = container_of(dev->cache_props.next, 1535b5c4e40SEvgeny Pinchuk struct kfd_cache_properties, list); 1545b5c4e40SEvgeny Pinchuk list_del(&cache->list); 1555b5c4e40SEvgeny Pinchuk kfree(cache); 1565b5c4e40SEvgeny Pinchuk } 1575b5c4e40SEvgeny Pinchuk 1585b5c4e40SEvgeny Pinchuk while (dev->io_link_props.next != &dev->io_link_props) { 1595b5c4e40SEvgeny Pinchuk iolink = container_of(dev->io_link_props.next, 1605b5c4e40SEvgeny Pinchuk struct kfd_iolink_properties, list); 1615b5c4e40SEvgeny Pinchuk list_del(&iolink->list); 1625b5c4e40SEvgeny Pinchuk kfree(iolink); 1635b5c4e40SEvgeny Pinchuk } 1645b5c4e40SEvgeny Pinchuk 165f4757347SAmber Lin while (dev->perf_props.next != &dev->perf_props) { 166f4757347SAmber Lin perf = container_of(dev->perf_props.next, 167f4757347SAmber Lin struct kfd_perf_properties, list); 168f4757347SAmber Lin list_del(&perf->list); 169f4757347SAmber Lin kfree(perf); 170f4757347SAmber Lin } 171f4757347SAmber Lin 1725b5c4e40SEvgeny Pinchuk kfree(dev); 1735b5c4e40SEvgeny Pinchuk } 1745b5c4e40SEvgeny Pinchuk 1754f449311SHarish Kasiviswanathan void kfd_release_topology_device_list(struct list_head *device_list) 1765b5c4e40SEvgeny Pinchuk { 1775b5c4e40SEvgeny Pinchuk struct kfd_topology_device *dev; 1785b5c4e40SEvgeny Pinchuk 1794f449311SHarish Kasiviswanathan while (!list_empty(device_list)) { 1804f449311SHarish Kasiviswanathan dev = list_first_entry(device_list, 1815b5c4e40SEvgeny Pinchuk struct kfd_topology_device, list); 1825b5c4e40SEvgeny Pinchuk kfd_release_topology_device(dev); 1835b5c4e40SEvgeny Pinchuk } 1844f449311SHarish Kasiviswanathan } 1855b5c4e40SEvgeny Pinchuk 1864f449311SHarish Kasiviswanathan static void kfd_release_live_view(void) 1874f449311SHarish Kasiviswanathan { 1884f449311SHarish Kasiviswanathan kfd_release_topology_device_list(&topology_device_list); 1895b5c4e40SEvgeny Pinchuk memset(&sys_props, 0, sizeof(sys_props)); 1905b5c4e40SEvgeny Pinchuk } 1915b5c4e40SEvgeny Pinchuk 1924f449311SHarish Kasiviswanathan struct kfd_topology_device *kfd_create_topology_device( 1934f449311SHarish Kasiviswanathan struct list_head *device_list) 1945b5c4e40SEvgeny Pinchuk { 1955b5c4e40SEvgeny Pinchuk struct kfd_topology_device *dev; 1965b5c4e40SEvgeny Pinchuk 1975b5c4e40SEvgeny Pinchuk dev = kfd_alloc_struct(dev); 1984eacc26bSKent Russell if (!dev) { 1995b5c4e40SEvgeny Pinchuk pr_err("No memory to allocate a topology device"); 20016b9201cSOded Gabbay return NULL; 2015b5c4e40SEvgeny Pinchuk } 2025b5c4e40SEvgeny Pinchuk 2035b5c4e40SEvgeny Pinchuk INIT_LIST_HEAD(&dev->mem_props); 2045b5c4e40SEvgeny Pinchuk INIT_LIST_HEAD(&dev->cache_props); 2055b5c4e40SEvgeny Pinchuk INIT_LIST_HEAD(&dev->io_link_props); 206f4757347SAmber Lin INIT_LIST_HEAD(&dev->perf_props); 2075b5c4e40SEvgeny Pinchuk 2084f449311SHarish Kasiviswanathan list_add_tail(&dev->list, device_list); 2095b5c4e40SEvgeny Pinchuk 2105b5c4e40SEvgeny Pinchuk return dev; 2115b5c4e40SEvgeny Pinchuk } 2125b5c4e40SEvgeny Pinchuk 2135b5c4e40SEvgeny Pinchuk 21483a13ef5SFelix Kuehling #define sysfs_show_gen_prop(buffer, offs, fmt, ...) \ 21583a13ef5SFelix Kuehling (offs += snprintf(buffer+offs, PAGE_SIZE-offs, \ 21683a13ef5SFelix Kuehling fmt, __VA_ARGS__)) 21783a13ef5SFelix Kuehling #define sysfs_show_32bit_prop(buffer, offs, name, value) \ 21883a13ef5SFelix Kuehling sysfs_show_gen_prop(buffer, offs, "%s %u\n", name, value) 21983a13ef5SFelix Kuehling #define sysfs_show_64bit_prop(buffer, offs, name, value) \ 22083a13ef5SFelix Kuehling sysfs_show_gen_prop(buffer, offs, "%s %llu\n", name, value) 22183a13ef5SFelix Kuehling #define sysfs_show_32bit_val(buffer, offs, value) \ 22283a13ef5SFelix Kuehling sysfs_show_gen_prop(buffer, offs, "%u\n", value) 22383a13ef5SFelix Kuehling #define sysfs_show_str_val(buffer, offs, value) \ 22483a13ef5SFelix Kuehling sysfs_show_gen_prop(buffer, offs, "%s\n", value) 2255b5c4e40SEvgeny Pinchuk 2265b5c4e40SEvgeny Pinchuk static ssize_t sysprops_show(struct kobject *kobj, struct attribute *attr, 2275b5c4e40SEvgeny Pinchuk char *buffer) 2285b5c4e40SEvgeny Pinchuk { 22983a13ef5SFelix Kuehling int offs = 0; 2305b5c4e40SEvgeny Pinchuk 2315b5c4e40SEvgeny Pinchuk /* Making sure that the buffer is an empty string */ 2325b5c4e40SEvgeny Pinchuk buffer[0] = 0; 2335b5c4e40SEvgeny Pinchuk 2345b5c4e40SEvgeny Pinchuk if (attr == &sys_props.attr_genid) { 23583a13ef5SFelix Kuehling sysfs_show_32bit_val(buffer, offs, 23683a13ef5SFelix Kuehling sys_props.generation_count); 2375b5c4e40SEvgeny Pinchuk } else if (attr == &sys_props.attr_props) { 23883a13ef5SFelix Kuehling sysfs_show_64bit_prop(buffer, offs, "platform_oem", 2395b5c4e40SEvgeny Pinchuk sys_props.platform_oem); 24083a13ef5SFelix Kuehling sysfs_show_64bit_prop(buffer, offs, "platform_id", 2415b5c4e40SEvgeny Pinchuk sys_props.platform_id); 24283a13ef5SFelix Kuehling sysfs_show_64bit_prop(buffer, offs, "platform_rev", 2435b5c4e40SEvgeny Pinchuk sys_props.platform_rev); 2445b5c4e40SEvgeny Pinchuk } else { 24583a13ef5SFelix Kuehling offs = -EINVAL; 2465b5c4e40SEvgeny Pinchuk } 2475b5c4e40SEvgeny Pinchuk 24883a13ef5SFelix Kuehling return offs; 2495b5c4e40SEvgeny Pinchuk } 2505b5c4e40SEvgeny Pinchuk 2515108d768SYong Zhao static void kfd_topology_kobj_release(struct kobject *kobj) 2525108d768SYong Zhao { 2535108d768SYong Zhao kfree(kobj); 2545108d768SYong Zhao } 2555108d768SYong Zhao 2565b5c4e40SEvgeny Pinchuk static const struct sysfs_ops sysprops_ops = { 2575b5c4e40SEvgeny Pinchuk .show = sysprops_show, 2585b5c4e40SEvgeny Pinchuk }; 2595b5c4e40SEvgeny Pinchuk 2605b5c4e40SEvgeny Pinchuk static struct kobj_type sysprops_type = { 2615108d768SYong Zhao .release = kfd_topology_kobj_release, 2625b5c4e40SEvgeny Pinchuk .sysfs_ops = &sysprops_ops, 2635b5c4e40SEvgeny Pinchuk }; 2645b5c4e40SEvgeny Pinchuk 2655b5c4e40SEvgeny Pinchuk static ssize_t iolink_show(struct kobject *kobj, struct attribute *attr, 2665b5c4e40SEvgeny Pinchuk char *buffer) 2675b5c4e40SEvgeny Pinchuk { 26883a13ef5SFelix Kuehling int offs = 0; 2695b5c4e40SEvgeny Pinchuk struct kfd_iolink_properties *iolink; 2705b5c4e40SEvgeny Pinchuk 2715b5c4e40SEvgeny Pinchuk /* Making sure that the buffer is an empty string */ 2725b5c4e40SEvgeny Pinchuk buffer[0] = 0; 2735b5c4e40SEvgeny Pinchuk 2745b5c4e40SEvgeny Pinchuk iolink = container_of(attr, struct kfd_iolink_properties, attr); 2756b855f7bSHarish Kasiviswanathan if (iolink->gpu && kfd_devcgroup_check_permission(iolink->gpu)) 2766b855f7bSHarish Kasiviswanathan return -EPERM; 27783a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "type", iolink->iolink_type); 27883a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "version_major", iolink->ver_maj); 27983a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "version_minor", iolink->ver_min); 28083a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "node_from", iolink->node_from); 28183a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "node_to", iolink->node_to); 28283a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "weight", iolink->weight); 28383a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "min_latency", iolink->min_latency); 28483a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "max_latency", iolink->max_latency); 28583a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "min_bandwidth", 28683a13ef5SFelix Kuehling iolink->min_bandwidth); 28783a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "max_bandwidth", 28883a13ef5SFelix Kuehling iolink->max_bandwidth); 28983a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "recommended_transfer_size", 2905b5c4e40SEvgeny Pinchuk iolink->rec_transfer_size); 29183a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "flags", iolink->flags); 2925b5c4e40SEvgeny Pinchuk 29383a13ef5SFelix Kuehling return offs; 2945b5c4e40SEvgeny Pinchuk } 2955b5c4e40SEvgeny Pinchuk 2965b5c4e40SEvgeny Pinchuk static const struct sysfs_ops iolink_ops = { 2975b5c4e40SEvgeny Pinchuk .show = iolink_show, 2985b5c4e40SEvgeny Pinchuk }; 2995b5c4e40SEvgeny Pinchuk 3005b5c4e40SEvgeny Pinchuk static struct kobj_type iolink_type = { 3015108d768SYong Zhao .release = kfd_topology_kobj_release, 3025b5c4e40SEvgeny Pinchuk .sysfs_ops = &iolink_ops, 3035b5c4e40SEvgeny Pinchuk }; 3045b5c4e40SEvgeny Pinchuk 3055b5c4e40SEvgeny Pinchuk static ssize_t mem_show(struct kobject *kobj, struct attribute *attr, 3065b5c4e40SEvgeny Pinchuk char *buffer) 3075b5c4e40SEvgeny Pinchuk { 30883a13ef5SFelix Kuehling int offs = 0; 3095b5c4e40SEvgeny Pinchuk struct kfd_mem_properties *mem; 3105b5c4e40SEvgeny Pinchuk 3115b5c4e40SEvgeny Pinchuk /* Making sure that the buffer is an empty string */ 3125b5c4e40SEvgeny Pinchuk buffer[0] = 0; 3135b5c4e40SEvgeny Pinchuk 3145b5c4e40SEvgeny Pinchuk mem = container_of(attr, struct kfd_mem_properties, attr); 3156b855f7bSHarish Kasiviswanathan if (mem->gpu && kfd_devcgroup_check_permission(mem->gpu)) 3166b855f7bSHarish Kasiviswanathan return -EPERM; 31783a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "heap_type", mem->heap_type); 31883a13ef5SFelix Kuehling sysfs_show_64bit_prop(buffer, offs, "size_in_bytes", 31983a13ef5SFelix Kuehling mem->size_in_bytes); 32083a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "flags", mem->flags); 32183a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "width", mem->width); 32283a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "mem_clk_max", 32383a13ef5SFelix Kuehling mem->mem_clk_max); 3245b5c4e40SEvgeny Pinchuk 32583a13ef5SFelix Kuehling return offs; 3265b5c4e40SEvgeny Pinchuk } 3275b5c4e40SEvgeny Pinchuk 3285b5c4e40SEvgeny Pinchuk static const struct sysfs_ops mem_ops = { 3295b5c4e40SEvgeny Pinchuk .show = mem_show, 3305b5c4e40SEvgeny Pinchuk }; 3315b5c4e40SEvgeny Pinchuk 3325b5c4e40SEvgeny Pinchuk static struct kobj_type mem_type = { 3335108d768SYong Zhao .release = kfd_topology_kobj_release, 3345b5c4e40SEvgeny Pinchuk .sysfs_ops = &mem_ops, 3355b5c4e40SEvgeny Pinchuk }; 3365b5c4e40SEvgeny Pinchuk 3375b5c4e40SEvgeny Pinchuk static ssize_t kfd_cache_show(struct kobject *kobj, struct attribute *attr, 3385b5c4e40SEvgeny Pinchuk char *buffer) 3395b5c4e40SEvgeny Pinchuk { 34083a13ef5SFelix Kuehling int offs = 0; 341bc0c75a3SHarish Kasiviswanathan uint32_t i, j; 3425b5c4e40SEvgeny Pinchuk struct kfd_cache_properties *cache; 3435b5c4e40SEvgeny Pinchuk 3445b5c4e40SEvgeny Pinchuk /* Making sure that the buffer is an empty string */ 3455b5c4e40SEvgeny Pinchuk buffer[0] = 0; 3465b5c4e40SEvgeny Pinchuk 3475b5c4e40SEvgeny Pinchuk cache = container_of(attr, struct kfd_cache_properties, attr); 3486b855f7bSHarish Kasiviswanathan if (cache->gpu && kfd_devcgroup_check_permission(cache->gpu)) 3496b855f7bSHarish Kasiviswanathan return -EPERM; 35083a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "processor_id_low", 3515b5c4e40SEvgeny Pinchuk cache->processor_id_low); 35283a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "level", cache->cache_level); 35383a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "size", cache->cache_size); 35483a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "cache_line_size", 35583a13ef5SFelix Kuehling cache->cacheline_size); 35683a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "cache_lines_per_tag", 3575b5c4e40SEvgeny Pinchuk cache->cachelines_per_tag); 35883a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "association", cache->cache_assoc); 35983a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "latency", cache->cache_latency); 36083a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "type", cache->cache_type); 36183a13ef5SFelix Kuehling offs += snprintf(buffer+offs, PAGE_SIZE-offs, "sibling_map "); 362bc0c75a3SHarish Kasiviswanathan for (i = 0; i < CRAT_SIBLINGMAP_SIZE; i++) 36383a13ef5SFelix Kuehling for (j = 0; j < sizeof(cache->sibling_map[0])*8; j++) 364bc0c75a3SHarish Kasiviswanathan /* Check each bit */ 36583a13ef5SFelix Kuehling offs += snprintf(buffer+offs, PAGE_SIZE-offs, "%d,", 36683a13ef5SFelix Kuehling (cache->sibling_map[i] >> j) & 1); 36783a13ef5SFelix Kuehling 368bc0c75a3SHarish Kasiviswanathan /* Replace the last "," with end of line */ 36983a13ef5SFelix Kuehling buffer[offs-1] = '\n'; 37083a13ef5SFelix Kuehling return offs; 3715b5c4e40SEvgeny Pinchuk } 3725b5c4e40SEvgeny Pinchuk 3735b5c4e40SEvgeny Pinchuk static const struct sysfs_ops cache_ops = { 3745b5c4e40SEvgeny Pinchuk .show = kfd_cache_show, 3755b5c4e40SEvgeny Pinchuk }; 3765b5c4e40SEvgeny Pinchuk 3775b5c4e40SEvgeny Pinchuk static struct kobj_type cache_type = { 3785108d768SYong Zhao .release = kfd_topology_kobj_release, 3795b5c4e40SEvgeny Pinchuk .sysfs_ops = &cache_ops, 3805b5c4e40SEvgeny Pinchuk }; 3815b5c4e40SEvgeny Pinchuk 382f4757347SAmber Lin /****** Sysfs of Performance Counters ******/ 383f4757347SAmber Lin 384f4757347SAmber Lin struct kfd_perf_attr { 385f4757347SAmber Lin struct kobj_attribute attr; 386f4757347SAmber Lin uint32_t data; 387f4757347SAmber Lin }; 388f4757347SAmber Lin 389f4757347SAmber Lin static ssize_t perf_show(struct kobject *kobj, struct kobj_attribute *attrs, 390f4757347SAmber Lin char *buf) 391f4757347SAmber Lin { 39283a13ef5SFelix Kuehling int offs = 0; 393f4757347SAmber Lin struct kfd_perf_attr *attr; 394f4757347SAmber Lin 395f4757347SAmber Lin buf[0] = 0; 396f4757347SAmber Lin attr = container_of(attrs, struct kfd_perf_attr, attr); 397f4757347SAmber Lin if (!attr->data) /* invalid data for PMC */ 398f4757347SAmber Lin return 0; 399f4757347SAmber Lin else 40083a13ef5SFelix Kuehling return sysfs_show_32bit_val(buf, offs, attr->data); 401f4757347SAmber Lin } 402f4757347SAmber Lin 403f4757347SAmber Lin #define KFD_PERF_DESC(_name, _data) \ 404f4757347SAmber Lin { \ 405f4757347SAmber Lin .attr = __ATTR(_name, 0444, perf_show, NULL), \ 406f4757347SAmber Lin .data = _data, \ 407f4757347SAmber Lin } 408f4757347SAmber Lin 409f4757347SAmber Lin static struct kfd_perf_attr perf_attr_iommu[] = { 410f4757347SAmber Lin KFD_PERF_DESC(max_concurrent, 0), 411f4757347SAmber Lin KFD_PERF_DESC(num_counters, 0), 412f4757347SAmber Lin KFD_PERF_DESC(counter_ids, 0), 413f4757347SAmber Lin }; 414f4757347SAmber Lin /****************************************/ 415f4757347SAmber Lin 4165b5c4e40SEvgeny Pinchuk static ssize_t node_show(struct kobject *kobj, struct attribute *attr, 4175b5c4e40SEvgeny Pinchuk char *buffer) 4185b5c4e40SEvgeny Pinchuk { 41983a13ef5SFelix Kuehling int offs = 0; 4205b5c4e40SEvgeny Pinchuk struct kfd_topology_device *dev; 421f7c826adSAlexey Skidanov uint32_t log_max_watch_addr; 4225b5c4e40SEvgeny Pinchuk 4235b5c4e40SEvgeny Pinchuk /* Making sure that the buffer is an empty string */ 4245b5c4e40SEvgeny Pinchuk buffer[0] = 0; 4255b5c4e40SEvgeny Pinchuk 4265b5c4e40SEvgeny Pinchuk if (strcmp(attr->name, "gpu_id") == 0) { 4275b5c4e40SEvgeny Pinchuk dev = container_of(attr, struct kfd_topology_device, 4285b5c4e40SEvgeny Pinchuk attr_gpuid); 4296b855f7bSHarish Kasiviswanathan if (dev->gpu && kfd_devcgroup_check_permission(dev->gpu)) 4306b855f7bSHarish Kasiviswanathan return -EPERM; 43183a13ef5SFelix Kuehling return sysfs_show_32bit_val(buffer, offs, dev->gpu_id); 432f7c826adSAlexey Skidanov } 433f7c826adSAlexey Skidanov 434f7c826adSAlexey Skidanov if (strcmp(attr->name, "name") == 0) { 4355b5c4e40SEvgeny Pinchuk dev = container_of(attr, struct kfd_topology_device, 4365b5c4e40SEvgeny Pinchuk attr_name); 437c181159aSYong Zhao 4386b855f7bSHarish Kasiviswanathan if (dev->gpu && kfd_devcgroup_check_permission(dev->gpu)) 4396b855f7bSHarish Kasiviswanathan return -EPERM; 44083a13ef5SFelix Kuehling return sysfs_show_str_val(buffer, offs, dev->node_props.name); 441f7c826adSAlexey Skidanov } 442f7c826adSAlexey Skidanov 4435b5c4e40SEvgeny Pinchuk dev = container_of(attr, struct kfd_topology_device, 4445b5c4e40SEvgeny Pinchuk attr_props); 4456b855f7bSHarish Kasiviswanathan if (dev->gpu && kfd_devcgroup_check_permission(dev->gpu)) 4466b855f7bSHarish Kasiviswanathan return -EPERM; 44783a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "cpu_cores_count", 4485b5c4e40SEvgeny Pinchuk dev->node_props.cpu_cores_count); 44983a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "simd_count", 4506127896fSHuang Rui dev->gpu ? dev->node_props.simd_count : 0); 45183a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "mem_banks_count", 4525b5c4e40SEvgeny Pinchuk dev->node_props.mem_banks_count); 45383a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "caches_count", 4545b5c4e40SEvgeny Pinchuk dev->node_props.caches_count); 45583a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "io_links_count", 4565b5c4e40SEvgeny Pinchuk dev->node_props.io_links_count); 45783a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "cpu_core_id_base", 4585b5c4e40SEvgeny Pinchuk dev->node_props.cpu_core_id_base); 45983a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "simd_id_base", 4605b5c4e40SEvgeny Pinchuk dev->node_props.simd_id_base); 46183a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "max_waves_per_simd", 4625b5c4e40SEvgeny Pinchuk dev->node_props.max_waves_per_simd); 46383a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "lds_size_in_kb", 4645b5c4e40SEvgeny Pinchuk dev->node_props.lds_size_in_kb); 46583a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "gds_size_in_kb", 4665b5c4e40SEvgeny Pinchuk dev->node_props.gds_size_in_kb); 46783a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "num_gws", 46829e76462SOak Zeng dev->node_props.num_gws); 46983a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "wave_front_size", 4705b5c4e40SEvgeny Pinchuk dev->node_props.wave_front_size); 47183a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "array_count", 4725b5c4e40SEvgeny Pinchuk dev->node_props.array_count); 47383a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "simd_arrays_per_engine", 4745b5c4e40SEvgeny Pinchuk dev->node_props.simd_arrays_per_engine); 47583a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "cu_per_simd_array", 4765b5c4e40SEvgeny Pinchuk dev->node_props.cu_per_simd_array); 47783a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "simd_per_cu", 4785b5c4e40SEvgeny Pinchuk dev->node_props.simd_per_cu); 47983a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "max_slots_scratch_cu", 4805b5c4e40SEvgeny Pinchuk dev->node_props.max_slots_scratch_cu); 4819d6fa9c7SGraham Sider sysfs_show_32bit_prop(buffer, offs, "gfx_target_version", 4829d6fa9c7SGraham Sider dev->node_props.gfx_target_version); 48383a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "vendor_id", 4845b5c4e40SEvgeny Pinchuk dev->node_props.vendor_id); 48583a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "device_id", 4865b5c4e40SEvgeny Pinchuk dev->node_props.device_id); 48783a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "location_id", 4885b5c4e40SEvgeny Pinchuk dev->node_props.location_id); 48983a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "domain", 4903e58e95aSOri Messinger dev->node_props.domain); 49183a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "drm_render_minor", 4927c9b7171SOak Zeng dev->node_props.drm_render_minor); 49383a13ef5SFelix Kuehling sysfs_show_64bit_prop(buffer, offs, "hive_id", 4940c1690e3SShaoyun Liu dev->node_props.hive_id); 49583a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "num_sdma_engines", 49614568cf6SOak Zeng dev->node_props.num_sdma_engines); 49783a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "num_sdma_xgmi_engines", 49814568cf6SOak Zeng dev->node_props.num_sdma_xgmi_engines); 49983a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "num_sdma_queues_per_engine", 500bb71c74dSHuang Rui dev->node_props.num_sdma_queues_per_engine); 50183a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "num_cp_queues", 502f4feb9faSHuang Rui dev->node_props.num_cp_queues); 5035b5c4e40SEvgeny Pinchuk 5045b5c4e40SEvgeny Pinchuk if (dev->gpu) { 505f7c826adSAlexey Skidanov log_max_watch_addr = 506f7c826adSAlexey Skidanov __ilog2_u32(dev->gpu->device_info->num_of_watch_points); 507f7c826adSAlexey Skidanov 508f7c826adSAlexey Skidanov if (log_max_watch_addr) { 509f7c826adSAlexey Skidanov dev->node_props.capability |= 510f7c826adSAlexey Skidanov HSA_CAP_WATCH_POINTS_SUPPORTED; 511f7c826adSAlexey Skidanov 512f7c826adSAlexey Skidanov dev->node_props.capability |= 513f7c826adSAlexey Skidanov ((log_max_watch_addr << 514f7c826adSAlexey Skidanov HSA_CAP_WATCH_POINTS_TOTALBITS_SHIFT) & 515f7c826adSAlexey Skidanov HSA_CAP_WATCH_POINTS_TOTALBITS_MASK); 516f7c826adSAlexey Skidanov } 517f7c826adSAlexey Skidanov 5187eb0502aSGraham Sider if (dev->gpu->adev->asic_type == CHIP_TONGA) 519413e85d5SBen Goz dev->node_props.capability |= 520413e85d5SBen Goz HSA_CAP_AQL_QUEUE_DOUBLE_MAP; 521413e85d5SBen Goz 52283a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "max_engine_clk_fcompute", 5233a87177eSHarish Kasiviswanathan dev->node_props.max_engine_clk_fcompute); 52442e08c78SOded Gabbay 52583a13ef5SFelix Kuehling sysfs_show_64bit_prop(buffer, offs, "local_mem_size", 0ULL); 526f1386fbcSOded Gabbay 52783a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "fw_version", 5285ade6c9cSFelix Kuehling dev->gpu->mec_fw_version); 52983a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "capability", 530826f5de8SAlexey Skidanov dev->node_props.capability); 53183a13ef5SFelix Kuehling sysfs_show_32bit_prop(buffer, offs, "sdma_fw_version", 5325ade6c9cSFelix Kuehling dev->gpu->sdma_fw_version); 53311964258SKent Russell sysfs_show_64bit_prop(buffer, offs, "unique_id", 53402274fc0SGraham Sider dev->gpu->adev->unique_id); 53511964258SKent Russell 5365b5c4e40SEvgeny Pinchuk } 5375b5c4e40SEvgeny Pinchuk 53883a13ef5SFelix Kuehling return sysfs_show_32bit_prop(buffer, offs, "max_engine_clk_ccompute", 5395b5c4e40SEvgeny Pinchuk cpufreq_quick_get_max(0)/1000); 5405b5c4e40SEvgeny Pinchuk } 5415b5c4e40SEvgeny Pinchuk 5425b5c4e40SEvgeny Pinchuk static const struct sysfs_ops node_ops = { 5435b5c4e40SEvgeny Pinchuk .show = node_show, 5445b5c4e40SEvgeny Pinchuk }; 5455b5c4e40SEvgeny Pinchuk 5465b5c4e40SEvgeny Pinchuk static struct kobj_type node_type = { 5475108d768SYong Zhao .release = kfd_topology_kobj_release, 5485b5c4e40SEvgeny Pinchuk .sysfs_ops = &node_ops, 5495b5c4e40SEvgeny Pinchuk }; 5505b5c4e40SEvgeny Pinchuk 5515b5c4e40SEvgeny Pinchuk static void kfd_remove_sysfs_file(struct kobject *kobj, struct attribute *attr) 5525b5c4e40SEvgeny Pinchuk { 5535b5c4e40SEvgeny Pinchuk sysfs_remove_file(kobj, attr); 5545b5c4e40SEvgeny Pinchuk kobject_del(kobj); 5555b5c4e40SEvgeny Pinchuk kobject_put(kobj); 5565b5c4e40SEvgeny Pinchuk } 5575b5c4e40SEvgeny Pinchuk 5585b5c4e40SEvgeny Pinchuk static void kfd_remove_sysfs_node_entry(struct kfd_topology_device *dev) 5595b5c4e40SEvgeny Pinchuk { 5605b5c4e40SEvgeny Pinchuk struct kfd_iolink_properties *iolink; 5615b5c4e40SEvgeny Pinchuk struct kfd_cache_properties *cache; 5625b5c4e40SEvgeny Pinchuk struct kfd_mem_properties *mem; 563f4757347SAmber Lin struct kfd_perf_properties *perf; 5645b5c4e40SEvgeny Pinchuk 5655b5c4e40SEvgeny Pinchuk if (dev->kobj_iolink) { 5665b5c4e40SEvgeny Pinchuk list_for_each_entry(iolink, &dev->io_link_props, list) 5675b5c4e40SEvgeny Pinchuk if (iolink->kobj) { 5685b5c4e40SEvgeny Pinchuk kfd_remove_sysfs_file(iolink->kobj, 5695b5c4e40SEvgeny Pinchuk &iolink->attr); 57016b9201cSOded Gabbay iolink->kobj = NULL; 5715b5c4e40SEvgeny Pinchuk } 5725b5c4e40SEvgeny Pinchuk kobject_del(dev->kobj_iolink); 5735b5c4e40SEvgeny Pinchuk kobject_put(dev->kobj_iolink); 57416b9201cSOded Gabbay dev->kobj_iolink = NULL; 5755b5c4e40SEvgeny Pinchuk } 5765b5c4e40SEvgeny Pinchuk 5775b5c4e40SEvgeny Pinchuk if (dev->kobj_cache) { 5785b5c4e40SEvgeny Pinchuk list_for_each_entry(cache, &dev->cache_props, list) 5795b5c4e40SEvgeny Pinchuk if (cache->kobj) { 5805b5c4e40SEvgeny Pinchuk kfd_remove_sysfs_file(cache->kobj, 5815b5c4e40SEvgeny Pinchuk &cache->attr); 58216b9201cSOded Gabbay cache->kobj = NULL; 5835b5c4e40SEvgeny Pinchuk } 5845b5c4e40SEvgeny Pinchuk kobject_del(dev->kobj_cache); 5855b5c4e40SEvgeny Pinchuk kobject_put(dev->kobj_cache); 58616b9201cSOded Gabbay dev->kobj_cache = NULL; 5875b5c4e40SEvgeny Pinchuk } 5885b5c4e40SEvgeny Pinchuk 5895b5c4e40SEvgeny Pinchuk if (dev->kobj_mem) { 5905b5c4e40SEvgeny Pinchuk list_for_each_entry(mem, &dev->mem_props, list) 5915b5c4e40SEvgeny Pinchuk if (mem->kobj) { 5925b5c4e40SEvgeny Pinchuk kfd_remove_sysfs_file(mem->kobj, &mem->attr); 59316b9201cSOded Gabbay mem->kobj = NULL; 5945b5c4e40SEvgeny Pinchuk } 5955b5c4e40SEvgeny Pinchuk kobject_del(dev->kobj_mem); 5965b5c4e40SEvgeny Pinchuk kobject_put(dev->kobj_mem); 59716b9201cSOded Gabbay dev->kobj_mem = NULL; 5985b5c4e40SEvgeny Pinchuk } 5995b5c4e40SEvgeny Pinchuk 600f4757347SAmber Lin if (dev->kobj_perf) { 601f4757347SAmber Lin list_for_each_entry(perf, &dev->perf_props, list) { 602f4757347SAmber Lin kfree(perf->attr_group); 603f4757347SAmber Lin perf->attr_group = NULL; 604f4757347SAmber Lin } 605f4757347SAmber Lin kobject_del(dev->kobj_perf); 606f4757347SAmber Lin kobject_put(dev->kobj_perf); 607f4757347SAmber Lin dev->kobj_perf = NULL; 608f4757347SAmber Lin } 609f4757347SAmber Lin 6105b5c4e40SEvgeny Pinchuk if (dev->kobj_node) { 6115b5c4e40SEvgeny Pinchuk sysfs_remove_file(dev->kobj_node, &dev->attr_gpuid); 6125b5c4e40SEvgeny Pinchuk sysfs_remove_file(dev->kobj_node, &dev->attr_name); 6135b5c4e40SEvgeny Pinchuk sysfs_remove_file(dev->kobj_node, &dev->attr_props); 6145b5c4e40SEvgeny Pinchuk kobject_del(dev->kobj_node); 6155b5c4e40SEvgeny Pinchuk kobject_put(dev->kobj_node); 61616b9201cSOded Gabbay dev->kobj_node = NULL; 6175b5c4e40SEvgeny Pinchuk } 6185b5c4e40SEvgeny Pinchuk } 6195b5c4e40SEvgeny Pinchuk 6205b5c4e40SEvgeny Pinchuk static int kfd_build_sysfs_node_entry(struct kfd_topology_device *dev, 6215b5c4e40SEvgeny Pinchuk uint32_t id) 6225b5c4e40SEvgeny Pinchuk { 6235b5c4e40SEvgeny Pinchuk struct kfd_iolink_properties *iolink; 6245b5c4e40SEvgeny Pinchuk struct kfd_cache_properties *cache; 6255b5c4e40SEvgeny Pinchuk struct kfd_mem_properties *mem; 626f4757347SAmber Lin struct kfd_perf_properties *perf; 6275b5c4e40SEvgeny Pinchuk int ret; 628f4757347SAmber Lin uint32_t i, num_attrs; 629f4757347SAmber Lin struct attribute **attrs; 6305b5c4e40SEvgeny Pinchuk 63132fa8219SFelix Kuehling if (WARN_ON(dev->kobj_node)) 63232fa8219SFelix Kuehling return -EEXIST; 63332fa8219SFelix Kuehling 6345b5c4e40SEvgeny Pinchuk /* 6355b5c4e40SEvgeny Pinchuk * Creating the sysfs folders 6365b5c4e40SEvgeny Pinchuk */ 6375b5c4e40SEvgeny Pinchuk dev->kobj_node = kfd_alloc_struct(dev->kobj_node); 6385b5c4e40SEvgeny Pinchuk if (!dev->kobj_node) 6395b5c4e40SEvgeny Pinchuk return -ENOMEM; 6405b5c4e40SEvgeny Pinchuk 6415b5c4e40SEvgeny Pinchuk ret = kobject_init_and_add(dev->kobj_node, &node_type, 6425b5c4e40SEvgeny Pinchuk sys_props.kobj_nodes, "%d", id); 64320eca012SQiushi Wu if (ret < 0) { 64420eca012SQiushi Wu kobject_put(dev->kobj_node); 6455b5c4e40SEvgeny Pinchuk return ret; 64620eca012SQiushi Wu } 6475b5c4e40SEvgeny Pinchuk 6485b5c4e40SEvgeny Pinchuk dev->kobj_mem = kobject_create_and_add("mem_banks", dev->kobj_node); 6495b5c4e40SEvgeny Pinchuk if (!dev->kobj_mem) 6505b5c4e40SEvgeny Pinchuk return -ENOMEM; 6515b5c4e40SEvgeny Pinchuk 6525b5c4e40SEvgeny Pinchuk dev->kobj_cache = kobject_create_and_add("caches", dev->kobj_node); 6535b5c4e40SEvgeny Pinchuk if (!dev->kobj_cache) 6545b5c4e40SEvgeny Pinchuk return -ENOMEM; 6555b5c4e40SEvgeny Pinchuk 6565b5c4e40SEvgeny Pinchuk dev->kobj_iolink = kobject_create_and_add("io_links", dev->kobj_node); 6575b5c4e40SEvgeny Pinchuk if (!dev->kobj_iolink) 6585b5c4e40SEvgeny Pinchuk return -ENOMEM; 6595b5c4e40SEvgeny Pinchuk 660f4757347SAmber Lin dev->kobj_perf = kobject_create_and_add("perf", dev->kobj_node); 661f4757347SAmber Lin if (!dev->kobj_perf) 662f4757347SAmber Lin return -ENOMEM; 663f4757347SAmber Lin 6645b5c4e40SEvgeny Pinchuk /* 6655b5c4e40SEvgeny Pinchuk * Creating sysfs files for node properties 6665b5c4e40SEvgeny Pinchuk */ 6675b5c4e40SEvgeny Pinchuk dev->attr_gpuid.name = "gpu_id"; 6685b5c4e40SEvgeny Pinchuk dev->attr_gpuid.mode = KFD_SYSFS_FILE_MODE; 6695b5c4e40SEvgeny Pinchuk sysfs_attr_init(&dev->attr_gpuid); 6705b5c4e40SEvgeny Pinchuk dev->attr_name.name = "name"; 6715b5c4e40SEvgeny Pinchuk dev->attr_name.mode = KFD_SYSFS_FILE_MODE; 6725b5c4e40SEvgeny Pinchuk sysfs_attr_init(&dev->attr_name); 6735b5c4e40SEvgeny Pinchuk dev->attr_props.name = "properties"; 6745b5c4e40SEvgeny Pinchuk dev->attr_props.mode = KFD_SYSFS_FILE_MODE; 6755b5c4e40SEvgeny Pinchuk sysfs_attr_init(&dev->attr_props); 6765b5c4e40SEvgeny Pinchuk ret = sysfs_create_file(dev->kobj_node, &dev->attr_gpuid); 6775b5c4e40SEvgeny Pinchuk if (ret < 0) 6785b5c4e40SEvgeny Pinchuk return ret; 6795b5c4e40SEvgeny Pinchuk ret = sysfs_create_file(dev->kobj_node, &dev->attr_name); 6805b5c4e40SEvgeny Pinchuk if (ret < 0) 6815b5c4e40SEvgeny Pinchuk return ret; 6825b5c4e40SEvgeny Pinchuk ret = sysfs_create_file(dev->kobj_node, &dev->attr_props); 6835b5c4e40SEvgeny Pinchuk if (ret < 0) 6845b5c4e40SEvgeny Pinchuk return ret; 6855b5c4e40SEvgeny Pinchuk 6865b5c4e40SEvgeny Pinchuk i = 0; 6875b5c4e40SEvgeny Pinchuk list_for_each_entry(mem, &dev->mem_props, list) { 6885b5c4e40SEvgeny Pinchuk mem->kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL); 6895b5c4e40SEvgeny Pinchuk if (!mem->kobj) 6905b5c4e40SEvgeny Pinchuk return -ENOMEM; 6915b5c4e40SEvgeny Pinchuk ret = kobject_init_and_add(mem->kobj, &mem_type, 6925b5c4e40SEvgeny Pinchuk dev->kobj_mem, "%d", i); 69320eca012SQiushi Wu if (ret < 0) { 69420eca012SQiushi Wu kobject_put(mem->kobj); 6955b5c4e40SEvgeny Pinchuk return ret; 69620eca012SQiushi Wu } 6975b5c4e40SEvgeny Pinchuk 6985b5c4e40SEvgeny Pinchuk mem->attr.name = "properties"; 6995b5c4e40SEvgeny Pinchuk mem->attr.mode = KFD_SYSFS_FILE_MODE; 7005b5c4e40SEvgeny Pinchuk sysfs_attr_init(&mem->attr); 7015b5c4e40SEvgeny Pinchuk ret = sysfs_create_file(mem->kobj, &mem->attr); 7025b5c4e40SEvgeny Pinchuk if (ret < 0) 7035b5c4e40SEvgeny Pinchuk return ret; 7045b5c4e40SEvgeny Pinchuk i++; 7055b5c4e40SEvgeny Pinchuk } 7065b5c4e40SEvgeny Pinchuk 7075b5c4e40SEvgeny Pinchuk i = 0; 7085b5c4e40SEvgeny Pinchuk list_for_each_entry(cache, &dev->cache_props, list) { 7095b5c4e40SEvgeny Pinchuk cache->kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL); 7105b5c4e40SEvgeny Pinchuk if (!cache->kobj) 7115b5c4e40SEvgeny Pinchuk return -ENOMEM; 7125b5c4e40SEvgeny Pinchuk ret = kobject_init_and_add(cache->kobj, &cache_type, 7135b5c4e40SEvgeny Pinchuk dev->kobj_cache, "%d", i); 71420eca012SQiushi Wu if (ret < 0) { 71520eca012SQiushi Wu kobject_put(cache->kobj); 7165b5c4e40SEvgeny Pinchuk return ret; 71720eca012SQiushi Wu } 7185b5c4e40SEvgeny Pinchuk 7195b5c4e40SEvgeny Pinchuk cache->attr.name = "properties"; 7205b5c4e40SEvgeny Pinchuk cache->attr.mode = KFD_SYSFS_FILE_MODE; 7215b5c4e40SEvgeny Pinchuk sysfs_attr_init(&cache->attr); 7225b5c4e40SEvgeny Pinchuk ret = sysfs_create_file(cache->kobj, &cache->attr); 7235b5c4e40SEvgeny Pinchuk if (ret < 0) 7245b5c4e40SEvgeny Pinchuk return ret; 7255b5c4e40SEvgeny Pinchuk i++; 7265b5c4e40SEvgeny Pinchuk } 7275b5c4e40SEvgeny Pinchuk 7285b5c4e40SEvgeny Pinchuk i = 0; 7295b5c4e40SEvgeny Pinchuk list_for_each_entry(iolink, &dev->io_link_props, list) { 7305b5c4e40SEvgeny Pinchuk iolink->kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL); 7315b5c4e40SEvgeny Pinchuk if (!iolink->kobj) 7325b5c4e40SEvgeny Pinchuk return -ENOMEM; 7335b5c4e40SEvgeny Pinchuk ret = kobject_init_and_add(iolink->kobj, &iolink_type, 7345b5c4e40SEvgeny Pinchuk dev->kobj_iolink, "%d", i); 73520eca012SQiushi Wu if (ret < 0) { 73620eca012SQiushi Wu kobject_put(iolink->kobj); 7375b5c4e40SEvgeny Pinchuk return ret; 73820eca012SQiushi Wu } 7395b5c4e40SEvgeny Pinchuk 7405b5c4e40SEvgeny Pinchuk iolink->attr.name = "properties"; 7415b5c4e40SEvgeny Pinchuk iolink->attr.mode = KFD_SYSFS_FILE_MODE; 7425b5c4e40SEvgeny Pinchuk sysfs_attr_init(&iolink->attr); 7435b5c4e40SEvgeny Pinchuk ret = sysfs_create_file(iolink->kobj, &iolink->attr); 7445b5c4e40SEvgeny Pinchuk if (ret < 0) 7455b5c4e40SEvgeny Pinchuk return ret; 7465b5c4e40SEvgeny Pinchuk i++; 7475b5c4e40SEvgeny Pinchuk } 7485b5c4e40SEvgeny Pinchuk 749f4757347SAmber Lin /* All hardware blocks have the same number of attributes. */ 7503f866f5fSGustavo A. R. Silva num_attrs = ARRAY_SIZE(perf_attr_iommu); 751f4757347SAmber Lin list_for_each_entry(perf, &dev->perf_props, list) { 752f4757347SAmber Lin perf->attr_group = kzalloc(sizeof(struct kfd_perf_attr) 753f4757347SAmber Lin * num_attrs + sizeof(struct attribute_group), 754f4757347SAmber Lin GFP_KERNEL); 755f4757347SAmber Lin if (!perf->attr_group) 756f4757347SAmber Lin return -ENOMEM; 757f4757347SAmber Lin 758f4757347SAmber Lin attrs = (struct attribute **)(perf->attr_group + 1); 759f4757347SAmber Lin if (!strcmp(perf->block_name, "iommu")) { 760f4757347SAmber Lin /* Information of IOMMU's num_counters and counter_ids is shown 761f4757347SAmber Lin * under /sys/bus/event_source/devices/amd_iommu. We don't 762f4757347SAmber Lin * duplicate here. 763f4757347SAmber Lin */ 764f4757347SAmber Lin perf_attr_iommu[0].data = perf->max_concurrent; 765f4757347SAmber Lin for (i = 0; i < num_attrs; i++) 766f4757347SAmber Lin attrs[i] = &perf_attr_iommu[i].attr.attr; 767f4757347SAmber Lin } 768f4757347SAmber Lin perf->attr_group->name = perf->block_name; 769f4757347SAmber Lin perf->attr_group->attrs = attrs; 770f4757347SAmber Lin ret = sysfs_create_group(dev->kobj_perf, perf->attr_group); 771f4757347SAmber Lin if (ret < 0) 772f4757347SAmber Lin return ret; 773f4757347SAmber Lin } 774f4757347SAmber Lin 7755b5c4e40SEvgeny Pinchuk return 0; 7765b5c4e40SEvgeny Pinchuk } 7775b5c4e40SEvgeny Pinchuk 7783a87177eSHarish Kasiviswanathan /* Called with write topology lock acquired */ 7795b5c4e40SEvgeny Pinchuk static int kfd_build_sysfs_node_tree(void) 7805b5c4e40SEvgeny Pinchuk { 7815b5c4e40SEvgeny Pinchuk struct kfd_topology_device *dev; 7825b5c4e40SEvgeny Pinchuk int ret; 7835b5c4e40SEvgeny Pinchuk uint32_t i = 0; 7845b5c4e40SEvgeny Pinchuk 7855b5c4e40SEvgeny Pinchuk list_for_each_entry(dev, &topology_device_list, list) { 7868dfead6cSBen Goz ret = kfd_build_sysfs_node_entry(dev, i); 7875b5c4e40SEvgeny Pinchuk if (ret < 0) 7885b5c4e40SEvgeny Pinchuk return ret; 7895b5c4e40SEvgeny Pinchuk i++; 7905b5c4e40SEvgeny Pinchuk } 7915b5c4e40SEvgeny Pinchuk 7925b5c4e40SEvgeny Pinchuk return 0; 7935b5c4e40SEvgeny Pinchuk } 7945b5c4e40SEvgeny Pinchuk 7953a87177eSHarish Kasiviswanathan /* Called with write topology lock acquired */ 7965b5c4e40SEvgeny Pinchuk static void kfd_remove_sysfs_node_tree(void) 7975b5c4e40SEvgeny Pinchuk { 7985b5c4e40SEvgeny Pinchuk struct kfd_topology_device *dev; 7995b5c4e40SEvgeny Pinchuk 8005b5c4e40SEvgeny Pinchuk list_for_each_entry(dev, &topology_device_list, list) 8015b5c4e40SEvgeny Pinchuk kfd_remove_sysfs_node_entry(dev); 8025b5c4e40SEvgeny Pinchuk } 8035b5c4e40SEvgeny Pinchuk 8045b5c4e40SEvgeny Pinchuk static int kfd_topology_update_sysfs(void) 8055b5c4e40SEvgeny Pinchuk { 8065b5c4e40SEvgeny Pinchuk int ret; 8075b5c4e40SEvgeny Pinchuk 8084eacc26bSKent Russell if (!sys_props.kobj_topology) { 8095b5c4e40SEvgeny Pinchuk sys_props.kobj_topology = 8105b5c4e40SEvgeny Pinchuk kfd_alloc_struct(sys_props.kobj_topology); 8115b5c4e40SEvgeny Pinchuk if (!sys_props.kobj_topology) 8125b5c4e40SEvgeny Pinchuk return -ENOMEM; 8135b5c4e40SEvgeny Pinchuk 8145b5c4e40SEvgeny Pinchuk ret = kobject_init_and_add(sys_props.kobj_topology, 8155b5c4e40SEvgeny Pinchuk &sysprops_type, &kfd_device->kobj, 8165b5c4e40SEvgeny Pinchuk "topology"); 81720eca012SQiushi Wu if (ret < 0) { 81820eca012SQiushi Wu kobject_put(sys_props.kobj_topology); 8195b5c4e40SEvgeny Pinchuk return ret; 82020eca012SQiushi Wu } 8215b5c4e40SEvgeny Pinchuk 8225b5c4e40SEvgeny Pinchuk sys_props.kobj_nodes = kobject_create_and_add("nodes", 8235b5c4e40SEvgeny Pinchuk sys_props.kobj_topology); 8245b5c4e40SEvgeny Pinchuk if (!sys_props.kobj_nodes) 8255b5c4e40SEvgeny Pinchuk return -ENOMEM; 8265b5c4e40SEvgeny Pinchuk 8275b5c4e40SEvgeny Pinchuk sys_props.attr_genid.name = "generation_id"; 8285b5c4e40SEvgeny Pinchuk sys_props.attr_genid.mode = KFD_SYSFS_FILE_MODE; 8295b5c4e40SEvgeny Pinchuk sysfs_attr_init(&sys_props.attr_genid); 8305b5c4e40SEvgeny Pinchuk ret = sysfs_create_file(sys_props.kobj_topology, 8315b5c4e40SEvgeny Pinchuk &sys_props.attr_genid); 8325b5c4e40SEvgeny Pinchuk if (ret < 0) 8335b5c4e40SEvgeny Pinchuk return ret; 8345b5c4e40SEvgeny Pinchuk 8355b5c4e40SEvgeny Pinchuk sys_props.attr_props.name = "system_properties"; 8365b5c4e40SEvgeny Pinchuk sys_props.attr_props.mode = KFD_SYSFS_FILE_MODE; 8375b5c4e40SEvgeny Pinchuk sysfs_attr_init(&sys_props.attr_props); 8385b5c4e40SEvgeny Pinchuk ret = sysfs_create_file(sys_props.kobj_topology, 8395b5c4e40SEvgeny Pinchuk &sys_props.attr_props); 8405b5c4e40SEvgeny Pinchuk if (ret < 0) 8415b5c4e40SEvgeny Pinchuk return ret; 8425b5c4e40SEvgeny Pinchuk } 8435b5c4e40SEvgeny Pinchuk 8445b5c4e40SEvgeny Pinchuk kfd_remove_sysfs_node_tree(); 8455b5c4e40SEvgeny Pinchuk 8465b5c4e40SEvgeny Pinchuk return kfd_build_sysfs_node_tree(); 8475b5c4e40SEvgeny Pinchuk } 8485b5c4e40SEvgeny Pinchuk 8495b5c4e40SEvgeny Pinchuk static void kfd_topology_release_sysfs(void) 8505b5c4e40SEvgeny Pinchuk { 8515b5c4e40SEvgeny Pinchuk kfd_remove_sysfs_node_tree(); 8525b5c4e40SEvgeny Pinchuk if (sys_props.kobj_topology) { 8535b5c4e40SEvgeny Pinchuk sysfs_remove_file(sys_props.kobj_topology, 8545b5c4e40SEvgeny Pinchuk &sys_props.attr_genid); 8555b5c4e40SEvgeny Pinchuk sysfs_remove_file(sys_props.kobj_topology, 8565b5c4e40SEvgeny Pinchuk &sys_props.attr_props); 8575b5c4e40SEvgeny Pinchuk if (sys_props.kobj_nodes) { 8585b5c4e40SEvgeny Pinchuk kobject_del(sys_props.kobj_nodes); 8595b5c4e40SEvgeny Pinchuk kobject_put(sys_props.kobj_nodes); 86016b9201cSOded Gabbay sys_props.kobj_nodes = NULL; 8615b5c4e40SEvgeny Pinchuk } 8625b5c4e40SEvgeny Pinchuk kobject_del(sys_props.kobj_topology); 8635b5c4e40SEvgeny Pinchuk kobject_put(sys_props.kobj_topology); 86416b9201cSOded Gabbay sys_props.kobj_topology = NULL; 8655b5c4e40SEvgeny Pinchuk } 8665b5c4e40SEvgeny Pinchuk } 8675b5c4e40SEvgeny Pinchuk 8684f449311SHarish Kasiviswanathan /* Called with write topology_lock acquired */ 8694f449311SHarish Kasiviswanathan static void kfd_topology_update_device_list(struct list_head *temp_list, 8704f449311SHarish Kasiviswanathan struct list_head *master_list) 8714f449311SHarish Kasiviswanathan { 8724f449311SHarish Kasiviswanathan while (!list_empty(temp_list)) { 8734f449311SHarish Kasiviswanathan list_move_tail(temp_list->next, master_list); 8744f449311SHarish Kasiviswanathan sys_props.num_devices++; 8754f449311SHarish Kasiviswanathan } 8764f449311SHarish Kasiviswanathan } 8774f449311SHarish Kasiviswanathan 878520b8fb7SFelix Kuehling static void kfd_debug_print_topology(void) 879520b8fb7SFelix Kuehling { 880520b8fb7SFelix Kuehling struct kfd_topology_device *dev; 881520b8fb7SFelix Kuehling 882520b8fb7SFelix Kuehling down_read(&topology_lock); 883520b8fb7SFelix Kuehling 884520b8fb7SFelix Kuehling dev = list_last_entry(&topology_device_list, 885520b8fb7SFelix Kuehling struct kfd_topology_device, list); 886520b8fb7SFelix Kuehling if (dev) { 887520b8fb7SFelix Kuehling if (dev->node_props.cpu_cores_count && 888520b8fb7SFelix Kuehling dev->node_props.simd_count) { 889520b8fb7SFelix Kuehling pr_info("Topology: Add APU node [0x%0x:0x%0x]\n", 890520b8fb7SFelix Kuehling dev->node_props.device_id, 891520b8fb7SFelix Kuehling dev->node_props.vendor_id); 892520b8fb7SFelix Kuehling } else if (dev->node_props.cpu_cores_count) 893520b8fb7SFelix Kuehling pr_info("Topology: Add CPU node\n"); 894520b8fb7SFelix Kuehling else if (dev->node_props.simd_count) 895520b8fb7SFelix Kuehling pr_info("Topology: Add dGPU node [0x%0x:0x%0x]\n", 896520b8fb7SFelix Kuehling dev->node_props.device_id, 897520b8fb7SFelix Kuehling dev->node_props.vendor_id); 898520b8fb7SFelix Kuehling } 899520b8fb7SFelix Kuehling up_read(&topology_lock); 900520b8fb7SFelix Kuehling } 901520b8fb7SFelix Kuehling 902520b8fb7SFelix Kuehling /* Helper function for intializing platform_xx members of 903520b8fb7SFelix Kuehling * kfd_system_properties. Uses OEM info from the last CPU/APU node. 904520b8fb7SFelix Kuehling */ 905520b8fb7SFelix Kuehling static void kfd_update_system_properties(void) 906520b8fb7SFelix Kuehling { 907520b8fb7SFelix Kuehling struct kfd_topology_device *dev; 908520b8fb7SFelix Kuehling 909520b8fb7SFelix Kuehling down_read(&topology_lock); 910520b8fb7SFelix Kuehling dev = list_last_entry(&topology_device_list, 911520b8fb7SFelix Kuehling struct kfd_topology_device, list); 912520b8fb7SFelix Kuehling if (dev) { 913520b8fb7SFelix Kuehling sys_props.platform_id = 914520b8fb7SFelix Kuehling (*((uint64_t *)dev->oem_id)) & CRAT_OEMID_64BIT_MASK; 915520b8fb7SFelix Kuehling sys_props.platform_oem = *((uint64_t *)dev->oem_table_id); 916520b8fb7SFelix Kuehling sys_props.platform_rev = dev->oem_revision; 917520b8fb7SFelix Kuehling } 918520b8fb7SFelix Kuehling up_read(&topology_lock); 919520b8fb7SFelix Kuehling } 920520b8fb7SFelix Kuehling 921520b8fb7SFelix Kuehling static void find_system_memory(const struct dmi_header *dm, 922520b8fb7SFelix Kuehling void *private) 923520b8fb7SFelix Kuehling { 924520b8fb7SFelix Kuehling struct kfd_mem_properties *mem; 925520b8fb7SFelix Kuehling u16 mem_width, mem_clock; 926520b8fb7SFelix Kuehling struct kfd_topology_device *kdev = 927520b8fb7SFelix Kuehling (struct kfd_topology_device *)private; 928520b8fb7SFelix Kuehling const u8 *dmi_data = (const u8 *)(dm + 1); 929520b8fb7SFelix Kuehling 930520b8fb7SFelix Kuehling if (dm->type == DMI_ENTRY_MEM_DEVICE && dm->length >= 0x15) { 931520b8fb7SFelix Kuehling mem_width = (u16)(*(const u16 *)(dmi_data + 0x6)); 932520b8fb7SFelix Kuehling mem_clock = (u16)(*(const u16 *)(dmi_data + 0x11)); 933520b8fb7SFelix Kuehling list_for_each_entry(mem, &kdev->mem_props, list) { 934520b8fb7SFelix Kuehling if (mem_width != 0xFFFF && mem_width != 0) 935520b8fb7SFelix Kuehling mem->width = mem_width; 936520b8fb7SFelix Kuehling if (mem_clock != 0) 937520b8fb7SFelix Kuehling mem->mem_clk_max = mem_clock; 938520b8fb7SFelix Kuehling } 939520b8fb7SFelix Kuehling } 940520b8fb7SFelix Kuehling } 941f4757347SAmber Lin 942f4757347SAmber Lin /* 943f4757347SAmber Lin * Performance counters information is not part of CRAT but we would like to 944f4757347SAmber Lin * put them in the sysfs under topology directory for Thunk to get the data. 945f4757347SAmber Lin * This function is called before updating the sysfs. 946f4757347SAmber Lin */ 947f4757347SAmber Lin static int kfd_add_perf_to_topology(struct kfd_topology_device *kdev) 948f4757347SAmber Lin { 94964d1c3a4SFelix Kuehling /* These are the only counters supported so far */ 95064d1c3a4SFelix Kuehling return kfd_iommu_add_perf_counters(kdev); 951f4757347SAmber Lin } 952f4757347SAmber Lin 953520b8fb7SFelix Kuehling /* kfd_add_non_crat_information - Add information that is not currently 954520b8fb7SFelix Kuehling * defined in CRAT but is necessary for KFD topology 955520b8fb7SFelix Kuehling * @dev - topology device to which addition info is added 956520b8fb7SFelix Kuehling */ 957520b8fb7SFelix Kuehling static void kfd_add_non_crat_information(struct kfd_topology_device *kdev) 958520b8fb7SFelix Kuehling { 959520b8fb7SFelix Kuehling /* Check if CPU only node. */ 960520b8fb7SFelix Kuehling if (!kdev->gpu) { 961520b8fb7SFelix Kuehling /* Add system memory information */ 962520b8fb7SFelix Kuehling dmi_walk(find_system_memory, kdev); 963520b8fb7SFelix Kuehling } 964520b8fb7SFelix Kuehling /* TODO: For GPU node, rearrange code from kfd_topology_add_device */ 965520b8fb7SFelix Kuehling } 966520b8fb7SFelix Kuehling 967b441093eSHarish Kasiviswanathan /* kfd_is_acpi_crat_invalid - CRAT from ACPI is valid only for AMD APU devices. 968b441093eSHarish Kasiviswanathan * Ignore CRAT for all other devices. AMD APU is identified if both CPU 969b441093eSHarish Kasiviswanathan * and GPU cores are present. 970b441093eSHarish Kasiviswanathan * @device_list - topology device list created by parsing ACPI CRAT table. 971b441093eSHarish Kasiviswanathan * @return - TRUE if invalid, FALSE is valid. 972b441093eSHarish Kasiviswanathan */ 973b441093eSHarish Kasiviswanathan static bool kfd_is_acpi_crat_invalid(struct list_head *device_list) 974b441093eSHarish Kasiviswanathan { 975b441093eSHarish Kasiviswanathan struct kfd_topology_device *dev; 976b441093eSHarish Kasiviswanathan 977b441093eSHarish Kasiviswanathan list_for_each_entry(dev, device_list, list) { 978b441093eSHarish Kasiviswanathan if (dev->node_props.cpu_cores_count && 979b441093eSHarish Kasiviswanathan dev->node_props.simd_count) 980b441093eSHarish Kasiviswanathan return false; 981b441093eSHarish Kasiviswanathan } 982b441093eSHarish Kasiviswanathan pr_info("Ignoring ACPI CRAT on non-APU system\n"); 983b441093eSHarish Kasiviswanathan return true; 984b441093eSHarish Kasiviswanathan } 985b441093eSHarish Kasiviswanathan 9865b5c4e40SEvgeny Pinchuk int kfd_topology_init(void) 9875b5c4e40SEvgeny Pinchuk { 98816b9201cSOded Gabbay void *crat_image = NULL; 9895b5c4e40SEvgeny Pinchuk size_t image_size = 0; 9905b5c4e40SEvgeny Pinchuk int ret; 9914f449311SHarish Kasiviswanathan struct list_head temp_topology_device_list; 992520b8fb7SFelix Kuehling int cpu_only_node = 0; 993520b8fb7SFelix Kuehling struct kfd_topology_device *kdev; 994520b8fb7SFelix Kuehling int proximity_domain; 9955b5c4e40SEvgeny Pinchuk 9964f449311SHarish Kasiviswanathan /* topology_device_list - Master list of all topology devices 9974f449311SHarish Kasiviswanathan * temp_topology_device_list - temporary list created while parsing CRAT 9984f449311SHarish Kasiviswanathan * or VCRAT. Once parsing is complete the contents of list is moved to 9994f449311SHarish Kasiviswanathan * topology_device_list 10005b5c4e40SEvgeny Pinchuk */ 10014f449311SHarish Kasiviswanathan 10024f449311SHarish Kasiviswanathan /* Initialize the head for the both the lists */ 10035b5c4e40SEvgeny Pinchuk INIT_LIST_HEAD(&topology_device_list); 10044f449311SHarish Kasiviswanathan INIT_LIST_HEAD(&temp_topology_device_list); 10055b5c4e40SEvgeny Pinchuk init_rwsem(&topology_lock); 10065b5c4e40SEvgeny Pinchuk 10075b5c4e40SEvgeny Pinchuk memset(&sys_props, 0, sizeof(sys_props)); 10085b5c4e40SEvgeny Pinchuk 1009520b8fb7SFelix Kuehling /* Proximity domains in ACPI CRAT tables start counting at 1010520b8fb7SFelix Kuehling * 0. The same should be true for virtual CRAT tables created 1011520b8fb7SFelix Kuehling * at this stage. GPUs added later in kfd_topology_add_device 1012520b8fb7SFelix Kuehling * use a counter. 1013520b8fb7SFelix Kuehling */ 1014520b8fb7SFelix Kuehling proximity_domain = 0; 1015520b8fb7SFelix Kuehling 10165b5c4e40SEvgeny Pinchuk /* 1017520b8fb7SFelix Kuehling * Get the CRAT image from the ACPI. If ACPI doesn't have one 1018b441093eSHarish Kasiviswanathan * or if ACPI CRAT is invalid create a virtual CRAT. 1019520b8fb7SFelix Kuehling * NOTE: The current implementation expects all AMD APUs to have 1020520b8fb7SFelix Kuehling * CRAT. If no CRAT is available, it is assumed to be a CPU 10215b5c4e40SEvgeny Pinchuk */ 10228e05247dSHarish Kasiviswanathan ret = kfd_create_crat_image_acpi(&crat_image, &image_size); 10238e05247dSHarish Kasiviswanathan if (!ret) { 10244f449311SHarish Kasiviswanathan ret = kfd_parse_crat_table(crat_image, 1025520b8fb7SFelix Kuehling &temp_topology_device_list, 1026520b8fb7SFelix Kuehling proximity_domain); 1027b441093eSHarish Kasiviswanathan if (ret || 1028b441093eSHarish Kasiviswanathan kfd_is_acpi_crat_invalid(&temp_topology_device_list)) { 1029520b8fb7SFelix Kuehling kfd_release_topology_device_list( 1030520b8fb7SFelix Kuehling &temp_topology_device_list); 1031520b8fb7SFelix Kuehling kfd_destroy_crat_image(crat_image); 1032520b8fb7SFelix Kuehling crat_image = NULL; 1033520b8fb7SFelix Kuehling } 1034520b8fb7SFelix Kuehling } 1035520b8fb7SFelix Kuehling 1036520b8fb7SFelix Kuehling if (!crat_image) { 1037520b8fb7SFelix Kuehling ret = kfd_create_crat_image_virtual(&crat_image, &image_size, 1038520b8fb7SFelix Kuehling COMPUTE_UNIT_CPU, NULL, 1039520b8fb7SFelix Kuehling proximity_domain); 1040520b8fb7SFelix Kuehling cpu_only_node = 1; 1041520b8fb7SFelix Kuehling if (ret) { 1042520b8fb7SFelix Kuehling pr_err("Error creating VCRAT table for CPU\n"); 1043520b8fb7SFelix Kuehling return ret; 1044520b8fb7SFelix Kuehling } 1045520b8fb7SFelix Kuehling 1046520b8fb7SFelix Kuehling ret = kfd_parse_crat_table(crat_image, 1047520b8fb7SFelix Kuehling &temp_topology_device_list, 1048520b8fb7SFelix Kuehling proximity_domain); 1049520b8fb7SFelix Kuehling if (ret) { 1050520b8fb7SFelix Kuehling pr_err("Error parsing VCRAT table for CPU\n"); 10518e05247dSHarish Kasiviswanathan goto err; 1052520b8fb7SFelix Kuehling } 10535b5c4e40SEvgeny Pinchuk } 10545b5c4e40SEvgeny Pinchuk 1055f4757347SAmber Lin kdev = list_first_entry(&temp_topology_device_list, 1056f4757347SAmber Lin struct kfd_topology_device, list); 1057f4757347SAmber Lin kfd_add_perf_to_topology(kdev); 1058f4757347SAmber Lin 10595b5c4e40SEvgeny Pinchuk down_write(&topology_lock); 10604f449311SHarish Kasiviswanathan kfd_topology_update_device_list(&temp_topology_device_list, 10614f449311SHarish Kasiviswanathan &topology_device_list); 1062520b8fb7SFelix Kuehling atomic_set(&topology_crat_proximity_domain, sys_props.num_devices-1); 10635b5c4e40SEvgeny Pinchuk ret = kfd_topology_update_sysfs(); 10645b5c4e40SEvgeny Pinchuk up_write(&topology_lock); 10658e05247dSHarish Kasiviswanathan 10664f449311SHarish Kasiviswanathan if (!ret) { 10674f449311SHarish Kasiviswanathan sys_props.generation_count++; 1068520b8fb7SFelix Kuehling kfd_update_system_properties(); 1069520b8fb7SFelix Kuehling kfd_debug_print_topology(); 10704f449311SHarish Kasiviswanathan } else 10718e05247dSHarish Kasiviswanathan pr_err("Failed to update topology in sysfs ret=%d\n", ret); 10725b5c4e40SEvgeny Pinchuk 1073520b8fb7SFelix Kuehling /* For nodes with GPU, this information gets added 1074520b8fb7SFelix Kuehling * when GPU is detected (kfd_topology_add_device). 1075520b8fb7SFelix Kuehling */ 1076520b8fb7SFelix Kuehling if (cpu_only_node) { 1077520b8fb7SFelix Kuehling /* Add additional information to CPU only node created above */ 1078520b8fb7SFelix Kuehling down_write(&topology_lock); 1079520b8fb7SFelix Kuehling kdev = list_first_entry(&topology_device_list, 1080520b8fb7SFelix Kuehling struct kfd_topology_device, list); 1081520b8fb7SFelix Kuehling up_write(&topology_lock); 1082520b8fb7SFelix Kuehling kfd_add_non_crat_information(kdev); 1083520b8fb7SFelix Kuehling } 1084520b8fb7SFelix Kuehling 10855b5c4e40SEvgeny Pinchuk err: 10868e05247dSHarish Kasiviswanathan kfd_destroy_crat_image(crat_image); 10875b5c4e40SEvgeny Pinchuk return ret; 10885b5c4e40SEvgeny Pinchuk } 10895b5c4e40SEvgeny Pinchuk 10905b5c4e40SEvgeny Pinchuk void kfd_topology_shutdown(void) 10915b5c4e40SEvgeny Pinchuk { 10924f449311SHarish Kasiviswanathan down_write(&topology_lock); 10935b5c4e40SEvgeny Pinchuk kfd_topology_release_sysfs(); 10945b5c4e40SEvgeny Pinchuk kfd_release_live_view(); 10954f449311SHarish Kasiviswanathan up_write(&topology_lock); 10965b5c4e40SEvgeny Pinchuk } 10975b5c4e40SEvgeny Pinchuk 10985b5c4e40SEvgeny Pinchuk static uint32_t kfd_generate_gpu_id(struct kfd_dev *gpu) 10995b5c4e40SEvgeny Pinchuk { 11005b5c4e40SEvgeny Pinchuk uint32_t hashout; 11015b5c4e40SEvgeny Pinchuk uint32_t buf[7]; 1102585f0e6cSEdward O'Callaghan uint64_t local_mem_size; 11035b5c4e40SEvgeny Pinchuk int i; 11040504cccfSHarish Kasiviswanathan struct kfd_local_mem_info local_mem_info; 11055b5c4e40SEvgeny Pinchuk 11065b5c4e40SEvgeny Pinchuk if (!gpu) 11075b5c4e40SEvgeny Pinchuk return 0; 11085b5c4e40SEvgeny Pinchuk 1109574c4183SGraham Sider amdgpu_amdkfd_get_local_mem_info(gpu->adev, &local_mem_info); 11100504cccfSHarish Kasiviswanathan 11110504cccfSHarish Kasiviswanathan local_mem_size = local_mem_info.local_mem_size_private + 11120504cccfSHarish Kasiviswanathan local_mem_info.local_mem_size_public; 1113585f0e6cSEdward O'Callaghan 11145b5c4e40SEvgeny Pinchuk buf[0] = gpu->pdev->devfn; 111546096058SAmber Lin buf[1] = gpu->pdev->subsystem_vendor | 111646096058SAmber Lin (gpu->pdev->subsystem_device << 16); 111746096058SAmber Lin buf[2] = pci_domain_nr(gpu->pdev->bus); 11185b5c4e40SEvgeny Pinchuk buf[3] = gpu->pdev->device; 11195b5c4e40SEvgeny Pinchuk buf[4] = gpu->pdev->bus->number; 1120585f0e6cSEdward O'Callaghan buf[5] = lower_32_bits(local_mem_size); 1121585f0e6cSEdward O'Callaghan buf[6] = upper_32_bits(local_mem_size); 11225b5c4e40SEvgeny Pinchuk 11235b5c4e40SEvgeny Pinchuk for (i = 0, hashout = 0; i < 7; i++) 11245b5c4e40SEvgeny Pinchuk hashout ^= hash_32(buf[i], KFD_GPU_ID_HASH_WIDTH); 11255b5c4e40SEvgeny Pinchuk 11265b5c4e40SEvgeny Pinchuk return hashout; 11275b5c4e40SEvgeny Pinchuk } 11283a87177eSHarish Kasiviswanathan /* kfd_assign_gpu - Attach @gpu to the correct kfd topology device. If 11293a87177eSHarish Kasiviswanathan * the GPU device is not already present in the topology device 11303a87177eSHarish Kasiviswanathan * list then return NULL. This means a new topology device has to 11313a87177eSHarish Kasiviswanathan * be created for this GPU. 11323a87177eSHarish Kasiviswanathan */ 11335b5c4e40SEvgeny Pinchuk static struct kfd_topology_device *kfd_assign_gpu(struct kfd_dev *gpu) 11345b5c4e40SEvgeny Pinchuk { 11355b5c4e40SEvgeny Pinchuk struct kfd_topology_device *dev; 113616b9201cSOded Gabbay struct kfd_topology_device *out_dev = NULL; 1137171bc67eSHarish Kasiviswanathan struct kfd_mem_properties *mem; 1138171bc67eSHarish Kasiviswanathan struct kfd_cache_properties *cache; 1139171bc67eSHarish Kasiviswanathan struct kfd_iolink_properties *iolink; 11405b5c4e40SEvgeny Pinchuk 11413a87177eSHarish Kasiviswanathan down_write(&topology_lock); 1142b8fe0524SFelix Kuehling list_for_each_entry(dev, &topology_device_list, list) { 1143b8fe0524SFelix Kuehling /* Discrete GPUs need their own topology device list 1144b8fe0524SFelix Kuehling * entries. Don't assign them to CPU/APU nodes. 1145b8fe0524SFelix Kuehling */ 11466127896fSHuang Rui if (!gpu->use_iommu_v2 && 1147b8fe0524SFelix Kuehling dev->node_props.cpu_cores_count) 1148b8fe0524SFelix Kuehling continue; 1149b8fe0524SFelix Kuehling 11504eacc26bSKent Russell if (!dev->gpu && (dev->node_props.simd_count > 0)) { 11515b5c4e40SEvgeny Pinchuk dev->gpu = gpu; 11525b5c4e40SEvgeny Pinchuk out_dev = dev; 1153171bc67eSHarish Kasiviswanathan 1154171bc67eSHarish Kasiviswanathan list_for_each_entry(mem, &dev->mem_props, list) 1155171bc67eSHarish Kasiviswanathan mem->gpu = dev->gpu; 1156171bc67eSHarish Kasiviswanathan list_for_each_entry(cache, &dev->cache_props, list) 1157171bc67eSHarish Kasiviswanathan cache->gpu = dev->gpu; 1158171bc67eSHarish Kasiviswanathan list_for_each_entry(iolink, &dev->io_link_props, list) 1159171bc67eSHarish Kasiviswanathan iolink->gpu = dev->gpu; 11605b5c4e40SEvgeny Pinchuk break; 11615b5c4e40SEvgeny Pinchuk } 1162b8fe0524SFelix Kuehling } 11633a87177eSHarish Kasiviswanathan up_write(&topology_lock); 11645b5c4e40SEvgeny Pinchuk return out_dev; 11655b5c4e40SEvgeny Pinchuk } 11665b5c4e40SEvgeny Pinchuk 11675b5c4e40SEvgeny Pinchuk static void kfd_notify_gpu_change(uint32_t gpu_id, int arrival) 11685b5c4e40SEvgeny Pinchuk { 11695b5c4e40SEvgeny Pinchuk /* 11705b5c4e40SEvgeny Pinchuk * TODO: Generate an event for thunk about the arrival/removal 11715b5c4e40SEvgeny Pinchuk * of the GPU 11725b5c4e40SEvgeny Pinchuk */ 11735b5c4e40SEvgeny Pinchuk } 11745b5c4e40SEvgeny Pinchuk 11753a87177eSHarish Kasiviswanathan /* kfd_fill_mem_clk_max_info - Since CRAT doesn't have memory clock info, 11763a87177eSHarish Kasiviswanathan * patch this after CRAT parsing. 11773a87177eSHarish Kasiviswanathan */ 11783a87177eSHarish Kasiviswanathan static void kfd_fill_mem_clk_max_info(struct kfd_topology_device *dev) 11793a87177eSHarish Kasiviswanathan { 11803a87177eSHarish Kasiviswanathan struct kfd_mem_properties *mem; 11813a87177eSHarish Kasiviswanathan struct kfd_local_mem_info local_mem_info; 11823a87177eSHarish Kasiviswanathan 11833a87177eSHarish Kasiviswanathan if (!dev) 11843a87177eSHarish Kasiviswanathan return; 11853a87177eSHarish Kasiviswanathan 11863a87177eSHarish Kasiviswanathan /* Currently, amdgpu driver (amdgpu_mc) deals only with GPUs with 11873a87177eSHarish Kasiviswanathan * single bank of VRAM local memory. 11883a87177eSHarish Kasiviswanathan * for dGPUs - VCRAT reports only one bank of Local Memory 11893a87177eSHarish Kasiviswanathan * for APUs - If CRAT from ACPI reports more than one bank, then 11903a87177eSHarish Kasiviswanathan * all the banks will report the same mem_clk_max information 11913a87177eSHarish Kasiviswanathan */ 1192574c4183SGraham Sider amdgpu_amdkfd_get_local_mem_info(dev->gpu->adev, &local_mem_info); 11933a87177eSHarish Kasiviswanathan 11943a87177eSHarish Kasiviswanathan list_for_each_entry(mem, &dev->mem_props, list) 11953a87177eSHarish Kasiviswanathan mem->mem_clk_max = local_mem_info.mem_clk_max; 11963a87177eSHarish Kasiviswanathan } 11973a87177eSHarish Kasiviswanathan 1198bdd24657SJonathan Kim static void kfd_set_iolink_no_atomics(struct kfd_topology_device *dev, 1199bdd24657SJonathan Kim struct kfd_topology_device *target_gpu_dev, 1200bdd24657SJonathan Kim struct kfd_iolink_properties *link) 12013a87177eSHarish Kasiviswanathan { 1202bdd24657SJonathan Kim /* xgmi always supports atomics between links. */ 1203bdd24657SJonathan Kim if (link->iolink_type == CRAT_IOLINK_TYPE_XGMI) 12043a87177eSHarish Kasiviswanathan return; 12053a87177eSHarish Kasiviswanathan 1206bdd24657SJonathan Kim /* check pcie support to set cpu(dev) flags for target_gpu_dev link. */ 1207bdd24657SJonathan Kim if (target_gpu_dev) { 1208bdd24657SJonathan Kim uint32_t cap; 1209bdd24657SJonathan Kim 1210bdd24657SJonathan Kim pcie_capability_read_dword(target_gpu_dev->gpu->pdev, 1211d35f00d8SEric Huang PCI_EXP_DEVCAP2, &cap); 1212d35f00d8SEric Huang 1213d35f00d8SEric Huang if (!(cap & (PCI_EXP_DEVCAP2_ATOMIC_COMP32 | 1214d35f00d8SEric Huang PCI_EXP_DEVCAP2_ATOMIC_COMP64))) 1215bdd24657SJonathan Kim link->flags |= CRAT_IOLINK_FLAGS_NO_ATOMICS_32_BIT | 12163a87177eSHarish Kasiviswanathan CRAT_IOLINK_FLAGS_NO_ATOMICS_64_BIT; 1217bdd24657SJonathan Kim /* set gpu (dev) flags. */ 1218bdd24657SJonathan Kim } else { 1219d35f00d8SEric Huang if (!dev->gpu->pci_atomic_requested || 12207eb0502aSGraham Sider dev->gpu->adev->asic_type == CHIP_HAWAII) 1221bdd24657SJonathan Kim link->flags |= CRAT_IOLINK_FLAGS_NO_ATOMICS_32_BIT | 1222d35f00d8SEric Huang CRAT_IOLINK_FLAGS_NO_ATOMICS_64_BIT; 1223deb68983SJonathan Kim } 1224bdd24657SJonathan Kim } 1225bdd24657SJonathan Kim 1226c9cfbf7fSEric Huang static void kfd_set_iolink_non_coherent(struct kfd_topology_device *to_dev, 1227c9cfbf7fSEric Huang struct kfd_iolink_properties *outbound_link, 1228c9cfbf7fSEric Huang struct kfd_iolink_properties *inbound_link) 1229c9cfbf7fSEric Huang { 1230c9cfbf7fSEric Huang /* CPU -> GPU with PCIe */ 1231c9cfbf7fSEric Huang if (!to_dev->gpu && 1232c9cfbf7fSEric Huang inbound_link->iolink_type == CRAT_IOLINK_TYPE_PCIEXPRESS) 1233c9cfbf7fSEric Huang inbound_link->flags |= CRAT_IOLINK_FLAGS_NON_COHERENT; 1234c9cfbf7fSEric Huang 1235c9cfbf7fSEric Huang if (to_dev->gpu) { 1236c9cfbf7fSEric Huang /* GPU <-> GPU with PCIe and 1237c9cfbf7fSEric Huang * Vega20 with XGMI 1238c9cfbf7fSEric Huang */ 1239c9cfbf7fSEric Huang if (inbound_link->iolink_type == CRAT_IOLINK_TYPE_PCIEXPRESS || 1240c9cfbf7fSEric Huang (inbound_link->iolink_type == CRAT_IOLINK_TYPE_XGMI && 1241046e674bSGraham Sider KFD_GC_VERSION(to_dev->gpu) == IP_VERSION(9, 4, 0))) { 1242c9cfbf7fSEric Huang outbound_link->flags |= CRAT_IOLINK_FLAGS_NON_COHERENT; 1243c9cfbf7fSEric Huang inbound_link->flags |= CRAT_IOLINK_FLAGS_NON_COHERENT; 1244c9cfbf7fSEric Huang } 1245c9cfbf7fSEric Huang } 1246c9cfbf7fSEric Huang } 1247c9cfbf7fSEric Huang 1248bdd24657SJonathan Kim static void kfd_fill_iolink_non_crat_info(struct kfd_topology_device *dev) 1249bdd24657SJonathan Kim { 1250bdd24657SJonathan Kim struct kfd_iolink_properties *link, *inbound_link; 1251bdd24657SJonathan Kim struct kfd_topology_device *peer_dev; 1252bdd24657SJonathan Kim 1253bdd24657SJonathan Kim if (!dev || !dev->gpu) 1254bdd24657SJonathan Kim return; 1255d35f00d8SEric Huang 1256d35f00d8SEric Huang /* GPU only creates direct links so apply flags setting to all */ 1257d35f00d8SEric Huang list_for_each_entry(link, &dev->io_link_props, list) { 1258bdd24657SJonathan Kim link->flags = CRAT_IOLINK_FLAGS_ENABLED; 1259bdd24657SJonathan Kim kfd_set_iolink_no_atomics(dev, NULL, link); 1260bdd24657SJonathan Kim peer_dev = kfd_topology_device_by_proximity_domain( 1261d35f00d8SEric Huang link->node_to); 1262bdd24657SJonathan Kim 1263bdd24657SJonathan Kim if (!peer_dev) 1264bdd24657SJonathan Kim continue; 1265bdd24657SJonathan Kim 1266bdd24657SJonathan Kim list_for_each_entry(inbound_link, &peer_dev->io_link_props, 1267bdd24657SJonathan Kim list) { 1268bdd24657SJonathan Kim if (inbound_link->node_to != link->node_from) 1269bdd24657SJonathan Kim continue; 1270bdd24657SJonathan Kim 1271bdd24657SJonathan Kim inbound_link->flags = CRAT_IOLINK_FLAGS_ENABLED; 1272bdd24657SJonathan Kim kfd_set_iolink_no_atomics(peer_dev, dev, inbound_link); 1273c9cfbf7fSEric Huang kfd_set_iolink_non_coherent(peer_dev, link, inbound_link); 1274d35f00d8SEric Huang } 1275d35f00d8SEric Huang } 12763a87177eSHarish Kasiviswanathan } 12773a87177eSHarish Kasiviswanathan 12785b5c4e40SEvgeny Pinchuk int kfd_topology_add_device(struct kfd_dev *gpu) 12795b5c4e40SEvgeny Pinchuk { 12805b5c4e40SEvgeny Pinchuk uint32_t gpu_id; 12815b5c4e40SEvgeny Pinchuk struct kfd_topology_device *dev; 1282f7ce2fadSFlora Cui struct kfd_cu_info cu_info; 12834f449311SHarish Kasiviswanathan int res = 0; 12844f449311SHarish Kasiviswanathan struct list_head temp_topology_device_list; 12853a87177eSHarish Kasiviswanathan void *crat_image = NULL; 12863a87177eSHarish Kasiviswanathan size_t image_size = 0; 12873a87177eSHarish Kasiviswanathan int proximity_domain; 1288*b7675b7bSGraham Sider int i; 1289*b7675b7bSGraham Sider const char *asic_name = amdgpu_asic_name[gpu->adev->asic_type]; 12904f449311SHarish Kasiviswanathan 12914f449311SHarish Kasiviswanathan INIT_LIST_HEAD(&temp_topology_device_list); 12925b5c4e40SEvgeny Pinchuk 12935b5c4e40SEvgeny Pinchuk gpu_id = kfd_generate_gpu_id(gpu); 12945b5c4e40SEvgeny Pinchuk 129579775b62SKent Russell pr_debug("Adding new GPU (ID: 0x%x) to topology\n", gpu_id); 12965b5c4e40SEvgeny Pinchuk 12973a87177eSHarish Kasiviswanathan proximity_domain = atomic_inc_return(&topology_crat_proximity_domain); 12983a87177eSHarish Kasiviswanathan 1299d5edb56fSJonathan Kim /* Include the CPU in xGMI hive if xGMI connected by assigning it the hive ID. */ 130056c5977eSGraham Sider if (gpu->hive_id && gpu->adev->gmc.xgmi.connected_to_cpu) { 1301d5edb56fSJonathan Kim struct kfd_topology_device *top_dev; 1302d5edb56fSJonathan Kim 1303d5edb56fSJonathan Kim down_read(&topology_lock); 1304d5edb56fSJonathan Kim 1305d5edb56fSJonathan Kim list_for_each_entry(top_dev, &topology_device_list, list) { 1306d5edb56fSJonathan Kim if (top_dev->gpu) 1307d5edb56fSJonathan Kim break; 1308d5edb56fSJonathan Kim 1309d5edb56fSJonathan Kim top_dev->node_props.hive_id = gpu->hive_id; 1310d5edb56fSJonathan Kim } 1311d5edb56fSJonathan Kim 1312d5edb56fSJonathan Kim up_read(&topology_lock); 1313d5edb56fSJonathan Kim } 1314d5edb56fSJonathan Kim 13153a87177eSHarish Kasiviswanathan /* Check to see if this gpu device exists in the topology_device_list. 13163a87177eSHarish Kasiviswanathan * If so, assign the gpu to that device, 13173a87177eSHarish Kasiviswanathan * else create a Virtual CRAT for this gpu device and then parse that 13183a87177eSHarish Kasiviswanathan * CRAT to create a new topology device. Once created assign the gpu to 13193a87177eSHarish Kasiviswanathan * that topology device 13205b5c4e40SEvgeny Pinchuk */ 13215b5c4e40SEvgeny Pinchuk dev = kfd_assign_gpu(gpu); 13225b5c4e40SEvgeny Pinchuk if (!dev) { 13233a87177eSHarish Kasiviswanathan res = kfd_create_crat_image_virtual(&crat_image, &image_size, 13243a87177eSHarish Kasiviswanathan COMPUTE_UNIT_GPU, gpu, 13253a87177eSHarish Kasiviswanathan proximity_domain); 13263a87177eSHarish Kasiviswanathan if (res) { 13273a87177eSHarish Kasiviswanathan pr_err("Error creating VCRAT for GPU (ID: 0x%x)\n", 13283a87177eSHarish Kasiviswanathan gpu_id); 13293a87177eSHarish Kasiviswanathan return res; 13303a87177eSHarish Kasiviswanathan } 13313a87177eSHarish Kasiviswanathan res = kfd_parse_crat_table(crat_image, 13323a87177eSHarish Kasiviswanathan &temp_topology_device_list, 13333a87177eSHarish Kasiviswanathan proximity_domain); 13343a87177eSHarish Kasiviswanathan if (res) { 13353a87177eSHarish Kasiviswanathan pr_err("Error parsing VCRAT for GPU (ID: 0x%x)\n", 13363a87177eSHarish Kasiviswanathan gpu_id); 13375b5c4e40SEvgeny Pinchuk goto err; 13385b5c4e40SEvgeny Pinchuk } 13394f449311SHarish Kasiviswanathan 13404f449311SHarish Kasiviswanathan down_write(&topology_lock); 13414f449311SHarish Kasiviswanathan kfd_topology_update_device_list(&temp_topology_device_list, 13424f449311SHarish Kasiviswanathan &topology_device_list); 13434f449311SHarish Kasiviswanathan 13448eabaf54SKent Russell /* Update the SYSFS tree, since we added another topology 13458eabaf54SKent Russell * device 13465b5c4e40SEvgeny Pinchuk */ 13473a87177eSHarish Kasiviswanathan res = kfd_topology_update_sysfs(); 13484f449311SHarish Kasiviswanathan up_write(&topology_lock); 13494f449311SHarish Kasiviswanathan 13503a87177eSHarish Kasiviswanathan if (!res) 13513a87177eSHarish Kasiviswanathan sys_props.generation_count++; 13523a87177eSHarish Kasiviswanathan else 13533a87177eSHarish Kasiviswanathan pr_err("Failed to update GPU (ID: 0x%x) to sysfs topology. res=%d\n", 13543a87177eSHarish Kasiviswanathan gpu_id, res); 13553a87177eSHarish Kasiviswanathan dev = kfd_assign_gpu(gpu); 13563a87177eSHarish Kasiviswanathan if (WARN_ON(!dev)) { 13573a87177eSHarish Kasiviswanathan res = -ENODEV; 13583a87177eSHarish Kasiviswanathan goto err; 13593a87177eSHarish Kasiviswanathan } 13605b5c4e40SEvgeny Pinchuk } 13615b5c4e40SEvgeny Pinchuk 13625b5c4e40SEvgeny Pinchuk dev->gpu_id = gpu_id; 13635b5c4e40SEvgeny Pinchuk gpu->id = gpu_id; 13643a87177eSHarish Kasiviswanathan 13653a87177eSHarish Kasiviswanathan /* TODO: Move the following lines to function 13663a87177eSHarish Kasiviswanathan * kfd_add_non_crat_information 13673a87177eSHarish Kasiviswanathan */ 13683a87177eSHarish Kasiviswanathan 13693a87177eSHarish Kasiviswanathan /* Fill-in additional information that is not available in CRAT but 13703a87177eSHarish Kasiviswanathan * needed for the topology 13713a87177eSHarish Kasiviswanathan */ 13723a87177eSHarish Kasiviswanathan 1373574c4183SGraham Sider amdgpu_amdkfd_get_cu_info(dev->gpu->adev, &cu_info); 1374c181159aSYong Zhao 1375*b7675b7bSGraham Sider for (i = 0; i < KFD_TOPOLOGY_PUBLIC_NAME_SIZE-1; i++) { 1376*b7675b7bSGraham Sider dev->node_props.name[i] = __tolower(asic_name[i]); 1377*b7675b7bSGraham Sider if (asic_name[i] == '\0') 1378*b7675b7bSGraham Sider break; 1379*b7675b7bSGraham Sider } 1380*b7675b7bSGraham Sider dev->node_props.name[i] = '\0'; 1381c181159aSYong Zhao 13823a87177eSHarish Kasiviswanathan dev->node_props.simd_arrays_per_engine = 13833a87177eSHarish Kasiviswanathan cu_info.num_shader_arrays_per_engine; 13843a87177eSHarish Kasiviswanathan 13859d6fa9c7SGraham Sider dev->node_props.gfx_target_version = gpu->device_info->gfx_target_version; 13865b5c4e40SEvgeny Pinchuk dev->node_props.vendor_id = gpu->pdev->vendor; 13875b5c4e40SEvgeny Pinchuk dev->node_props.device_id = gpu->pdev->device; 1388c6d1ec41SJoseph Greathouse dev->node_props.capability |= 138902274fc0SGraham Sider ((dev->gpu->adev->rev_id << HSA_CAP_ASIC_REVISION_SHIFT) & 1390c6d1ec41SJoseph Greathouse HSA_CAP_ASIC_REVISION_MASK); 1391babe2ef3SHeiner Kallweit dev->node_props.location_id = pci_dev_id(gpu->pdev); 13923e58e95aSOri Messinger dev->node_props.domain = pci_domain_nr(gpu->pdev->bus); 13933a87177eSHarish Kasiviswanathan dev->node_props.max_engine_clk_fcompute = 1394574c4183SGraham Sider amdgpu_amdkfd_get_max_engine_clock_in_mhz(dev->gpu->adev); 13953a87177eSHarish Kasiviswanathan dev->node_props.max_engine_clk_ccompute = 13963a87177eSHarish Kasiviswanathan cpufreq_quick_get_max(0) / 1000; 13977c9b7171SOak Zeng dev->node_props.drm_render_minor = 13987c9b7171SOak Zeng gpu->shared_resources.drm_render_minor; 13995b5c4e40SEvgeny Pinchuk 14000c1690e3SShaoyun Liu dev->node_props.hive_id = gpu->hive_id; 1401ee2f17f4SAmber Lin dev->node_props.num_sdma_engines = kfd_get_num_sdma_engines(gpu); 140214568cf6SOak Zeng dev->node_props.num_sdma_xgmi_engines = 1403ee2f17f4SAmber Lin kfd_get_num_xgmi_sdma_engines(gpu); 1404bb71c74dSHuang Rui dev->node_props.num_sdma_queues_per_engine = 1405bb71c74dSHuang Rui gpu->device_info->num_sdma_queues_per_engine; 140629633d0eSJoseph Greathouse dev->node_props.num_gws = (dev->gpu->gws && 140729e76462SOak Zeng dev->gpu->dqm->sched_policy != KFD_SCHED_POLICY_NO_HWS) ? 140802274fc0SGraham Sider dev->gpu->adev->gds.gws_size : 0; 1409e6945304SYong Zhao dev->node_props.num_cp_queues = get_cp_queues_num(dev->gpu->dqm); 14100c1690e3SShaoyun Liu 14113a87177eSHarish Kasiviswanathan kfd_fill_mem_clk_max_info(dev); 14123a87177eSHarish Kasiviswanathan kfd_fill_iolink_non_crat_info(dev); 14133a87177eSHarish Kasiviswanathan 14147eb0502aSGraham Sider switch (dev->gpu->adev->asic_type) { 14153a87177eSHarish Kasiviswanathan case CHIP_KAVERI: 14163a87177eSHarish Kasiviswanathan case CHIP_HAWAII: 14173a87177eSHarish Kasiviswanathan case CHIP_TONGA: 14183a87177eSHarish Kasiviswanathan dev->node_props.capability |= ((HSA_CAP_DOORBELL_TYPE_PRE_1_0 << 14193a87177eSHarish Kasiviswanathan HSA_CAP_DOORBELL_TYPE_TOTALBITS_SHIFT) & 14203a87177eSHarish Kasiviswanathan HSA_CAP_DOORBELL_TYPE_TOTALBITS_MASK); 14213a87177eSHarish Kasiviswanathan break; 14223a87177eSHarish Kasiviswanathan case CHIP_CARRIZO: 14233a87177eSHarish Kasiviswanathan case CHIP_FIJI: 14243a87177eSHarish Kasiviswanathan case CHIP_POLARIS10: 14253a87177eSHarish Kasiviswanathan case CHIP_POLARIS11: 1426846a44d7SGang Ba case CHIP_POLARIS12: 1427ed81cd6eSKent Russell case CHIP_VEGAM: 142842aa8793SFelix Kuehling pr_debug("Adding doorbell packet type capability\n"); 14293a87177eSHarish Kasiviswanathan dev->node_props.capability |= ((HSA_CAP_DOORBELL_TYPE_1_0 << 14303a87177eSHarish Kasiviswanathan HSA_CAP_DOORBELL_TYPE_TOTALBITS_SHIFT) & 14313a87177eSHarish Kasiviswanathan HSA_CAP_DOORBELL_TYPE_TOTALBITS_MASK); 14323a87177eSHarish Kasiviswanathan break; 1433e4804a39SGraham Sider default: 1434e4804a39SGraham Sider if (KFD_GC_VERSION(dev->gpu) >= IP_VERSION(9, 0, 1)) 1435389056e5SFelix Kuehling dev->node_props.capability |= ((HSA_CAP_DOORBELL_TYPE_2_0 << 1436389056e5SFelix Kuehling HSA_CAP_DOORBELL_TYPE_TOTALBITS_SHIFT) & 1437389056e5SFelix Kuehling HSA_CAP_DOORBELL_TYPE_TOTALBITS_MASK); 1438e4804a39SGraham Sider else 14393a87177eSHarish Kasiviswanathan WARN(1, "Unexpected ASIC family %u", 14407eb0502aSGraham Sider dev->gpu->adev->asic_type); 14417639a8c4SBen Goz } 14427639a8c4SBen Goz 14431ae99eabSOak Zeng /* 14441ae99eabSOak Zeng * Overwrite ATS capability according to needs_iommu_device to fix 14451ae99eabSOak Zeng * potential missing corresponding bit in CRAT of BIOS. 14461ae99eabSOak Zeng */ 14476127896fSHuang Rui if (dev->gpu->use_iommu_v2) 14481ae99eabSOak Zeng dev->node_props.capability |= HSA_CAP_ATS_PRESENT; 14491ae99eabSOak Zeng else 14501ae99eabSOak Zeng dev->node_props.capability &= ~HSA_CAP_ATS_PRESENT; 14511ae99eabSOak Zeng 14523a87177eSHarish Kasiviswanathan /* Fix errors in CZ CRAT. 14533a87177eSHarish Kasiviswanathan * simd_count: Carrizo CRAT reports wrong simd_count, probably 14543a87177eSHarish Kasiviswanathan * because it doesn't consider masked out CUs 145570f372bfSPhilip Cox * max_waves_per_simd: Carrizo reports wrong max_waves_per_simd 14563a87177eSHarish Kasiviswanathan */ 14577eb0502aSGraham Sider if (dev->gpu->adev->asic_type == CHIP_CARRIZO) { 14583a87177eSHarish Kasiviswanathan dev->node_props.simd_count = 14593a87177eSHarish Kasiviswanathan cu_info.simd_per_cu * cu_info.cu_active_number; 146070f372bfSPhilip Cox dev->node_props.max_waves_per_simd = 10; 146170f372bfSPhilip Cox } 14623a87177eSHarish Kasiviswanathan 14635436ab94SStanley.Yang /* kfd only concerns sram ecc on GFX and HBM ecc on UMC */ 14640dee45a2SEric Huang dev->node_props.capability |= 146556c5977eSGraham Sider ((dev->gpu->adev->ras_enabled & BIT(AMDGPU_RAS_BLOCK__GFX)) != 0) ? 14660dee45a2SEric Huang HSA_CAP_SRAM_EDCSUPPORTED : 0; 146756c5977eSGraham Sider dev->node_props.capability |= 146856c5977eSGraham Sider ((dev->gpu->adev->ras_enabled & BIT(AMDGPU_RAS_BLOCK__UMC)) != 0) ? 14690dee45a2SEric Huang HSA_CAP_MEM_EDCSUPPORTED : 0; 14700dee45a2SEric Huang 1471046e674bSGraham Sider if (KFD_GC_VERSION(dev->gpu) != IP_VERSION(9, 0, 1)) 147256c5977eSGraham Sider dev->node_props.capability |= (dev->gpu->adev->ras_enabled != 0) ? 14730dee45a2SEric Huang HSA_CAP_RASEVENTNOTIFY : 0; 14740dee45a2SEric Huang 147556c5977eSGraham Sider if (KFD_IS_SVM_API_SUPPORTED(dev->gpu->adev->kfd.dev)) 14764c166eb9SPhilip Yang dev->node_props.capability |= HSA_CAP_SVMAPI_SUPPORTED; 14774c166eb9SPhilip Yang 14783a87177eSHarish Kasiviswanathan kfd_debug_print_topology(); 14793a87177eSHarish Kasiviswanathan 14804f449311SHarish Kasiviswanathan if (!res) 14815b5c4e40SEvgeny Pinchuk kfd_notify_gpu_change(gpu_id, 1); 14824f449311SHarish Kasiviswanathan err: 14833a87177eSHarish Kasiviswanathan kfd_destroy_crat_image(crat_image); 14845b5c4e40SEvgeny Pinchuk return res; 14855b5c4e40SEvgeny Pinchuk } 14865b5c4e40SEvgeny Pinchuk 14875b5c4e40SEvgeny Pinchuk int kfd_topology_remove_device(struct kfd_dev *gpu) 14885b5c4e40SEvgeny Pinchuk { 14894f449311SHarish Kasiviswanathan struct kfd_topology_device *dev, *tmp; 14905b5c4e40SEvgeny Pinchuk uint32_t gpu_id; 14915b5c4e40SEvgeny Pinchuk int res = -ENODEV; 14925b5c4e40SEvgeny Pinchuk 14935b5c4e40SEvgeny Pinchuk down_write(&topology_lock); 14945b5c4e40SEvgeny Pinchuk 14954f449311SHarish Kasiviswanathan list_for_each_entry_safe(dev, tmp, &topology_device_list, list) 14965b5c4e40SEvgeny Pinchuk if (dev->gpu == gpu) { 14975b5c4e40SEvgeny Pinchuk gpu_id = dev->gpu_id; 14985b5c4e40SEvgeny Pinchuk kfd_remove_sysfs_node_entry(dev); 14995b5c4e40SEvgeny Pinchuk kfd_release_topology_device(dev); 15004f449311SHarish Kasiviswanathan sys_props.num_devices--; 15015b5c4e40SEvgeny Pinchuk res = 0; 15025b5c4e40SEvgeny Pinchuk if (kfd_topology_update_sysfs() < 0) 15035b5c4e40SEvgeny Pinchuk kfd_topology_release_sysfs(); 15045b5c4e40SEvgeny Pinchuk break; 15055b5c4e40SEvgeny Pinchuk } 15065b5c4e40SEvgeny Pinchuk 15075b5c4e40SEvgeny Pinchuk up_write(&topology_lock); 15085b5c4e40SEvgeny Pinchuk 1509174de876SFelix Kuehling if (!res) 15105b5c4e40SEvgeny Pinchuk kfd_notify_gpu_change(gpu_id, 0); 15115b5c4e40SEvgeny Pinchuk 15125b5c4e40SEvgeny Pinchuk return res; 15135b5c4e40SEvgeny Pinchuk } 15145b5c4e40SEvgeny Pinchuk 15156d82eb0eSHarish Kasiviswanathan /* kfd_topology_enum_kfd_devices - Enumerate through all devices in KFD 15166d82eb0eSHarish Kasiviswanathan * topology. If GPU device is found @idx, then valid kfd_dev pointer is 15176d82eb0eSHarish Kasiviswanathan * returned through @kdev 15186d82eb0eSHarish Kasiviswanathan * Return - 0: On success (@kdev will be NULL for non GPU nodes) 15196d82eb0eSHarish Kasiviswanathan * -1: If end of list 15205b5c4e40SEvgeny Pinchuk */ 15216d82eb0eSHarish Kasiviswanathan int kfd_topology_enum_kfd_devices(uint8_t idx, struct kfd_dev **kdev) 15225b5c4e40SEvgeny Pinchuk { 15235b5c4e40SEvgeny Pinchuk 15245b5c4e40SEvgeny Pinchuk struct kfd_topology_device *top_dev; 15255b5c4e40SEvgeny Pinchuk uint8_t device_idx = 0; 15265b5c4e40SEvgeny Pinchuk 15276d82eb0eSHarish Kasiviswanathan *kdev = NULL; 15285b5c4e40SEvgeny Pinchuk down_read(&topology_lock); 15295b5c4e40SEvgeny Pinchuk 15305b5c4e40SEvgeny Pinchuk list_for_each_entry(top_dev, &topology_device_list, list) { 15315b5c4e40SEvgeny Pinchuk if (device_idx == idx) { 15326d82eb0eSHarish Kasiviswanathan *kdev = top_dev->gpu; 15336d82eb0eSHarish Kasiviswanathan up_read(&topology_lock); 15346d82eb0eSHarish Kasiviswanathan return 0; 15355b5c4e40SEvgeny Pinchuk } 15365b5c4e40SEvgeny Pinchuk 15375b5c4e40SEvgeny Pinchuk device_idx++; 15385b5c4e40SEvgeny Pinchuk } 15395b5c4e40SEvgeny Pinchuk 15405b5c4e40SEvgeny Pinchuk up_read(&topology_lock); 15415b5c4e40SEvgeny Pinchuk 15426d82eb0eSHarish Kasiviswanathan return -1; 15435b5c4e40SEvgeny Pinchuk 15445b5c4e40SEvgeny Pinchuk } 1545851a645eSFelix Kuehling 1546520b8fb7SFelix Kuehling static int kfd_cpumask_to_apic_id(const struct cpumask *cpumask) 1547520b8fb7SFelix Kuehling { 1548520b8fb7SFelix Kuehling int first_cpu_of_numa_node; 1549520b8fb7SFelix Kuehling 1550520b8fb7SFelix Kuehling if (!cpumask || cpumask == cpu_none_mask) 1551520b8fb7SFelix Kuehling return -1; 1552520b8fb7SFelix Kuehling first_cpu_of_numa_node = cpumask_first(cpumask); 1553520b8fb7SFelix Kuehling if (first_cpu_of_numa_node >= nr_cpu_ids) 1554520b8fb7SFelix Kuehling return -1; 1555df1dd4f4SFelix Kuehling #ifdef CONFIG_X86_64 1556df1dd4f4SFelix Kuehling return cpu_data(first_cpu_of_numa_node).apicid; 1557df1dd4f4SFelix Kuehling #else 1558df1dd4f4SFelix Kuehling return first_cpu_of_numa_node; 1559df1dd4f4SFelix Kuehling #endif 1560520b8fb7SFelix Kuehling } 1561520b8fb7SFelix Kuehling 1562520b8fb7SFelix Kuehling /* kfd_numa_node_to_apic_id - Returns the APIC ID of the first logical processor 1563520b8fb7SFelix Kuehling * of the given NUMA node (numa_node_id) 1564520b8fb7SFelix Kuehling * Return -1 on failure 1565520b8fb7SFelix Kuehling */ 1566520b8fb7SFelix Kuehling int kfd_numa_node_to_apic_id(int numa_node_id) 1567520b8fb7SFelix Kuehling { 1568520b8fb7SFelix Kuehling if (numa_node_id == -1) { 1569520b8fb7SFelix Kuehling pr_warn("Invalid NUMA Node. Use online CPU mask\n"); 1570520b8fb7SFelix Kuehling return kfd_cpumask_to_apic_id(cpu_online_mask); 1571520b8fb7SFelix Kuehling } 1572520b8fb7SFelix Kuehling return kfd_cpumask_to_apic_id(cpumask_of_node(numa_node_id)); 1573520b8fb7SFelix Kuehling } 1574520b8fb7SFelix Kuehling 15756127896fSHuang Rui void kfd_double_confirm_iommu_support(struct kfd_dev *gpu) 15766127896fSHuang Rui { 15776127896fSHuang Rui struct kfd_topology_device *dev; 15786127896fSHuang Rui 15796127896fSHuang Rui gpu->use_iommu_v2 = false; 15806127896fSHuang Rui 15816127896fSHuang Rui if (!gpu->device_info->needs_iommu_device) 15826127896fSHuang Rui return; 15836127896fSHuang Rui 15846127896fSHuang Rui down_read(&topology_lock); 15856127896fSHuang Rui 15866127896fSHuang Rui /* Only use IOMMUv2 if there is an APU topology node with no GPU 15876127896fSHuang Rui * assigned yet. This GPU will be assigned to it. 15886127896fSHuang Rui */ 15896127896fSHuang Rui list_for_each_entry(dev, &topology_device_list, list) 15906127896fSHuang Rui if (dev->node_props.cpu_cores_count && 15916127896fSHuang Rui dev->node_props.simd_count && 15926127896fSHuang Rui !dev->gpu) 15936127896fSHuang Rui gpu->use_iommu_v2 = true; 15946127896fSHuang Rui 15956127896fSHuang Rui up_read(&topology_lock); 15966127896fSHuang Rui } 15976127896fSHuang Rui 1598851a645eSFelix Kuehling #if defined(CONFIG_DEBUG_FS) 1599851a645eSFelix Kuehling 1600851a645eSFelix Kuehling int kfd_debugfs_hqds_by_device(struct seq_file *m, void *data) 1601851a645eSFelix Kuehling { 1602851a645eSFelix Kuehling struct kfd_topology_device *dev; 1603851a645eSFelix Kuehling unsigned int i = 0; 1604851a645eSFelix Kuehling int r = 0; 1605851a645eSFelix Kuehling 1606851a645eSFelix Kuehling down_read(&topology_lock); 1607851a645eSFelix Kuehling 1608851a645eSFelix Kuehling list_for_each_entry(dev, &topology_device_list, list) { 1609851a645eSFelix Kuehling if (!dev->gpu) { 1610851a645eSFelix Kuehling i++; 1611851a645eSFelix Kuehling continue; 1612851a645eSFelix Kuehling } 1613851a645eSFelix Kuehling 1614851a645eSFelix Kuehling seq_printf(m, "Node %u, gpu_id %x:\n", i++, dev->gpu->id); 1615851a645eSFelix Kuehling r = dqm_debugfs_hqds(m, dev->gpu->dqm); 1616851a645eSFelix Kuehling if (r) 1617851a645eSFelix Kuehling break; 1618851a645eSFelix Kuehling } 1619851a645eSFelix Kuehling 1620851a645eSFelix Kuehling up_read(&topology_lock); 1621851a645eSFelix Kuehling 1622851a645eSFelix Kuehling return r; 1623851a645eSFelix Kuehling } 1624851a645eSFelix Kuehling 1625851a645eSFelix Kuehling int kfd_debugfs_rls_by_device(struct seq_file *m, void *data) 1626851a645eSFelix Kuehling { 1627851a645eSFelix Kuehling struct kfd_topology_device *dev; 1628851a645eSFelix Kuehling unsigned int i = 0; 1629851a645eSFelix Kuehling int r = 0; 1630851a645eSFelix Kuehling 1631851a645eSFelix Kuehling down_read(&topology_lock); 1632851a645eSFelix Kuehling 1633851a645eSFelix Kuehling list_for_each_entry(dev, &topology_device_list, list) { 1634851a645eSFelix Kuehling if (!dev->gpu) { 1635851a645eSFelix Kuehling i++; 1636851a645eSFelix Kuehling continue; 1637851a645eSFelix Kuehling } 1638851a645eSFelix Kuehling 1639851a645eSFelix Kuehling seq_printf(m, "Node %u, gpu_id %x:\n", i++, dev->gpu->id); 16409af5379cSOak Zeng r = pm_debugfs_runlist(m, &dev->gpu->dqm->packet_mgr); 1641851a645eSFelix Kuehling if (r) 1642851a645eSFelix Kuehling break; 1643851a645eSFelix Kuehling } 1644851a645eSFelix Kuehling 1645851a645eSFelix Kuehling up_read(&topology_lock); 1646851a645eSFelix Kuehling 1647851a645eSFelix Kuehling return r; 1648851a645eSFelix Kuehling } 1649851a645eSFelix Kuehling 1650851a645eSFelix Kuehling #endif 1651