精华内容
下载资源
问答
  • Amd gpu

    2021-01-11 04:24:51
    <div><p>I have followed the instructions in the docs to install for AMD gpu and after building it shows "opencl: NO" <p>Also when trying to run john with one of the -opencl options such as ...
  • amd gpu

    2020-12-07 08:43:58
    <div><p>now that it has become "... does it support acceleration also on amd boards as it was in the past with mods?</p><p>该提问来源于开源项目:NVIDIAGameWorks/PhysX</p></div>
  • AMD GPU

    2020-11-30 11:20:05
    <div><p>GPU mining not working: <pre><code> <info> found 2 devices <info> compiling ... <info> source: 0 bytes <error> source files not found or empty </error></info&...
  • AMDGPU时钟 介绍 这是一个简单的脚本,可用于为由amdgpu Linux内核驱动程序驱动的最新AMD GPU设置自定义电源状态。 假设驱动程序中启用了Radeon OverDrive,则脚本可以设置自定义时钟,电压和其他一些电源状态。 从...
  • AMDGPU.jl Julia中的AMD GPU(ROCm)编程 文献资料 建置状态 快速开始 可以与Julia软件包管理器一起安装AMDGPU.jl。 在Julia REPL中,键入]进入Pkg REPL模式并运行: pkg> add AMDGPU 或者,等效地,通过Pkg API:...
  • sudo pip3 install amdgpu-fan Arch Linux 可在aur中以amdgpu-fan 用法: sudo amdgpu-fan 配置: # /etc/amdgpu-fan.yml # eg: speed_matrix: # -[temp(*C), speed(0-100%)] - [0, 0] - [40, 30] - [60, 50] ...
  • <div><p>With amdgpu.dc=0 (disabled) ddcutil works correctly for adjusting all monitor settings. I need amdgpu.dc=1 to have audio through displayport to my monitor. When booted with amdgpu.dc&#...
  • drivers/gpu/drm/amd/amdgpu/../display/amdgpu_dm/amdgpu_dm_pp_smu.c:336:8: warning: implicit conversion from enumeration type 'enum smu_clk_type' to different enumeration type 'enum amd_pp_...
  • vfio-单amdgpu直通 此存储库是针对单个AMD gpu直通到各种qemu VM的教程。 在阅读了和一些精彩文章后,我想尝试一下,不幸的是,这里并没有关于AMD GPU的说明,只是警告了可怕的重置错误。 因此,这将是我为回馈爱好...
  • Fix GPU usage with AMDGPU

    2020-12-25 22:36:53
    <div><p>As reminder, the bug is <code>radeon-profile</code> shows 0% for GPU usage with AMDGPU: ...
  • Add amdgpu support

    2021-01-05 04:18:55
    <div><p>amdgpu - kernel module amdgpu - ddx driver pm and fan control It is the same as with radeon</p><p>该提问来源于开源项目:marazmista/radeon-profile</p></div>
  • LLVM AMD GPU

    2020-12-26 13:31:32
    AMD GPU". I'm not really sure what this means but it came into my mind that it maybe means that pocl can use this target to execute OpenCL kernel on AMD GPUS? <p>That would be really nice as ...
  • AMDGPU support

    2020-12-08 19:27:16
    Made my own fork with AMDGPU support. https://github.com/Veske/gnome-shell-extension-freon</p> <p>If maintainer comes back, please pull changes in.</p><p>该提问来源于开源项目:UshakovVasilii/...
  • amdgpu module crash

    2020-12-08 22:57:42
    [ 1.975824] amdgpu 0000:04:00.0: amdgpu: SMU is initialized successfully! [ 1.977241] [drm] kiq ring mec 2 pipe 1 q 0 [ 1.977727] ------------[ cut here ]------------ [ 1.977806] WARNING: CPU: 6 PID: ...
  • Ubuntu 安装 AMD GPU 驱动

    万次阅读 2019-06-26 21:19:30
    Ubuntu 安装 AMD GPU 驱动 环境申明 Ubuntu18.04 AMD-RX580 显卡 AMD 官网下载驱动 https://www.amd.com/en/support ...$ tar -Jxvf amdgpu-pro-YY.XX-NNNNNN.tar.xz $ cd ~/Download...

    基于环境

    • Ubuntu18.04
    • AMD-RX580 显卡

    AMD 官网下载驱动

    https://www.amd.com/en/support
    

    在这里插入图片描述

    将驱动上传到 Ubuntu 系统并解压

    $ cd ~/Downloads
    $ tar -Jxvf amdgpu-pro-YY.XX-NNNNNN.tar.xz
    $ cd ~/Downloads/amdgpu-pro-YY.XX-NNNNNN
    

    开始安装 AMD 显卡驱动

    $ ./amdgpu-pro-install -y
    

    安装 radeontop 显示 AMD GPU 使用情况

    $ apt install radeontop
    
    $ radeontop
    

    在这里插入图片描述

    展开全文
  • m on a MacBook Pro 13,3 and currently running <code>5.0.0-32-generic</code> wich allows me to load <strong>amdgpu</strong> and turn it off doing the following: <pre><code>bash gpu-manager | grep '...
  • AMD GPU support

    2020-12-29 07:18:11
    <div><p>Someone asked me about deal.II support for AMD GPU recently, so I looked how we could support both type of GPUs. The good news is that HIP C++ (AMD's language) is extremely close ...
  • INTRODUCTION TO AMD GPU PROGRAMMING WITH HIP Paul Bauman, Noel Chalmers, Nick Curtis, Chip Freitag, Joe Greathouse, Nicholas Malaya, Damon McDougall, Scott Moe, René van Oostrum, Noah Wolfe9/6/...
  • lib /固件/ amdgpu 修复W: Possible missing firmware /lib/firmware/amdgpu/ 修复步骤 打开终端,逐步复制并插入这些逗号。 第1步git clone "https://github.com/Ritwikrajsingh/linux-firmware-amdgpu.git" ...
  • amdgpu and have error: <pre><code> VK_ICD_FILENAMES=/etc/vulkan/icd.d/amd_icd64.json vulkaninfo amdgpu_device_initialize: DRM version is 2.50.0 but this driver is only compatible with 3.x.x. ...
  • CONFIG_DRM_AMDGPU=y CONFIG_DRM_AMDGPU_SI=y CONFIG_DRM_AMDGPU_CIK=y CONFIG_DRM_AMDGPU_USERPTR=y CONFIG_DRM_AMDGPU_GART_DEBUGFS=y CONFIG_DRM_AMD_ACP=y causes tons of linkage ...
  • drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c module_init(amdgpu_init); module_exit(amdgpu_exit); MODULE_AUTHOR(DRIVER_AUTHOR); MODULE_DESCRIPTION(DRIVER_DESC); MODULE_LICENSE("GPL and additional rights...

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

    module_init(amdgpu_init);
    module_exit(amdgpu_exit);
    
    MODULE_AUTHOR(DRIVER_AUTHOR);
    MODULE_DESCRIPTION(DRIVER_DESC);
    MODULE_LICENSE("GPL and additional rights");

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

    static void __exit amdgpu_exit(void)
    {
    	amdgpu_amdkfd_fini();
    	pci_unregister_driver(pdriver);
    	amdgpu_unregister_atpx_handler();
    	amdgpu_sync_fini();
    	amdgpu_fence_slab_fini();
    }
    static int __init amdgpu_init(void)
    {
    	int r;
    
    	if (vgacon_text_force()) {
    		DRM_ERROR("VGACON disables amdgpu kernel modesetting.\n");
    		return -EINVAL;
    	}
    
    	r = amdgpu_sync_init();
    	if (r)
    		goto error_sync;
    
    	r = amdgpu_fence_slab_init();
    	if (r)
    		goto error_fence;
    
    	DRM_INFO("amdgpu kernel modesetting enabled.\n");
    	driver = &kms_driver;
    	pdriver = &amdgpu_kms_pci_driver;
    	driver->num_ioctls = amdgpu_max_kms_ioctl;
    	amdgpu_register_atpx_handler();
    	/* let modprobe override vga console setting */
    	return pci_register_driver(pdriver);
    
    error_fence:
    	amdgpu_sync_fini();
    
    error_sync:
    	return r;
    }

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

    static struct drm_driver *driver;
    static struct pci_driver *pdriver;
    static struct drm_driver kms_driver = {
    	.driver_features =
    	    DRIVER_USE_AGP |
    	    DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_GEM |
    	    DRIVER_PRIME | DRIVER_RENDER | DRIVER_MODESET | DRIVER_SYNCOBJ,
    	.load = amdgpu_driver_load_kms,
    	.open = amdgpu_driver_open_kms,
    	.postclose = amdgpu_driver_postclose_kms,
    	.lastclose = amdgpu_driver_lastclose_kms,
    	.unload = amdgpu_driver_unload_kms,
    	.get_vblank_counter = amdgpu_get_vblank_counter_kms,
    	.enable_vblank = amdgpu_enable_vblank_kms,
    	.disable_vblank = amdgpu_disable_vblank_kms,
    	.get_vblank_timestamp = drm_calc_vbltimestamp_from_scanoutpos,
    	.get_scanout_position = amdgpu_get_crtc_scanout_position,
    	.irq_handler = amdgpu_irq_handler,
    	.ioctls = amdgpu_ioctls_kms,
    	.gem_free_object_unlocked = amdgpu_gem_object_free,
    	.gem_open_object = amdgpu_gem_object_open,
    	.gem_close_object = amdgpu_gem_object_close,
    	.dumb_create = amdgpu_mode_dumb_create,
    	.dumb_map_offset = amdgpu_mode_dumb_mmap,
    	.fops = &amdgpu_driver_kms_fops,
    
    	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
    	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
    	.gem_prime_export = amdgpu_gem_prime_export,
    	.gem_prime_import = amdgpu_gem_prime_import,
    	.gem_prime_res_obj = amdgpu_gem_prime_res_obj,
    	.gem_prime_get_sg_table = amdgpu_gem_prime_get_sg_table,
    	.gem_prime_import_sg_table = amdgpu_gem_prime_import_sg_table,
    	.gem_prime_vmap = amdgpu_gem_prime_vmap,
    	.gem_prime_vunmap = amdgpu_gem_prime_vunmap,
    	.gem_prime_mmap = amdgpu_gem_prime_mmap,
    
    	.name = DRIVER_NAME,
    	.desc = DRIVER_DESC,
    	.date = DRIVER_DATE,
    	.major = KMS_DRIVER_MAJOR,
    	.minor = KMS_DRIVER_MINOR,
    	.patchlevel = KMS_DRIVER_PATCHLEVEL,
    };
    static struct pci_driver amdgpu_kms_pci_driver = {
    	.name = DRIVER_NAME,
    	.id_table = pciidlist,
    	.probe = amdgpu_pci_probe,
    	.remove = amdgpu_pci_remove,
    	.shutdown = amdgpu_pci_shutdown,
    	.driver.pm = &amdgpu_pm_ops,
    };

    include/drm/drm_drv.h

    /**
     * struct drm_driver - DRM driver structure
     *
     * This structure represent the common code for a family of cards. There will
     * one drm_device for each card present in this family. It contains lots of
     * vfunc entries, and a pile of those probably should be moved to more
     * appropriate places like &drm_mode_config_funcs or into a new operations
     * structure for GEM drivers.
     */
    struct drm_driver {
    	/**
    	 * @load:
    	 *
    	 * Backward-compatible driver callback to complete
    	 * initialization steps after the driver is registered.  For
    	 * this reason, may suffer from race conditions and its use is
    	 * deprecated for new drivers.  It is therefore only supported
    	 * for existing drivers not yet converted to the new scheme.
    	 * See drm_dev_init() and drm_dev_register() for proper and
    	 * race-free way to set up a &struct drm_device.
    	 *
    	 * This is deprecated, do not use!
    	 *
    	 * Returns:
    	 *
    	 * Zero on success, non-zero value on failure.
    	 */
    	int (*load) (struct drm_device *, unsigned long flags);
    
    	/**
    	 * @open:
    	 *
    	 * Driver callback when a new &struct drm_file is opened. Useful for
    	 * setting up driver-private data structures like buffer allocators,
    	 * execution contexts or similar things. Such driver-private resources
    	 * must be released again in @postclose.
    	 *
    	 * Since the display/modeset side of DRM can only be owned by exactly
    	 * one &struct drm_file (see &drm_file.is_master and &drm_device.master)
    	 * there should never be a need to set up any modeset related resources
    	 * in this callback. Doing so would be a driver design bug.
    	 *
    	 * Returns:
    	 *
    	 * 0 on success, a negative error code on failure, which will be
    	 * promoted to userspace as the result of the open() system call.
    	 */
    	int (*open) (struct drm_device *, struct drm_file *);
    
    	/**
    	 * @postclose:
    	 *
    	 * One of the driver callbacks when a new &struct drm_file is closed.
    	 * Useful for tearing down driver-private data structures allocated in
    	 * @open like buffer allocators, execution contexts or similar things.
    	 *
    	 * Since the display/modeset side of DRM can only be owned by exactly
    	 * one &struct drm_file (see &drm_file.is_master and &drm_device.master)
    	 * there should never be a need to tear down any modeset related
    	 * resources in this callback. Doing so would be a driver design bug.
    	 */
    	void (*postclose) (struct drm_device *, struct drm_file *);
    
    	/**
    	 * @lastclose:
    	 *
    	 * Called when the last &struct drm_file has been closed and there's
    	 * currently no userspace client for the &struct drm_device.
    	 *
    	 * Modern drivers should only use this to force-restore the fbdev
    	 * framebuffer using drm_fb_helper_restore_fbdev_mode_unlocked().
    	 * Anything else would indicate there's something seriously wrong.
    	 * Modern drivers can also use this to execute delayed power switching
    	 * state changes, e.g. in conjunction with the :ref:`vga_switcheroo`
    	 * infrastructure.
    	 *
    	 * This is called after @postclose hook has been called.
    	 *
    	 * NOTE:
    	 *
    	 * All legacy drivers use this callback to de-initialize the hardware.
    	 * This is purely because of the shadow-attach model, where the DRM
    	 * kernel driver does not really own the hardware. Instead ownershipe is
    	 * handled with the help of userspace through an inheritedly racy dance
    	 * to set/unset the VT into raw mode.
    	 *
    	 * Legacy drivers initialize the hardware in the @firstopen callback,
    	 * which isn't even called for modern drivers.
    	 */
    	void (*lastclose) (struct drm_device *);
    
    	/**
    	 * @unload:
    	 *
    	 * Reverse the effects of the driver load callback.  Ideally,
    	 * the clean up performed by the driver should happen in the
    	 * reverse order of the initialization.  Similarly to the load
    	 * hook, this handler is deprecated and its usage should be
    	 * dropped in favor of an open-coded teardown function at the
    	 * driver layer.  See drm_dev_unregister() and drm_dev_put()
    	 * for the proper way to remove a &struct drm_device.
    	 *
    	 * The unload() hook is called right after unregistering
    	 * the device.
    	 *
    	 */
    	void (*unload) (struct drm_device *);
    
    	/**
    	 * @release:
    	 *
    	 * Optional callback for destroying device data after the final
    	 * reference is released, i.e. the device is being destroyed. Drivers
    	 * using this callback are responsible for calling drm_dev_fini()
    	 * to finalize the device and then freeing the struct themselves.
    	 */
    	void (*release) (struct drm_device *);
    
    	/**
    	 * @get_vblank_counter:
    	 *
    	 * Driver callback for fetching a raw hardware vblank counter for the
    	 * CRTC specified with the pipe argument.  If a device doesn't have a
    	 * hardware counter, the driver can simply leave the hook as NULL.
    	 * The DRM core will account for missed vblank events while interrupts
    	 * where disabled based on system timestamps.
    	 *
    	 * Wraparound handling and loss of events due to modesetting is dealt
    	 * with in the DRM core code, as long as drivers call
    	 * drm_crtc_vblank_off() and drm_crtc_vblank_on() when disabling or
    	 * enabling a CRTC.
    	 *
    	 * This is deprecated and should not be used by new drivers.
    	 * Use &drm_crtc_funcs.get_vblank_counter instead.
    	 *
    	 * Returns:
    	 *
    	 * Raw vblank counter value.
    	 */
    	u32 (*get_vblank_counter) (struct drm_device *dev, unsigned int pipe);
    
    	/**
    	 * @enable_vblank:
    	 *
    	 * Enable vblank interrupts for the CRTC specified with the pipe
    	 * argument.
    	 *
    	 * This is deprecated and should not be used by new drivers.
    	 * Use &drm_crtc_funcs.enable_vblank instead.
    	 *
    	 * Returns:
    	 *
    	 * Zero on success, appropriate errno if the given @crtc's vblank
    	 * interrupt cannot be enabled.
    	 */
    	int (*enable_vblank) (struct drm_device *dev, unsigned int pipe);
    
    	/**
    	 * @disable_vblank:
    	 *
    	 * Disable vblank interrupts for the CRTC specified with the pipe
    	 * argument.
    	 *
    	 * This is deprecated and should not be used by new drivers.
    	 * Use &drm_crtc_funcs.disable_vblank instead.
    	 */
    	void (*disable_vblank) (struct drm_device *dev, unsigned int pipe);
    
    	/**
    	 * @get_scanout_position:
    	 *
    	 * Called by vblank timestamping code.
    	 *
    	 * Returns the current display scanout position from a crtc, and an
    	 * optional accurate ktime_get() timestamp of when position was
    	 * measured. Note that this is a helper callback which is only used if a
    	 * driver uses drm_calc_vbltimestamp_from_scanoutpos() for the
    	 * @get_vblank_timestamp callback.
    	 *
    	 * Parameters:
    	 *
    	 * dev:
    	 *     DRM device.
    	 * pipe:
    	 *     Id of the crtc to query.
    	 * in_vblank_irq:
    	 *     True when called from drm_crtc_handle_vblank().  Some drivers
    	 *     need to apply some workarounds for gpu-specific vblank irq quirks
    	 *     if flag is set.
    	 * vpos:
    	 *     Target location for current vertical scanout position.
    	 * hpos:
    	 *     Target location for current horizontal scanout position.
    	 * stime:
    	 *     Target location for timestamp taken immediately before
    	 *     scanout position query. Can be NULL to skip timestamp.
    	 * etime:
    	 *     Target location for timestamp taken immediately after
    	 *     scanout position query. Can be NULL to skip timestamp.
    	 * mode:
    	 *     Current display timings.
    	 *
    	 * Returns vpos as a positive number while in active scanout area.
    	 * Returns vpos as a negative number inside vblank, counting the number
    	 * of scanlines to go until end of vblank, e.g., -1 means "one scanline
    	 * until start of active scanout / end of vblank."
    	 *
    	 * Returns:
    	 *
    	 * True on success, false if a reliable scanout position counter could
    	 * not be read out.
    	 *
    	 * FIXME:
    	 *
    	 * Since this is a helper to implement @get_vblank_timestamp, we should
    	 * move it to &struct drm_crtc_helper_funcs, like all the other
    	 * helper-internal hooks.
    	 */
    	bool (*get_scanout_position) (struct drm_device *dev, unsigned int pipe,
    				      bool in_vblank_irq, int *vpos, int *hpos,
    				      ktime_t *stime, ktime_t *etime,
    				      const struct drm_display_mode *mode);
    
    	/**
    	 * @get_vblank_timestamp:
    	 *
    	 * Called by drm_get_last_vbltimestamp(). Should return a precise
    	 * timestamp when the most recent VBLANK interval ended or will end.
    	 *
    	 * Specifically, the timestamp in @vblank_time should correspond as
    	 * closely as possible to the time when the first video scanline of
    	 * the video frame after the end of VBLANK will start scanning out,
    	 * the time immediately after end of the VBLANK interval. If the
    	 * @crtc is currently inside VBLANK, this will be a time in the future.
    	 * If the @crtc is currently scanning out a frame, this will be the
    	 * past start time of the current scanout. This is meant to adhere
    	 * to the OpenML OML_sync_control extension specification.
    	 *
    	 * Paramters:
    	 *
    	 * dev:
    	 *     dev DRM device handle.
    	 * pipe:
    	 *     crtc for which timestamp should be returned.
    	 * max_error:
    	 *     Maximum allowable timestamp error in nanoseconds.
    	 *     Implementation should strive to provide timestamp
    	 *     with an error of at most max_error nanoseconds.
    	 *     Returns true upper bound on error for timestamp.
    	 * vblank_time:
    	 *     Target location for returned vblank timestamp.
    	 * in_vblank_irq:
    	 *     True when called from drm_crtc_handle_vblank().  Some drivers
    	 *     need to apply some workarounds for gpu-specific vblank irq quirks
    	 *     if flag is set.
    	 *
    	 * Returns:
    	 *
    	 * True on success, false on failure, which means the core should
    	 * fallback to a simple timestamp taken in drm_crtc_handle_vblank().
    	 *
    	 * FIXME:
    	 *
    	 * We should move this hook to &struct drm_crtc_funcs like all the other
    	 * vblank hooks.
    	 */
    	bool (*get_vblank_timestamp) (struct drm_device *dev, unsigned int pipe,
    				     int *max_error,
    				     ktime_t *vblank_time,
    				     bool in_vblank_irq);
    
    	/**
    	 * @irq_handler:
    	 *
    	 * Interrupt handler called when using drm_irq_install(). Not used by
    	 * drivers which implement their own interrupt handling.
    	 */
    	irqreturn_t(*irq_handler) (int irq, void *arg);
    
    	/**
    	 * @irq_preinstall:
    	 *
    	 * Optional callback used by drm_irq_install() which is called before
    	 * the interrupt handler is registered. This should be used to clear out
    	 * any pending interrupts (from e.g. firmware based drives) and reset
    	 * the interrupt handling registers.
    	 */
    	void (*irq_preinstall) (struct drm_device *dev);
    
    	/**
    	 * @irq_postinstall:
    	 *
    	 * Optional callback used by drm_irq_install() which is called after
    	 * the interrupt handler is registered. This should be used to enable
    	 * interrupt generation in the hardware.
    	 */
    	int (*irq_postinstall) (struct drm_device *dev);
    
    	/**
    	 * @irq_uninstall:
    	 *
    	 * Optional callback used by drm_irq_uninstall() which is called before
    	 * the interrupt handler is unregistered. This should be used to disable
    	 * interrupt generation in the hardware.
    	 */
    	void (*irq_uninstall) (struct drm_device *dev);
    
    	/**
    	 * @master_create:
    	 *
    	 * Called whenever a new master is created. Only used by vmwgfx.
    	 */
    	int (*master_create)(struct drm_device *dev, struct drm_master *master);
    
    	/**
    	 * @master_destroy:
    	 *
    	 * Called whenever a master is destroyed. Only used by vmwgfx.
    	 */
    	void (*master_destroy)(struct drm_device *dev, struct drm_master *master);
    
    	/**
    	 * @master_set:
    	 *
    	 * Called whenever the minor master is set. Only used by vmwgfx.
    	 */
    	int (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
    			  bool from_open);
    	/**
    	 * @master_drop:
    	 *
    	 * Called whenever the minor master is dropped. Only used by vmwgfx.
    	 */
    	void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv);
    
    	/**
    	 * @debugfs_init:
    	 *
    	 * Allows drivers to create driver-specific debugfs files.
    	 */
    	int (*debugfs_init)(struct drm_minor *minor);
    
    	/**
    	 * @gem_free_object: deconstructor for drm_gem_objects
    	 *
    	 * This is deprecated and should not be used by new drivers. Use
    	 * @gem_free_object_unlocked instead.
    	 */
    	void (*gem_free_object) (struct drm_gem_object *obj);
    
    	/**
    	 * @gem_free_object_unlocked: deconstructor for drm_gem_objects
    	 *
    	 * This is for drivers which are not encumbered with &drm_device.struct_mutex
    	 * legacy locking schemes. Use this hook instead of @gem_free_object.
    	 */
    	void (*gem_free_object_unlocked) (struct drm_gem_object *obj);
    
    	/**
    	 * @gem_open_object:
    	 *
    	 * Driver hook called upon gem handle creation
    	 */
    	int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
    
    	/**
    	 * @gem_close_object:
    	 *
    	 * Driver hook called upon gem handle release
    	 */
    	void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);
    
    	/**
    	 * @gem_print_info:
    	 *
    	 * If driver subclasses struct &drm_gem_object, it can implement this
    	 * optional hook for printing additional driver specific info.
    	 *
    	 * drm_printf_indent() should be used in the callback passing it the
    	 * indent argument.
    	 *
    	 * This callback is called from drm_gem_print_info().
    	 */
    	void (*gem_print_info)(struct drm_printer *p, unsigned int indent,
    			       const struct drm_gem_object *obj);
    
    	/**
    	 * @gem_create_object: constructor for gem objects
    	 *
    	 * Hook for allocating the GEM object struct, for use by core
    	 * helpers.
    	 */
    	struct drm_gem_object *(*gem_create_object)(struct drm_device *dev,
    						    size_t size);
    
    	/* prime: */
    	/**
    	 * @prime_handle_to_fd:
    	 *
    	 * export handle -> fd (see drm_gem_prime_handle_to_fd() helper)
    	 */
    	int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
    				uint32_t handle, uint32_t flags, int *prime_fd);
    	/**
    	 * @prime_fd_to_handle:
    	 *
    	 * import fd -> handle (see drm_gem_prime_fd_to_handle() helper)
    	 */
    	int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
    				int prime_fd, uint32_t *handle);
    	/**
    	 * @gem_prime_export:
    	 *
    	 * export GEM -> dmabuf
    	 */
    	struct dma_buf * (*gem_prime_export)(struct drm_device *dev,
    				struct drm_gem_object *obj, int flags);
    	/**
    	 * @gem_prime_import:
    	 *
    	 * import dmabuf -> GEM
    	 */
    	struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
    				struct dma_buf *dma_buf);
    	int (*gem_prime_pin)(struct drm_gem_object *obj);
    	void (*gem_prime_unpin)(struct drm_gem_object *obj);
    	struct reservation_object * (*gem_prime_res_obj)(
    				struct drm_gem_object *obj);
    	struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj);
    	struct drm_gem_object *(*gem_prime_import_sg_table)(
    				struct drm_device *dev,
    				struct dma_buf_attachment *attach,
    				struct sg_table *sgt);
    	void *(*gem_prime_vmap)(struct drm_gem_object *obj);
    	void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr);
    	int (*gem_prime_mmap)(struct drm_gem_object *obj,
    				struct vm_area_struct *vma);
    
    	/**
    	 * @dumb_create:
    	 *
    	 * This creates a new dumb buffer in the driver's backing storage manager (GEM,
    	 * TTM or something else entirely) and returns the resulting buffer handle. This
    	 * handle can then be wrapped up into a framebuffer modeset object.
    	 *
    	 * Note that userspace is not allowed to use such objects for render
    	 * acceleration - drivers must create their own private ioctls for such a use
    	 * case.
    	 *
    	 * Width, height and depth are specified in the &drm_mode_create_dumb
    	 * argument. The callback needs to fill the handle, pitch and size for
    	 * the created buffer.
    	 *
    	 * Called by the user via ioctl.
    	 *
    	 * Returns:
    	 *
    	 * Zero on success, negative errno on failure.
    	 */
    	int (*dumb_create)(struct drm_file *file_priv,
    			   struct drm_device *dev,
    			   struct drm_mode_create_dumb *args);
    	/**
    	 * @dumb_map_offset:
    	 *
    	 * Allocate an offset in the drm device node's address space to be able to
    	 * memory map a dumb buffer. GEM-based drivers must use
    	 * drm_gem_create_mmap_offset() to implement this.
    	 *
    	 * Called by the user via ioctl.
    	 *
    	 * Returns:
    	 *
    	 * Zero on success, negative errno on failure.
    	 */
    	int (*dumb_map_offset)(struct drm_file *file_priv,
    			       struct drm_device *dev, uint32_t handle,
    			       uint64_t *offset);
    	/**
    	 * @dumb_destroy:
    	 *
    	 * This destroys the userspace handle for the given dumb backing storage buffer.
    	 * Since buffer objects must be reference counted in the kernel a buffer object
    	 * won't be immediately freed if a framebuffer modeset object still uses it.
    	 *
    	 * Called by the user via ioctl.
    	 *
    	 * Returns:
    	 *
    	 * Zero on success, negative errno on failure.
    	 */
    	int (*dumb_destroy)(struct drm_file *file_priv,
    			    struct drm_device *dev,
    			    uint32_t handle);
    
    	/**
    	 * @gem_vm_ops: Driver private ops for this object
    	 */
    	const struct vm_operations_struct *gem_vm_ops;
    
    	/** @major: driver major number */
    	int major;
    	/** @minor: driver minor number */
    	int minor;
    	/** @patchlevel: driver patch level */
    	int patchlevel;
    	/** @name: driver name */
    	char *name;
    	/** @desc: driver description */
    	char *desc;
    	/** @date: driver date */
    	char *date;
    
    	/** @driver_features: driver features */
    	u32 driver_features;
    
    	/**
    	 * @ioctls:
    	 *
    	 * Array of driver-private IOCTL description entries. See the chapter on
    	 * :ref:`IOCTL support in the userland interfaces
    	 * chapter<drm_driver_ioctl>` for the full details.
    	 */
    
    	const struct drm_ioctl_desc *ioctls;
    	/** @num_ioctls: Number of entries in @ioctls. */
    	int num_ioctls;
    
    	/**
    	 * @fops:
    	 *
    	 * File operations for the DRM device node. See the discussion in
    	 * :ref:`file operations<drm_driver_fops>` for in-depth coverage and
    	 * some examples.
    	 */
    	const struct file_operations *fops;
    
    	/* Everything below here is for legacy driver, never use! */
    	/* private: */
    
    	/* List of devices hanging off this driver with stealth attach. */
    	struct list_head legacy_dev_list;
    	int (*firstopen) (struct drm_device *);
    	void (*preclose) (struct drm_device *, struct drm_file *file_priv);
    	int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
    	int (*dma_quiescent) (struct drm_device *);
    	int (*context_dtor) (struct drm_device *dev, int context);
    	int dev_priv_size;
    };

    include/linux/pci.h

    struct pci_driver {
    	struct list_head	node;
    	const char		*name;
    	const struct pci_device_id *id_table;	/* Must be non-NULL for probe to be called */
    	int  (*probe)(struct pci_dev *dev, const struct pci_device_id *id);	/* New device inserted */
    	void (*remove)(struct pci_dev *dev);	/* Device removed (NULL if not a hot-plug capable driver) */
    	int  (*suspend)(struct pci_dev *dev, pm_message_t state);	/* Device suspended */
    	int  (*suspend_late)(struct pci_dev *dev, pm_message_t state);
    	int  (*resume_early)(struct pci_dev *dev);
    	int  (*resume) (struct pci_dev *dev);	/* Device woken up */
    	void (*shutdown) (struct pci_dev *dev);
    	int  (*sriov_configure) (struct pci_dev *dev, int num_vfs); /* On PF */
    	const struct pci_error_handlers *err_handler;
    	const struct attribute_group **groups;
    	struct device_driver	driver;
    	struct pci_dynids	dynids;
    };

     

    展开全文
  • CC drivers/gpu/drm/amd/amdgpu/gmc_v8_0.o drivers/gpu/drm/amd/amdgpu/gmc_v8_0.c:1447:41: warning: suggest braces around initialization of subobject [-Wmissing-braces] struct amdgpu_task_info task_...
  • amdgpu-fancontrol-源码

    2021-05-08 08:11:54
    amdgpu-fancontrol 简单的bash脚本可控制AMD Radeon显卡风扇pwm。 根据需要在脚本中调整temp / pwm值和滞后/间隔。 可能还需要其他调整,例如正确的hwmon路径。 该脚本最初只是作为示例。 请不要天真地运行它,并...
  • support for amdgpu sensor

    2020-12-01 23:49:29
    <div><p>could you add gpu icon for amdgpu driver? <p><code>let isGpuDriver = this._output[i].indexOf("radeon") != -1 || this._output[i].indexOf("amdgpu") != -1 || this._...
  • linux下的AMDGPU驱动源码,可以编译为arm目标平台,需要在Makefile中配置
  • <div><p>I found when building OpenMM 6.2 on Windows with AMD APP SDK 2.9 instead of NVIDIA CUDA 6.5 then running FahBench 2.0.2 is 40% faster on AMD GPU R9 280. see ...
  • <div><ol><li>Changed Makefile to enable compile flag WITH_AMDGPU</li><li>Changed CodeGen_LLVM file to check if intializing amdgpu works or not</li></ol> <p>Need to enable AMDGPU backend when building ...
  • <div><p>On a ppc64el system with this kernel and a WX7100 (Polaris) card, loading the <code>amdgpu</code> module results in a kernel oops. Note that the upstream Linux 4.15 <code>amdgpu</code> module ...
  • 0xe3/0x190 [amdgpu] Code: f2 0f 58 05 37 8a 16 00 f2 48 0f 2c c0 31 d2 41 f7 f6 e9 a0 00 00 00 f2 0f 58 05 20 8a 16 00 44 89 f0 0f 57 c9 f2 48 0f 2a c8 <66> 0f 29 4d d0 f2 0f 5e c1 f2 0f 5a c0 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,274
精华内容 2,109
关键字:

amdgpu