litmus-rt-ext-res.git - LITMUS^RT with extended reservations for Forbidden Zones paper @ RTAS'20

diff options

author	Christian König <christian.koenig@amd.com>	2016-05-04 04:33:11 -0400
committer	Alex Deucher <alexander.deucher@amd.com>	2016-05-11 12:31:19 -0400
commit	79aa03893df937967201b6ea34e8d4216b893a38 (patch)
tree	2a228469747dee9dd569528e50a5059a4f898a76 /drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
parent	0ea54b9b6c4ebc04cc6f68246b03577a25dbd4bb (diff)

drm/amdgpu: remove owner cleanup v2

The client ID is now unique, so no need to resert the owner fields any more. v2: remove unused variables as well Signed-off-by: Christian König <christian.koenig@amd.com> Reviewed-by: Chunming Zhou <david1.zhou@amd.com> (v1) Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

Diffstat (limited to 'drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c')

-rw-r--r--

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

1 files changed, 0 insertions, 13 deletions


diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c index cd578987d6c0..67f6c2eb8282 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
@@ -1457,7 +1457,6 @@ error_free_sched_entity:
1457	void amdgpu_vm_fini(struct amdgpu_device adev, struct amdgpu_vm vm)	1457	void amdgpu_vm_fini(struct amdgpu_device adev, struct amdgpu_vm vm)
1458	{	1458	{
1459	struct amdgpu_bo_va_mapping mapping, tmp;	1459	struct amdgpu_bo_va_mapping mapping, tmp;
1460	struct amdgpu_vm_id id, id_tmp;
1461	int i;	1460	int i;
1462		1461
1463	amd_sched_entity_fini(vm->entity.sched, &vm->entity);	1462	amd_sched_entity_fini(vm->entity.sched, &vm->entity);
@@ -1481,18 +1480,6 @@ void amdgpu_vm_fini(struct amdgpu_device adev, struct amdgpu_vm vm)
1481		1480
1482	amdgpu_bo_unref(&vm->page_directory);	1481	amdgpu_bo_unref(&vm->page_directory);
1483	fence_put(vm->page_directory_fence);	1482	fence_put(vm->page_directory_fence);
1484
1485	mutex_lock(&adev->vm_manager.lock);
1486	list_for_each_entry_safe(id, id_tmp, &adev->vm_manager.ids_lru,
1487	list) {
1488	if (!id)
1489	continue;
1490	if (atomic_long_read(&id->owner) == vm->client_id) {
1491	atomic_long_set(&id->owner, 0);
1492	id->pd_gpu_addr = 0;
1493	}
1494	}
1495	mutex_unlock(&adev->vm_manager.lock);
1496	}	1483	}
1497		1484
1498	/**	1485	/**

/* * drivers.c * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. * * Copyright (c) 1999 The Puffin Group * Copyright (c) 2001 Matthew Wilcox for Hewlett Packard * Copyright (c) 2001 Helge Deller <deller@gmx.de> * Copyright (c) 2001,2002 Ryan Bradetich * Copyright (c) 2004-2005 Thibaut VARENE <varenet@parisc-linux.org> * * The file handles registering devices and drivers, then matching them. * It's the closest we get to a dating agency. * * If you're thinking about modifying this file, here are some gotchas to * bear in mind: * - 715/Mirage device paths have a dummy device between Lasi and its children * - The EISA adapter may show up as a sibling or child of Wax * - Dino has an optionally functional serial port. If firmware enables it, * it shows up as a child of Dino. If firmware disables it, the buswalk * finds it and it shows up as a child of Cujo * - Dino has both parisc and pci devices as children * - parisc devices are discovered in a random order, including children * before parents in some cases. */ #include <linux/slab.h> #include <linux/types.h> #include <linux/kernel.h> #include <linux/pci.h> #include <linux/spinlock.h> #include <linux/string.h> #include <linux/export.h> #include <asm/hardware.h> #include <asm/io.h> #include <asm/pdc.h> #include <asm/parisc-device.h> /* See comments in include/asm-parisc/pci.h */ struct hppa_dma_ops *hppa_dma_ops __read_mostly; EXPORT_SYMBOL(hppa_dma_ops); static struct device root = { .init_name = "parisc", }; static inline int check_dev(struct device *dev) { if (dev->bus == &parisc_bus_type) { struct parisc_device *pdev; pdev = to_parisc_device(dev); return pdev->id.hw_type != HPHW_FAULTY; } return 1; } static struct device * parse_tree_node(struct device *parent, int index, struct hardware_path *modpath); struct recurse_struct { void * obj; int (*fn)(struct device *, void *); }; static int descend_children(struct device * dev, void * data) { struct recurse_struct * recurse_data = (struct recurse_struct *)data; if (recurse_data->fn(dev, recurse_data->obj)) return 1; else return device_for_each_child(dev, recurse_data, descend_children); } /** * for_each_padev - Iterate over all devices in the tree * @fn: Function to call for each device. * @data: Data to pass to the called function. * * This performs a depth-first traversal of the tree, calling the * function passed for each node. It calls the function for parents * before children. */ static int for_each_padev(int (*fn)(struct device *, void *), void * data) { struct recurse_struct recurse_data = { .obj = data, .fn = fn, }; return device_for_each_child(&root, &recurse_data, descend_children); } /** * match_device - Report whether this driver can handle this device * @driver: the PA-RISC driver to try * @dev: the PA-RISC device to try */ static int match_device(struct parisc_driver *driver, struct parisc_device *dev) { const struct parisc_device_id *ids; for (ids = driver->id_table; ids->sversion; ids++) { if ((ids->sversion != SVERSION_ANY_ID) && (ids->sversion != dev->id.sversion)) continue; if ((ids->hw_type != HWTYPE_ANY_ID) && (ids->hw_type != dev->id.hw_type)) continue; if ((ids->hversion != HVERSION_ANY_ID) && (ids->hversion != dev->id.hversion)) continue; return 1; } return 0; } static int parisc_driver_probe(struct device *dev) { int rc; struct parisc_device *pa_dev = to_parisc_device(dev); struct parisc_driver *pa_drv = to_parisc_driver(dev->driver); rc = pa_drv->probe(pa_dev); if (!rc) pa_dev->driver = pa_drv; return rc; } static int parisc_driver_remove(struct device *dev) { struct parisc_device *pa_dev = to_parisc_device(dev); struct parisc_driver *pa_drv = to_parisc_driver(dev->driver); if (pa_drv->remove) pa_drv->remove(pa_dev); return 0; } /** * register_parisc_driver - Register this driver if it can handle a device * @driver: the PA-RISC driver to try */ int register_parisc_driver(struct parisc_driver *driver) { /* FIXME: we need this because apparently the sti * driver can be registered twice */ if(driver->drv.name) { printk(KERN_WARNING "BUG: skipping previously registered driver %s\n", driver->name); return 1; } if (!driver->probe) { printk(KERN_WARNING "BUG: driver %s has no probe routine\n", driver->name); return 1; } driver->drv.bus = &parisc_bus_type; /* We install our own probe and remove routines */ WARN_ON(driver->drv.probe != NULL); WARN_ON(driver->drv.remove != NULL); driver->drv.name = driver->name; return driver_register(&driver->drv); } EXPORT_SYMBOL(register_parisc_driver); struct match_count { struct parisc_driver * driver; int count; }; static int match_and_count(struct device * dev, void * data) { struct match_count * m = data; struct parisc_device * pdev = to_parisc_device(dev); if (check_dev(dev)) { if (match_device(m->driver, pdev)) m->count++; } return 0; } /** * count_parisc_driver - count # of devices this driver would match * @driver: the PA-RISC driver to try * * Use by IOMMU support to "guess" the right size IOPdir. * Formula is something like memsize/(num_iommu * entry_size). */ int count_parisc_driver(struct parisc_driver *driver) { struct match_count m = { .driver = driver, .count = 0, }; for_each_padev(match_and_count, &m); return m.count; } /** * unregister_parisc_driver - Unregister this driver from the list of drivers * @driver: the PA-RISC driver to unregister */ int unregister_parisc_driver(struct parisc_driver *driver) { driver_unregister(&driver->drv); return 0; } EXPORT_SYMBOL(unregister_parisc_driver); struct find_data { unsigned long hpa; struct parisc_device * dev; }; static int find_device(struct device * dev, void * data) { struct parisc_device * pdev = to_parisc_device(dev); struct find_data * d = (struct find_data*)data; if (check_dev(dev)) { if (pdev->hpa.start == d->hpa) { d->dev = pdev; return 1; } } return 0; } static struct parisc_device *find_device_by_addr(unsigned long hpa) { struct find_data d = { .hpa = hpa, }; int ret; ret = for_each_padev(find_device, &d); return ret ? d.dev : NULL; } /** * find_pa_parent_type - Find a parent of a specific type * @dev: The device to start searching from * @type: The device type to search for. * * Walks up the device tree looking for a device of the specified type. * If it finds it, it returns it. If not, it returns NULL. */ const struct parisc_device * find_pa_parent_type(const struct parisc_device *padev, int type) { const struct device *dev = &padev->dev; while (dev != &root) { struct parisc_device *candidate = to_parisc_device(dev); if (candidate->id.hw_type == type) return candidate; dev = dev->parent; } return NULL; } #ifdef CONFIG_PCI static inline int is_pci_dev(struct device *dev) { return dev->bus == &pci_bus_type; } #else static inline int is_pci_dev(struct device *dev) { return 0; } #endif /* * get_node_path fills in @path with the firmware path to the device. * Note that if @node is a parisc device, we don't fill in the 'mod' field. * This is because both callers pass the parent and fill in the mod * themselves. If @node is a PCI device, we do fill it in, even though this * is inconsistent. */ static void get_node_path(struct device *dev, struct hardware_path *path) { int i = 5; memset(&path->bc, -1, 6); if (is_pci_dev(dev)) { unsigned int devfn = to_pci_dev(dev)->devfn; path->mod = PCI_FUNC(devfn); path->bc[i--] = PCI_SLOT(devfn); dev = dev->parent; } while (dev != &root) { if (is_pci_dev(dev)) { unsigned int devfn = to_pci_dev(dev)->devfn; path->bc[i--] = PCI_SLOT(devfn) | (PCI_FUNC(devfn)<< 5); } else if (dev->bus == &parisc_bus_type) { path->bc[i--] = to_parisc_device(dev)->hw_path; } dev = dev->parent; } } static char *print_hwpath(struct hardware_path *path, char *output) { int i;


context:
space:
mode: