2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* Copyright 2008 Advanced Micro Devices, Inc.
|
|
|
|
* Copyright 2008 Red Hat Inc.
|
|
|
|
* Copyright 2009 Jerome Glisse.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
* Authors: Dave Airlie
|
|
|
|
* Alex Deucher
|
|
|
|
* Jerome Glisse
|
|
|
|
*/
|
|
|
|
#ifndef __AMDGPU_H__
|
|
|
|
#define __AMDGPU_H__
|
|
|
|
|
|
|
|
#include <linux/atomic.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/kref.h>
|
2017-03-30 20:03:59 +08:00
|
|
|
#include <linux/rbtree.h>
|
2015-04-21 04:51:00 +08:00
|
|
|
#include <linux/hashtable.h>
|
2016-10-25 20:00:45 +08:00
|
|
|
#include <linux/dma-fence.h>
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
#include <ttm/ttm_bo_api.h>
|
|
|
|
#include <ttm/ttm_bo_driver.h>
|
|
|
|
#include <ttm/ttm_placement.h>
|
|
|
|
#include <ttm/ttm_module.h>
|
|
|
|
#include <ttm/ttm_execbuf_util.h>
|
|
|
|
|
2015-07-29 02:20:03 +08:00
|
|
|
#include <drm/drmP.h>
|
2015-04-21 04:51:00 +08:00
|
|
|
#include <drm/drm_gem.h>
|
2015-04-24 17:37:30 +08:00
|
|
|
#include <drm/amdgpu_drm.h>
|
2015-04-21 04:51:00 +08:00
|
|
|
|
2015-05-23 02:39:35 +08:00
|
|
|
#include "amd_shared.h"
|
2015-04-21 04:51:00 +08:00
|
|
|
#include "amdgpu_mode.h"
|
|
|
|
#include "amdgpu_ih.h"
|
|
|
|
#include "amdgpu_irq.h"
|
|
|
|
#include "amdgpu_ucode.h"
|
2016-08-02 11:32:41 +08:00
|
|
|
#include "amdgpu_ttm.h"
|
2017-03-04 07:37:23 +08:00
|
|
|
#include "amdgpu_psp.h"
|
2015-04-21 04:51:00 +08:00
|
|
|
#include "amdgpu_gds.h"
|
2016-09-28 18:36:44 +08:00
|
|
|
#include "amdgpu_sync.h"
|
2016-09-28 21:33:18 +08:00
|
|
|
#include "amdgpu_ring.h"
|
2016-09-28 21:41:50 +08:00
|
|
|
#include "amdgpu_vm.h"
|
2015-12-03 06:46:21 +08:00
|
|
|
#include "amd_powerplay.h"
|
2016-10-07 23:40:09 +08:00
|
|
|
#include "amdgpu_dpm.h"
|
2015-09-23 05:05:20 +08:00
|
|
|
#include "amdgpu_acp.h"
|
2017-01-02 23:07:33 +08:00
|
|
|
#include "amdgpu_uvd.h"
|
2017-01-11 00:02:58 +08:00
|
|
|
#include "amdgpu_vce.h"
|
2015-04-21 04:51:00 +08:00
|
|
|
|
2015-08-17 10:55:02 +08:00
|
|
|
#include "gpu_scheduler.h"
|
2016-09-19 12:13:58 +08:00
|
|
|
#include "amdgpu_virt.h"
|
2015-08-17 10:55:02 +08:00
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* Modules parameters.
|
|
|
|
*/
|
|
|
|
extern int amdgpu_modeset;
|
|
|
|
extern int amdgpu_vram_limit;
|
|
|
|
extern int amdgpu_gart_size;
|
2016-08-18 05:49:27 +08:00
|
|
|
extern int amdgpu_moverate;
|
2015-04-21 04:51:00 +08:00
|
|
|
extern int amdgpu_benchmarking;
|
|
|
|
extern int amdgpu_testing;
|
|
|
|
extern int amdgpu_audio;
|
|
|
|
extern int amdgpu_disp_priority;
|
|
|
|
extern int amdgpu_hw_i2c;
|
|
|
|
extern int amdgpu_pcie_gen2;
|
|
|
|
extern int amdgpu_msi;
|
|
|
|
extern int amdgpu_lockup_timeout;
|
|
|
|
extern int amdgpu_dpm;
|
2016-11-01 15:35:38 +08:00
|
|
|
extern int amdgpu_fw_load_type;
|
2015-04-21 04:51:00 +08:00
|
|
|
extern int amdgpu_aspm;
|
|
|
|
extern int amdgpu_runtime_pm;
|
|
|
|
extern unsigned amdgpu_ip_block_mask;
|
|
|
|
extern int amdgpu_bapm;
|
|
|
|
extern int amdgpu_deep_color;
|
|
|
|
extern int amdgpu_vm_size;
|
|
|
|
extern int amdgpu_vm_block_size;
|
2015-09-28 18:31:26 +08:00
|
|
|
extern int amdgpu_vm_fault_stop;
|
2015-09-10 20:00:35 +08:00
|
|
|
extern int amdgpu_vm_debug;
|
2015-07-30 16:36:58 +08:00
|
|
|
extern int amdgpu_sched_jobs;
|
2015-07-30 16:44:05 +08:00
|
|
|
extern int amdgpu_sched_hw_submission;
|
2016-11-02 13:38:37 +08:00
|
|
|
extern int amdgpu_no_evict;
|
|
|
|
extern int amdgpu_direct_gma_size;
|
2016-02-04 23:21:23 +08:00
|
|
|
extern unsigned amdgpu_pcie_gen_cap;
|
|
|
|
extern unsigned amdgpu_pcie_lane_cap;
|
2016-06-02 18:32:07 +08:00
|
|
|
extern unsigned amdgpu_cg_mask;
|
|
|
|
extern unsigned amdgpu_pg_mask;
|
2016-06-18 01:31:33 +08:00
|
|
|
extern char *amdgpu_disable_cu;
|
2016-08-10 16:01:25 +08:00
|
|
|
extern char *amdgpu_virtual_display;
|
2016-09-06 16:34:37 +08:00
|
|
|
extern unsigned amdgpu_pp_feature_mask;
|
2016-08-24 21:51:49 +08:00
|
|
|
extern int amdgpu_vram_page_split;
|
2017-03-29 00:52:08 +08:00
|
|
|
extern int amdgpu_ngg;
|
|
|
|
extern int amdgpu_prim_buf_per_se;
|
|
|
|
extern int amdgpu_pos_buf_per_se;
|
|
|
|
extern int amdgpu_cntl_sb_buf_per_se;
|
|
|
|
extern int amdgpu_param_buf_per_se;
|
2015-04-21 04:51:00 +08:00
|
|
|
|
2017-04-21 16:40:00 +08:00
|
|
|
#define AMDGPU_DEFAULT_GTT_SIZE_MB 3072ULL /* 3GB by default */
|
2015-07-21 15:53:04 +08:00
|
|
|
#define AMDGPU_WAIT_IDLE_TIMEOUT_IN_MS 3000
|
2015-04-21 04:51:00 +08:00
|
|
|
#define AMDGPU_MAX_USEC_TIMEOUT 100000 /* 100 ms */
|
|
|
|
#define AMDGPU_FENCE_JIFFIES_TIMEOUT (HZ / 2)
|
|
|
|
/* AMDGPU_IB_POOL_SIZE must be a power of 2 */
|
|
|
|
#define AMDGPU_IB_POOL_SIZE 16
|
|
|
|
#define AMDGPU_DEBUGFS_MAX_COMPONENTS 32
|
|
|
|
#define AMDGPUFB_CONN_LIMIT 4
|
2016-09-24 04:23:41 +08:00
|
|
|
#define AMDGPU_BIOS_NUM_SCRATCH 16
|
2015-04-21 04:51:00 +08:00
|
|
|
|
2015-09-01 12:54:27 +08:00
|
|
|
/* max number of IP instances */
|
|
|
|
#define AMDGPU_MAX_SDMA_INSTANCES 2
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/* hard reset data */
|
|
|
|
#define AMDGPU_ASIC_RESET_DATA 0x39d5e86b
|
|
|
|
|
|
|
|
/* reset flags */
|
|
|
|
#define AMDGPU_RESET_GFX (1 << 0)
|
|
|
|
#define AMDGPU_RESET_COMPUTE (1 << 1)
|
|
|
|
#define AMDGPU_RESET_DMA (1 << 2)
|
|
|
|
#define AMDGPU_RESET_CP (1 << 3)
|
|
|
|
#define AMDGPU_RESET_GRBM (1 << 4)
|
|
|
|
#define AMDGPU_RESET_DMA1 (1 << 5)
|
|
|
|
#define AMDGPU_RESET_RLC (1 << 6)
|
|
|
|
#define AMDGPU_RESET_SEM (1 << 7)
|
|
|
|
#define AMDGPU_RESET_IH (1 << 8)
|
|
|
|
#define AMDGPU_RESET_VMC (1 << 9)
|
|
|
|
#define AMDGPU_RESET_MC (1 << 10)
|
|
|
|
#define AMDGPU_RESET_DISPLAY (1 << 11)
|
|
|
|
#define AMDGPU_RESET_UVD (1 << 12)
|
|
|
|
#define AMDGPU_RESET_VCE (1 << 13)
|
|
|
|
#define AMDGPU_RESET_VCE1 (1 << 14)
|
|
|
|
|
|
|
|
/* GFX current status */
|
|
|
|
#define AMDGPU_GFX_NORMAL_MODE 0x00000000L
|
|
|
|
#define AMDGPU_GFX_SAFE_MODE 0x00000001L
|
|
|
|
#define AMDGPU_GFX_PG_DISABLED_MODE 0x00000002L
|
|
|
|
#define AMDGPU_GFX_CG_DISABLED_MODE 0x00000004L
|
|
|
|
#define AMDGPU_GFX_LBPW_DISABLED_MODE 0x00000008L
|
|
|
|
|
|
|
|
/* max cursor sizes (in pixels) */
|
|
|
|
#define CIK_CURSOR_WIDTH 128
|
|
|
|
#define CIK_CURSOR_HEIGHT 128
|
|
|
|
|
|
|
|
struct amdgpu_device;
|
|
|
|
struct amdgpu_ib;
|
|
|
|
struct amdgpu_cs_parser;
|
2015-08-18 15:16:40 +08:00
|
|
|
struct amdgpu_job;
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_irq_src;
|
2015-08-17 10:48:26 +08:00
|
|
|
struct amdgpu_fpriv;
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
enum amdgpu_cp_irq {
|
|
|
|
AMDGPU_CP_IRQ_GFX_EOP = 0,
|
|
|
|
AMDGPU_CP_IRQ_COMPUTE_MEC1_PIPE0_EOP,
|
|
|
|
AMDGPU_CP_IRQ_COMPUTE_MEC1_PIPE1_EOP,
|
|
|
|
AMDGPU_CP_IRQ_COMPUTE_MEC1_PIPE2_EOP,
|
|
|
|
AMDGPU_CP_IRQ_COMPUTE_MEC1_PIPE3_EOP,
|
|
|
|
AMDGPU_CP_IRQ_COMPUTE_MEC2_PIPE0_EOP,
|
|
|
|
AMDGPU_CP_IRQ_COMPUTE_MEC2_PIPE1_EOP,
|
|
|
|
AMDGPU_CP_IRQ_COMPUTE_MEC2_PIPE2_EOP,
|
|
|
|
AMDGPU_CP_IRQ_COMPUTE_MEC2_PIPE3_EOP,
|
|
|
|
|
|
|
|
AMDGPU_CP_IRQ_LAST
|
|
|
|
};
|
|
|
|
|
|
|
|
enum amdgpu_sdma_irq {
|
|
|
|
AMDGPU_SDMA_IRQ_TRAP0 = 0,
|
|
|
|
AMDGPU_SDMA_IRQ_TRAP1,
|
|
|
|
|
|
|
|
AMDGPU_SDMA_IRQ_LAST
|
|
|
|
};
|
|
|
|
|
|
|
|
enum amdgpu_thermal_irq {
|
|
|
|
AMDGPU_THERMAL_IRQ_LOW_TO_HIGH = 0,
|
|
|
|
AMDGPU_THERMAL_IRQ_HIGH_TO_LOW,
|
|
|
|
|
|
|
|
AMDGPU_THERMAL_IRQ_LAST
|
|
|
|
};
|
|
|
|
|
2016-12-23 15:00:01 +08:00
|
|
|
enum amdgpu_kiq_irq {
|
|
|
|
AMDGPU_CP_KIQ_IRQ_DRIVER0 = 0,
|
|
|
|
AMDGPU_CP_KIQ_IRQ_LAST
|
|
|
|
};
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
int amdgpu_set_clockgating_state(struct amdgpu_device *adev,
|
2015-05-23 02:39:35 +08:00
|
|
|
enum amd_ip_block_type block_type,
|
|
|
|
enum amd_clockgating_state state);
|
2015-04-21 04:51:00 +08:00
|
|
|
int amdgpu_set_powergating_state(struct amdgpu_device *adev,
|
2015-05-23 02:39:35 +08:00
|
|
|
enum amd_ip_block_type block_type,
|
|
|
|
enum amd_powergating_state state);
|
2017-01-05 18:44:41 +08:00
|
|
|
void amdgpu_get_clockgating_state(struct amdgpu_device *adev, u32 *flags);
|
2016-06-23 23:41:04 +08:00
|
|
|
int amdgpu_wait_for_idle(struct amdgpu_device *adev,
|
|
|
|
enum amd_ip_block_type block_type);
|
|
|
|
bool amdgpu_is_idle(struct amdgpu_device *adev,
|
|
|
|
enum amd_ip_block_type block_type);
|
2015-04-21 04:51:00 +08:00
|
|
|
|
2016-10-14 05:41:13 +08:00
|
|
|
#define AMDGPU_MAX_IP_NUM 16
|
|
|
|
|
|
|
|
struct amdgpu_ip_block_status {
|
|
|
|
bool valid;
|
|
|
|
bool sw;
|
|
|
|
bool hw;
|
|
|
|
bool late_initialized;
|
|
|
|
bool hang;
|
|
|
|
};
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_ip_block_version {
|
2016-10-14 05:41:13 +08:00
|
|
|
const enum amd_ip_block_type type;
|
|
|
|
const u32 major;
|
|
|
|
const u32 minor;
|
|
|
|
const u32 rev;
|
2015-05-23 02:39:35 +08:00
|
|
|
const struct amd_ip_funcs *funcs;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
2016-10-14 05:41:13 +08:00
|
|
|
struct amdgpu_ip_block {
|
|
|
|
struct amdgpu_ip_block_status status;
|
|
|
|
const struct amdgpu_ip_block_version *version;
|
|
|
|
};
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
int amdgpu_ip_block_version_cmp(struct amdgpu_device *adev,
|
2015-05-23 02:39:35 +08:00
|
|
|
enum amd_ip_block_type type,
|
2015-04-21 04:51:00 +08:00
|
|
|
u32 major, u32 minor);
|
|
|
|
|
2016-10-14 05:41:13 +08:00
|
|
|
struct amdgpu_ip_block * amdgpu_get_ip_block(struct amdgpu_device *adev,
|
|
|
|
enum amd_ip_block_type type);
|
|
|
|
|
|
|
|
int amdgpu_ip_block_add(struct amdgpu_device *adev,
|
|
|
|
const struct amdgpu_ip_block_version *ip_block_version);
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
/* provided by hw blocks that can move/clear data. e.g., gfx or sdma */
|
|
|
|
struct amdgpu_buffer_funcs {
|
|
|
|
/* maximum bytes in a single operation */
|
|
|
|
uint32_t copy_max_bytes;
|
|
|
|
|
|
|
|
/* number of dw to reserve per operation */
|
|
|
|
unsigned copy_num_dw;
|
|
|
|
|
|
|
|
/* used for buffer migration */
|
2015-08-25 17:23:45 +08:00
|
|
|
void (*emit_copy_buffer)(struct amdgpu_ib *ib,
|
2015-04-21 04:51:00 +08:00
|
|
|
/* src addr in bytes */
|
|
|
|
uint64_t src_offset,
|
|
|
|
/* dst addr in bytes */
|
|
|
|
uint64_t dst_offset,
|
|
|
|
/* number of byte to transfer */
|
|
|
|
uint32_t byte_count);
|
|
|
|
|
|
|
|
/* maximum bytes in a single operation */
|
|
|
|
uint32_t fill_max_bytes;
|
|
|
|
|
|
|
|
/* number of dw to reserve per operation */
|
|
|
|
unsigned fill_num_dw;
|
|
|
|
|
|
|
|
/* used for buffer clearing */
|
2015-08-27 13:46:09 +08:00
|
|
|
void (*emit_fill_buffer)(struct amdgpu_ib *ib,
|
2015-04-21 04:51:00 +08:00
|
|
|
/* value to write to memory */
|
|
|
|
uint32_t src_data,
|
|
|
|
/* dst addr in bytes */
|
|
|
|
uint64_t dst_offset,
|
|
|
|
/* number of byte to fill */
|
|
|
|
uint32_t byte_count);
|
|
|
|
};
|
|
|
|
|
|
|
|
/* provided by hw blocks that can write ptes, e.g., sdma */
|
|
|
|
struct amdgpu_vm_pte_funcs {
|
|
|
|
/* copy pte entries from GART */
|
|
|
|
void (*copy_pte)(struct amdgpu_ib *ib,
|
|
|
|
uint64_t pe, uint64_t src,
|
|
|
|
unsigned count);
|
|
|
|
/* write pte one entry at a time with addr mapping */
|
2016-08-12 17:33:30 +08:00
|
|
|
void (*write_pte)(struct amdgpu_ib *ib, uint64_t pe,
|
|
|
|
uint64_t value, unsigned count,
|
|
|
|
uint32_t incr);
|
2015-04-21 04:51:00 +08:00
|
|
|
/* for linear pte/pde updates without addr mapping */
|
|
|
|
void (*set_pte_pde)(struct amdgpu_ib *ib,
|
|
|
|
uint64_t pe,
|
|
|
|
uint64_t addr, unsigned count,
|
2016-09-21 16:19:19 +08:00
|
|
|
uint32_t incr, uint64_t flags);
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/* provided by the gmc block */
|
|
|
|
struct amdgpu_gart_funcs {
|
|
|
|
/* flush the vm tlb via mmio */
|
|
|
|
void (*flush_gpu_tlb)(struct amdgpu_device *adev,
|
|
|
|
uint32_t vmid);
|
|
|
|
/* write pte/pde updates using the cpu */
|
|
|
|
int (*set_pte_pde)(struct amdgpu_device *adev,
|
|
|
|
void *cpu_pt_addr, /* cpu addr of page table */
|
|
|
|
uint32_t gpu_page_idx, /* pte/pde to update */
|
|
|
|
uint64_t addr, /* addr to write into pte/pde */
|
2016-09-21 16:19:19 +08:00
|
|
|
uint64_t flags); /* access flags */
|
2017-01-30 18:09:31 +08:00
|
|
|
/* enable/disable PRT support */
|
|
|
|
void (*set_prt)(struct amdgpu_device *adev, bool enable);
|
2017-02-15 01:22:57 +08:00
|
|
|
/* set pte flags based per asic */
|
|
|
|
uint64_t (*get_vm_pte_flags)(struct amdgpu_device *adev,
|
|
|
|
uint32_t flags);
|
2017-03-10 00:36:26 +08:00
|
|
|
/* adjust mc addr in fb for APU case */
|
|
|
|
u64 (*adjust_mc_addr)(struct amdgpu_device *adev, u64 addr);
|
2017-04-04 22:07:45 +08:00
|
|
|
uint32_t (*get_invalidate_req)(unsigned int vm_id);
|
2017-03-10 00:36:26 +08:00
|
|
|
};
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/* provided by the ih block */
|
|
|
|
struct amdgpu_ih_funcs {
|
|
|
|
/* ring read/write ptr handling, called from interrupt context */
|
|
|
|
u32 (*get_wptr)(struct amdgpu_device *adev);
|
|
|
|
void (*decode_iv)(struct amdgpu_device *adev,
|
|
|
|
struct amdgpu_iv_entry *entry);
|
|
|
|
void (*set_rptr)(struct amdgpu_device *adev);
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* BIOS.
|
|
|
|
*/
|
|
|
|
bool amdgpu_get_bios(struct amdgpu_device *adev);
|
|
|
|
bool amdgpu_read_bios(struct amdgpu_device *adev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Dummy page
|
|
|
|
*/
|
|
|
|
struct amdgpu_dummy_page {
|
|
|
|
struct page *page;
|
|
|
|
dma_addr_t addr;
|
|
|
|
};
|
|
|
|
int amdgpu_dummy_page_init(struct amdgpu_device *adev);
|
|
|
|
void amdgpu_dummy_page_fini(struct amdgpu_device *adev);
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clocks
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define AMDGPU_MAX_PPLL 3
|
|
|
|
|
|
|
|
struct amdgpu_clock {
|
|
|
|
struct amdgpu_pll ppll[AMDGPU_MAX_PPLL];
|
|
|
|
struct amdgpu_pll spll;
|
|
|
|
struct amdgpu_pll mpll;
|
|
|
|
/* 10 Khz units */
|
|
|
|
uint32_t default_mclk;
|
|
|
|
uint32_t default_sclk;
|
|
|
|
uint32_t default_dispclk;
|
|
|
|
uint32_t current_dispclk;
|
|
|
|
uint32_t dp_extclk;
|
|
|
|
uint32_t max_pixel_clock;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2016-08-02 11:32:41 +08:00
|
|
|
* BO.
|
2015-04-21 04:51:00 +08:00
|
|
|
*/
|
|
|
|
struct amdgpu_bo_list_entry {
|
|
|
|
struct amdgpu_bo *robj;
|
|
|
|
struct ttm_validate_buffer tv;
|
|
|
|
struct amdgpu_bo_va *bo_va;
|
|
|
|
uint32_t priority;
|
2016-02-23 19:36:59 +08:00
|
|
|
struct page **user_pages;
|
|
|
|
int user_invalidated;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_bo_va_mapping {
|
|
|
|
struct list_head list;
|
2017-03-30 20:03:59 +08:00
|
|
|
struct rb_node rb;
|
|
|
|
uint64_t start;
|
|
|
|
uint64_t last;
|
|
|
|
uint64_t __subtree_last;
|
2015-04-21 04:51:00 +08:00
|
|
|
uint64_t offset;
|
2017-01-18 21:49:43 +08:00
|
|
|
uint64_t flags;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/* bo virtual addresses in a specific vm */
|
|
|
|
struct amdgpu_bo_va {
|
|
|
|
/* protected by bo being reserved */
|
|
|
|
struct list_head bo_list;
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence *last_pt_update;
|
2015-04-21 04:51:00 +08:00
|
|
|
unsigned ref_count;
|
|
|
|
|
2015-07-30 17:53:42 +08:00
|
|
|
/* protected by vm mutex and spinlock */
|
2015-04-21 04:51:00 +08:00
|
|
|
struct list_head vm_status;
|
|
|
|
|
2015-07-30 17:53:42 +08:00
|
|
|
/* mappings for this bo_va */
|
|
|
|
struct list_head invalids;
|
|
|
|
struct list_head valids;
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/* constant after initialization */
|
|
|
|
struct amdgpu_vm *vm;
|
|
|
|
struct amdgpu_bo *bo;
|
|
|
|
};
|
|
|
|
|
2015-04-24 17:37:30 +08:00
|
|
|
#define AMDGPU_GEM_DOMAIN_MAX 0x3
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_bo {
|
|
|
|
/* Protected by tbo.reserved */
|
2015-12-19 05:13:12 +08:00
|
|
|
u32 prefered_domains;
|
|
|
|
u32 allowed_domains;
|
2015-04-24 17:37:30 +08:00
|
|
|
struct ttm_place placements[AMDGPU_GEM_DOMAIN_MAX + 1];
|
2015-04-21 04:51:00 +08:00
|
|
|
struct ttm_placement placement;
|
|
|
|
struct ttm_buffer_object tbo;
|
|
|
|
struct ttm_bo_kmap_obj kmap;
|
|
|
|
u64 flags;
|
|
|
|
unsigned pin_count;
|
|
|
|
void *kptr;
|
|
|
|
u64 tiling_flags;
|
|
|
|
u64 metadata_flags;
|
|
|
|
void *metadata;
|
|
|
|
u32 metadata_size;
|
drm/amdgpu: Attach exclusive fence to prime exported bo's. (v5)
External clients which import our bo's wait only
for exclusive dmabuf-fences, not on shared ones,
ditto for bo's which we import from external
providers and write to.
Therefore attach exclusive fences on prime shared buffers
if our exported buffer gets imported by an external
client, or if we import a buffer from an external
exporter.
See discussion in thread:
https://lists.freedesktop.org/archives/dri-devel/2016-October/122370.html
Prime export tested on Intel iGPU + AMD Tonga dGPU as
DRI3/Present Prime render offload, and with the Tonga
standalone as primary gpu.
v2: Add a wait for all shared fences before prime export,
as suggested by Christian Koenig.
v3: - Mark buffer prime_exported in amdgpu_gem_prime_pin,
so we only use the exclusive fence when exporting a
bo to external clients like a separate iGPU, but not
when exporting/importing from/to ourselves as part of
regular DRI3 fd passing.
- Propagate failure of reservation_object_wait_rcu back
to caller.
v4: - Switch to a prime_shared_count counter instead of a
flag, which gets in/decremented on prime_pin/unpin, so
we can switch back to shared fences if all clients
detach from our exported bo.
- Also switch to exclusive fence for prime imported bo's.
v5: - Drop lret, instead use int ret -> long ret, as proposed
by Christian.
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=95472
Tested-by: Mike Lothian <mike@fireburn.co.uk> (v1)
Signed-off-by: Mario Kleiner <mario.kleiner.de@gmail.com>
Reviewed-by: Christian König <christian.koenig@amd.com>.
Cc: Christian König <christian.koenig@amd.com>
Cc: Michel Dänzer <michel.daenzer@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
Cc: stable@vger.kernel.org
2016-11-09 09:25:15 +08:00
|
|
|
unsigned prime_shared_count;
|
2015-04-21 04:51:00 +08:00
|
|
|
/* list of all virtual address to which this bo
|
|
|
|
* is associated to
|
|
|
|
*/
|
|
|
|
struct list_head va;
|
|
|
|
/* Constant after initialization */
|
|
|
|
struct drm_gem_object gem_base;
|
2015-11-27 23:49:00 +08:00
|
|
|
struct amdgpu_bo *parent;
|
2016-07-26 14:13:21 +08:00
|
|
|
struct amdgpu_bo *shadow;
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
struct ttm_bo_kmap_obj dma_buf_vmap;
|
|
|
|
struct amdgpu_mn *mn;
|
|
|
|
struct list_head mn_list;
|
2016-08-17 11:41:30 +08:00
|
|
|
struct list_head shadow_list;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
#define gem_to_amdgpu_bo(gobj) container_of((gobj), struct amdgpu_bo, gem_base)
|
|
|
|
|
|
|
|
void amdgpu_gem_object_free(struct drm_gem_object *obj);
|
|
|
|
int amdgpu_gem_object_open(struct drm_gem_object *obj,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
void amdgpu_gem_object_close(struct drm_gem_object *obj,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
unsigned long amdgpu_gem_timeout(uint64_t timeout_ns);
|
|
|
|
struct sg_table *amdgpu_gem_prime_get_sg_table(struct drm_gem_object *obj);
|
2016-05-04 00:46:19 +08:00
|
|
|
struct drm_gem_object *
|
|
|
|
amdgpu_gem_prime_import_sg_table(struct drm_device *dev,
|
|
|
|
struct dma_buf_attachment *attach,
|
|
|
|
struct sg_table *sg);
|
2015-04-21 04:51:00 +08:00
|
|
|
struct dma_buf *amdgpu_gem_prime_export(struct drm_device *dev,
|
|
|
|
struct drm_gem_object *gobj,
|
|
|
|
int flags);
|
|
|
|
int amdgpu_gem_prime_pin(struct drm_gem_object *obj);
|
|
|
|
void amdgpu_gem_prime_unpin(struct drm_gem_object *obj);
|
|
|
|
struct reservation_object *amdgpu_gem_prime_res_obj(struct drm_gem_object *);
|
|
|
|
void *amdgpu_gem_prime_vmap(struct drm_gem_object *obj);
|
|
|
|
void amdgpu_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr);
|
|
|
|
int amdgpu_gem_debugfs_init(struct amdgpu_device *adev);
|
|
|
|
|
|
|
|
/* sub-allocation manager, it has to be protected by another lock.
|
|
|
|
* By conception this is an helper for other part of the driver
|
|
|
|
* like the indirect buffer or semaphore, which both have their
|
|
|
|
* locking.
|
|
|
|
*
|
|
|
|
* Principe is simple, we keep a list of sub allocation in offset
|
|
|
|
* order (first entry has offset == 0, last entry has the highest
|
|
|
|
* offset).
|
|
|
|
*
|
|
|
|
* When allocating new object we first check if there is room at
|
|
|
|
* the end total_size - (last_object_offset + last_object_size) >=
|
|
|
|
* alloc_size. If so we allocate new object there.
|
|
|
|
*
|
|
|
|
* When there is not enough room at the end, we start waiting for
|
|
|
|
* each sub object until we reach object_offset+object_size >=
|
|
|
|
* alloc_size, this object then become the sub object we return.
|
|
|
|
*
|
|
|
|
* Alignment can't be bigger than page size.
|
|
|
|
*
|
|
|
|
* Hole are not considered for allocation to keep things simple.
|
|
|
|
* Assumption is that there won't be hole (all object on same
|
|
|
|
* alignment).
|
|
|
|
*/
|
2016-03-11 21:50:08 +08:00
|
|
|
|
|
|
|
#define AMDGPU_SA_NUM_FENCE_LISTS 32
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_sa_manager {
|
|
|
|
wait_queue_head_t wq;
|
|
|
|
struct amdgpu_bo *bo;
|
|
|
|
struct list_head *hole;
|
2016-03-11 21:50:08 +08:00
|
|
|
struct list_head flist[AMDGPU_SA_NUM_FENCE_LISTS];
|
2015-04-21 04:51:00 +08:00
|
|
|
struct list_head olist;
|
|
|
|
unsigned size;
|
|
|
|
uint64_t gpu_addr;
|
|
|
|
void *cpu_ptr;
|
|
|
|
uint32_t domain;
|
|
|
|
uint32_t align;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* sub-allocation buffer */
|
|
|
|
struct amdgpu_sa_bo {
|
|
|
|
struct list_head olist;
|
|
|
|
struct list_head flist;
|
|
|
|
struct amdgpu_sa_manager *manager;
|
|
|
|
unsigned soffset;
|
|
|
|
unsigned eoffset;
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence *fence;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* GEM objects.
|
|
|
|
*/
|
2016-02-15 23:59:57 +08:00
|
|
|
void amdgpu_gem_force_release(struct amdgpu_device *adev);
|
2015-04-21 04:51:00 +08:00
|
|
|
int amdgpu_gem_object_create(struct amdgpu_device *adev, unsigned long size,
|
|
|
|
int alignment, u32 initial_domain,
|
|
|
|
u64 flags, bool kernel,
|
|
|
|
struct drm_gem_object **obj);
|
|
|
|
|
|
|
|
int amdgpu_mode_dumb_create(struct drm_file *file_priv,
|
|
|
|
struct drm_device *dev,
|
|
|
|
struct drm_mode_create_dumb *args);
|
|
|
|
int amdgpu_mode_dumb_mmap(struct drm_file *filp,
|
|
|
|
struct drm_device *dev,
|
|
|
|
uint32_t handle, uint64_t *offset_p);
|
2016-05-12 13:27:28 +08:00
|
|
|
int amdgpu_fence_slab_init(void);
|
|
|
|
void amdgpu_fence_slab_fini(void);
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* GART structures, functions & helpers
|
|
|
|
*/
|
|
|
|
struct amdgpu_mc;
|
|
|
|
|
|
|
|
#define AMDGPU_GPU_PAGE_SIZE 4096
|
|
|
|
#define AMDGPU_GPU_PAGE_MASK (AMDGPU_GPU_PAGE_SIZE - 1)
|
|
|
|
#define AMDGPU_GPU_PAGE_SHIFT 12
|
|
|
|
#define AMDGPU_GPU_PAGE_ALIGN(a) (((a) + AMDGPU_GPU_PAGE_MASK) & ~AMDGPU_GPU_PAGE_MASK)
|
|
|
|
|
|
|
|
struct amdgpu_gart {
|
|
|
|
dma_addr_t table_addr;
|
|
|
|
struct amdgpu_bo *robj;
|
|
|
|
void *ptr;
|
|
|
|
unsigned num_gpu_pages;
|
|
|
|
unsigned num_cpu_pages;
|
|
|
|
unsigned table_size;
|
2016-03-30 20:42:57 +08:00
|
|
|
#ifdef CONFIG_DRM_AMDGPU_GART_DEBUGFS
|
2015-04-21 04:51:00 +08:00
|
|
|
struct page **pages;
|
2016-03-30 20:42:57 +08:00
|
|
|
#endif
|
2015-04-21 04:51:00 +08:00
|
|
|
bool ready;
|
2017-02-15 01:31:36 +08:00
|
|
|
|
|
|
|
/* Asic default pte flags */
|
|
|
|
uint64_t gart_pte_flags;
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
const struct amdgpu_gart_funcs *gart_funcs;
|
|
|
|
};
|
|
|
|
|
|
|
|
int amdgpu_gart_table_ram_alloc(struct amdgpu_device *adev);
|
|
|
|
void amdgpu_gart_table_ram_free(struct amdgpu_device *adev);
|
|
|
|
int amdgpu_gart_table_vram_alloc(struct amdgpu_device *adev);
|
|
|
|
void amdgpu_gart_table_vram_free(struct amdgpu_device *adev);
|
|
|
|
int amdgpu_gart_table_vram_pin(struct amdgpu_device *adev);
|
|
|
|
void amdgpu_gart_table_vram_unpin(struct amdgpu_device *adev);
|
|
|
|
int amdgpu_gart_init(struct amdgpu_device *adev);
|
|
|
|
void amdgpu_gart_fini(struct amdgpu_device *adev);
|
2016-08-13 07:25:21 +08:00
|
|
|
void amdgpu_gart_unbind(struct amdgpu_device *adev, uint64_t offset,
|
2015-04-21 04:51:00 +08:00
|
|
|
int pages);
|
2016-08-13 07:25:21 +08:00
|
|
|
int amdgpu_gart_bind(struct amdgpu_device *adev, uint64_t offset,
|
2015-04-21 04:51:00 +08:00
|
|
|
int pages, struct page **pagelist,
|
2016-09-21 16:19:19 +08:00
|
|
|
dma_addr_t *dma_addr, uint64_t flags);
|
2016-08-30 16:36:25 +08:00
|
|
|
int amdgpu_ttm_recover_gart(struct amdgpu_device *adev);
|
2015-04-21 04:51:00 +08:00
|
|
|
|
2017-03-10 00:36:26 +08:00
|
|
|
/*
|
|
|
|
* VMHUB structures, functions & helpers
|
|
|
|
*/
|
|
|
|
struct amdgpu_vmhub {
|
|
|
|
uint32_t ctx0_ptb_addr_lo32;
|
|
|
|
uint32_t ctx0_ptb_addr_hi32;
|
|
|
|
uint32_t vm_inv_eng0_req;
|
|
|
|
uint32_t vm_inv_eng0_ack;
|
|
|
|
uint32_t vm_context0_cntl;
|
|
|
|
uint32_t vm_l2_pro_fault_status;
|
|
|
|
uint32_t vm_l2_pro_fault_cntl;
|
|
|
|
};
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* GPU MC structures, functions & helpers
|
|
|
|
*/
|
|
|
|
struct amdgpu_mc {
|
|
|
|
resource_size_t aper_size;
|
|
|
|
resource_size_t aper_base;
|
|
|
|
resource_size_t agp_base;
|
|
|
|
/* for some chips with <= 32MB we need to lie
|
|
|
|
* about vram size near mc fb location */
|
|
|
|
u64 mc_vram_size;
|
|
|
|
u64 visible_vram_size;
|
|
|
|
u64 gtt_size;
|
|
|
|
u64 gtt_start;
|
|
|
|
u64 gtt_end;
|
|
|
|
u64 vram_start;
|
|
|
|
u64 vram_end;
|
|
|
|
unsigned vram_width;
|
|
|
|
u64 real_vram_size;
|
|
|
|
int vram_mtrr;
|
|
|
|
u64 gtt_base_align;
|
|
|
|
u64 mc_mask;
|
|
|
|
const struct firmware *fw; /* MC firmware */
|
|
|
|
uint32_t fw_version;
|
|
|
|
struct amdgpu_irq_src vm_fault;
|
2015-06-03 21:02:01 +08:00
|
|
|
uint32_t vram_type;
|
2016-07-18 16:59:24 +08:00
|
|
|
uint32_t srbm_soft_reset;
|
|
|
|
struct amdgpu_mode_mc_save save;
|
2017-01-27 18:56:05 +08:00
|
|
|
bool prt_warning;
|
2016-03-10 14:20:39 +08:00
|
|
|
/* apertures */
|
|
|
|
u64 shared_aperture_start;
|
|
|
|
u64 shared_aperture_end;
|
|
|
|
u64 private_aperture_start;
|
|
|
|
u64 private_aperture_end;
|
2017-03-10 00:36:26 +08:00
|
|
|
/* protects concurrent invalidation */
|
|
|
|
spinlock_t invalidate_lock;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* GPU doorbell structures, functions & helpers
|
|
|
|
*/
|
|
|
|
typedef enum _AMDGPU_DOORBELL_ASSIGNMENT
|
|
|
|
{
|
|
|
|
AMDGPU_DOORBELL_KIQ = 0x000,
|
|
|
|
AMDGPU_DOORBELL_HIQ = 0x001,
|
|
|
|
AMDGPU_DOORBELL_DIQ = 0x002,
|
|
|
|
AMDGPU_DOORBELL_MEC_RING0 = 0x010,
|
|
|
|
AMDGPU_DOORBELL_MEC_RING1 = 0x011,
|
|
|
|
AMDGPU_DOORBELL_MEC_RING2 = 0x012,
|
|
|
|
AMDGPU_DOORBELL_MEC_RING3 = 0x013,
|
|
|
|
AMDGPU_DOORBELL_MEC_RING4 = 0x014,
|
|
|
|
AMDGPU_DOORBELL_MEC_RING5 = 0x015,
|
|
|
|
AMDGPU_DOORBELL_MEC_RING6 = 0x016,
|
|
|
|
AMDGPU_DOORBELL_MEC_RING7 = 0x017,
|
|
|
|
AMDGPU_DOORBELL_GFX_RING0 = 0x020,
|
|
|
|
AMDGPU_DOORBELL_sDMA_ENGINE0 = 0x1E0,
|
|
|
|
AMDGPU_DOORBELL_sDMA_ENGINE1 = 0x1E1,
|
|
|
|
AMDGPU_DOORBELL_IH = 0x1E8,
|
|
|
|
AMDGPU_DOORBELL_MAX_ASSIGNMENT = 0x3FF,
|
|
|
|
AMDGPU_DOORBELL_INVALID = 0xFFFF
|
|
|
|
} AMDGPU_DOORBELL_ASSIGNMENT;
|
|
|
|
|
|
|
|
struct amdgpu_doorbell {
|
|
|
|
/* doorbell mmio */
|
|
|
|
resource_size_t base;
|
|
|
|
resource_size_t size;
|
|
|
|
u32 __iomem *ptr;
|
|
|
|
u32 num_doorbells; /* Number of doorbells actually reserved for amdgpu. */
|
|
|
|
};
|
|
|
|
|
2016-03-18 15:41:42 +08:00
|
|
|
/*
|
|
|
|
* 64bit doorbell, offset are in QWORD, occupy 2KB doorbell space
|
|
|
|
*/
|
|
|
|
typedef enum _AMDGPU_DOORBELL64_ASSIGNMENT
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* All compute related doorbells: kiq, hiq, diq, traditional compute queue, user queue, should locate in
|
|
|
|
* a continues range so that programming CP_MEC_DOORBELL_RANGE_LOWER/UPPER can cover this range.
|
|
|
|
* Compute related doorbells are allocated from 0x00 to 0x8a
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/* kernel scheduling */
|
|
|
|
AMDGPU_DOORBELL64_KIQ = 0x00,
|
|
|
|
|
|
|
|
/* HSA interface queue and debug queue */
|
|
|
|
AMDGPU_DOORBELL64_HIQ = 0x01,
|
|
|
|
AMDGPU_DOORBELL64_DIQ = 0x02,
|
|
|
|
|
|
|
|
/* Compute engines */
|
|
|
|
AMDGPU_DOORBELL64_MEC_RING0 = 0x03,
|
|
|
|
AMDGPU_DOORBELL64_MEC_RING1 = 0x04,
|
|
|
|
AMDGPU_DOORBELL64_MEC_RING2 = 0x05,
|
|
|
|
AMDGPU_DOORBELL64_MEC_RING3 = 0x06,
|
|
|
|
AMDGPU_DOORBELL64_MEC_RING4 = 0x07,
|
|
|
|
AMDGPU_DOORBELL64_MEC_RING5 = 0x08,
|
|
|
|
AMDGPU_DOORBELL64_MEC_RING6 = 0x09,
|
|
|
|
AMDGPU_DOORBELL64_MEC_RING7 = 0x0a,
|
|
|
|
|
|
|
|
/* User queue doorbell range (128 doorbells) */
|
|
|
|
AMDGPU_DOORBELL64_USERQUEUE_START = 0x0b,
|
|
|
|
AMDGPU_DOORBELL64_USERQUEUE_END = 0x8a,
|
|
|
|
|
|
|
|
/* Graphics engine */
|
|
|
|
AMDGPU_DOORBELL64_GFX_RING0 = 0x8b,
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Other graphics doorbells can be allocated here: from 0x8c to 0xef
|
|
|
|
* Graphics voltage island aperture 1
|
|
|
|
* default non-graphics QWORD index is 0xF0 - 0xFF inclusive
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* sDMA engines */
|
|
|
|
AMDGPU_DOORBELL64_sDMA_ENGINE0 = 0xF0,
|
|
|
|
AMDGPU_DOORBELL64_sDMA_HI_PRI_ENGINE0 = 0xF1,
|
|
|
|
AMDGPU_DOORBELL64_sDMA_ENGINE1 = 0xF2,
|
|
|
|
AMDGPU_DOORBELL64_sDMA_HI_PRI_ENGINE1 = 0xF3,
|
|
|
|
|
|
|
|
/* Interrupt handler */
|
|
|
|
AMDGPU_DOORBELL64_IH = 0xF4, /* For legacy interrupt ring buffer */
|
|
|
|
AMDGPU_DOORBELL64_IH_RING1 = 0xF5, /* For page migration request log */
|
|
|
|
AMDGPU_DOORBELL64_IH_RING2 = 0xF6, /* For page migration translation/invalidation log */
|
|
|
|
|
2016-12-30 16:18:56 +08:00
|
|
|
/* VCN engine use 32 bits doorbell */
|
|
|
|
AMDGPU_DOORBELL64_VCN0_1 = 0xF8, /* lower 32 bits for VNC0 and upper 32 bits for VNC1 */
|
|
|
|
AMDGPU_DOORBELL64_VCN2_3 = 0xF9,
|
|
|
|
AMDGPU_DOORBELL64_VCN4_5 = 0xFA,
|
|
|
|
AMDGPU_DOORBELL64_VCN6_7 = 0xFB,
|
|
|
|
|
|
|
|
/* overlap the doorbell assignment with VCN as they are mutually exclusive
|
|
|
|
* VCE engine's doorbell is 32 bit and two VCE ring share one QWORD
|
|
|
|
*/
|
|
|
|
AMDGPU_DOORBELL64_RING0_1 = 0xF8,
|
|
|
|
AMDGPU_DOORBELL64_RING2_3 = 0xF9,
|
|
|
|
AMDGPU_DOORBELL64_RING4_5 = 0xFA,
|
|
|
|
AMDGPU_DOORBELL64_RING6_7 = 0xFB,
|
|
|
|
|
|
|
|
AMDGPU_DOORBELL64_UVD_RING0_1 = 0xFC,
|
|
|
|
AMDGPU_DOORBELL64_UVD_RING2_3 = 0xFD,
|
|
|
|
AMDGPU_DOORBELL64_UVD_RING4_5 = 0xFE,
|
|
|
|
AMDGPU_DOORBELL64_UVD_RING6_7 = 0xFF,
|
2016-03-18 15:41:42 +08:00
|
|
|
|
|
|
|
AMDGPU_DOORBELL64_MAX_ASSIGNMENT = 0xFF,
|
|
|
|
AMDGPU_DOORBELL64_INVALID = 0xFFFF
|
|
|
|
} AMDGPU_DOORBELL64_ASSIGNMENT;
|
|
|
|
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
void amdgpu_doorbell_get_kfd_info(struct amdgpu_device *adev,
|
|
|
|
phys_addr_t *aperture_base,
|
|
|
|
size_t *aperture_size,
|
|
|
|
size_t *start_offset);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IRQS.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct amdgpu_flip_work {
|
2016-08-04 11:39:37 +08:00
|
|
|
struct delayed_work flip_work;
|
2015-04-21 04:51:00 +08:00
|
|
|
struct work_struct unpin_work;
|
|
|
|
struct amdgpu_device *adev;
|
|
|
|
int crtc_id;
|
2016-08-04 11:39:37 +08:00
|
|
|
u32 target_vblank;
|
2015-04-21 04:51:00 +08:00
|
|
|
uint64_t base;
|
|
|
|
struct drm_pending_vblank_event *event;
|
2016-09-15 21:06:50 +08:00
|
|
|
struct amdgpu_bo *old_abo;
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence *excl;
|
2015-08-11 23:29:52 +08:00
|
|
|
unsigned shared_count;
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence **shared;
|
|
|
|
struct dma_fence_cb cb;
|
2016-05-06 04:03:57 +08:00
|
|
|
bool async;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CP & rings.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct amdgpu_ib {
|
|
|
|
struct amdgpu_sa_bo *sa_bo;
|
|
|
|
uint32_t length_dw;
|
|
|
|
uint64_t gpu_addr;
|
|
|
|
uint32_t *ptr;
|
2015-05-11 23:41:41 +08:00
|
|
|
uint32_t flags;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
2016-04-10 22:30:00 +08:00
|
|
|
extern const struct amd_sched_backend_ops amdgpu_sched_ops;
|
2015-07-21 13:45:14 +08:00
|
|
|
|
2016-02-03 20:44:52 +08:00
|
|
|
int amdgpu_job_alloc(struct amdgpu_device *adev, unsigned num_ibs,
|
2016-04-19 20:11:32 +08:00
|
|
|
struct amdgpu_job **job, struct amdgpu_vm *vm);
|
2016-02-01 19:20:25 +08:00
|
|
|
int amdgpu_job_alloc_with_ib(struct amdgpu_device *adev, unsigned size,
|
|
|
|
struct amdgpu_job **job);
|
2016-03-10 12:14:44 +08:00
|
|
|
|
2016-06-29 21:10:31 +08:00
|
|
|
void amdgpu_job_free_resources(struct amdgpu_job *job);
|
2016-02-03 20:44:52 +08:00
|
|
|
void amdgpu_job_free(struct amdgpu_job *job);
|
2016-02-01 19:20:25 +08:00
|
|
|
int amdgpu_job_submit(struct amdgpu_job *job, struct amdgpu_ring *ring,
|
2016-02-01 19:53:58 +08:00
|
|
|
struct amd_sched_entity *entity, void *owner,
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence **f);
|
2015-11-15 23:04:16 +08:00
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* context related structures
|
|
|
|
*/
|
|
|
|
|
2015-07-07 23:24:49 +08:00
|
|
|
struct amdgpu_ctx_ring {
|
2015-08-06 00:33:21 +08:00
|
|
|
uint64_t sequence;
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence **fences;
|
2015-08-06 00:33:21 +08:00
|
|
|
struct amd_sched_entity entity;
|
2015-07-07 23:24:49 +08:00
|
|
|
};
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_ctx {
|
2015-08-17 10:48:26 +08:00
|
|
|
struct kref refcount;
|
2015-07-21 13:17:19 +08:00
|
|
|
struct amdgpu_device *adev;
|
2015-08-17 10:48:26 +08:00
|
|
|
unsigned reset_counter;
|
2015-07-07 23:24:49 +08:00
|
|
|
spinlock_t ring_lock;
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence **fences;
|
2015-07-07 23:24:49 +08:00
|
|
|
struct amdgpu_ctx_ring rings[AMDGPU_MAX_RINGS];
|
2016-08-26 13:28:28 +08:00
|
|
|
bool preamble_presented;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_ctx_mgr {
|
2015-08-17 10:48:26 +08:00
|
|
|
struct amdgpu_device *adev;
|
|
|
|
struct mutex lock;
|
|
|
|
/* protected by lock */
|
|
|
|
struct idr ctx_handles;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
2015-08-17 10:48:26 +08:00
|
|
|
struct amdgpu_ctx *amdgpu_ctx_get(struct amdgpu_fpriv *fpriv, uint32_t id);
|
|
|
|
int amdgpu_ctx_put(struct amdgpu_ctx *ctx);
|
|
|
|
|
2015-07-07 23:24:49 +08:00
|
|
|
uint64_t amdgpu_ctx_add_fence(struct amdgpu_ctx *ctx, struct amdgpu_ring *ring,
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence *fence);
|
|
|
|
struct dma_fence *amdgpu_ctx_get_fence(struct amdgpu_ctx *ctx,
|
2015-07-07 23:24:49 +08:00
|
|
|
struct amdgpu_ring *ring, uint64_t seq);
|
|
|
|
|
2015-08-17 10:48:26 +08:00
|
|
|
int amdgpu_ctx_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *filp);
|
|
|
|
|
2015-08-04 22:20:31 +08:00
|
|
|
void amdgpu_ctx_mgr_init(struct amdgpu_ctx_mgr *mgr);
|
|
|
|
void amdgpu_ctx_mgr_fini(struct amdgpu_ctx_mgr *mgr);
|
2015-08-17 10:48:26 +08:00
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* file private structure
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct amdgpu_fpriv {
|
|
|
|
struct amdgpu_vm vm;
|
2017-01-16 13:59:01 +08:00
|
|
|
struct amdgpu_bo_va *prt_va;
|
2015-04-21 04:51:00 +08:00
|
|
|
struct mutex bo_list_lock;
|
|
|
|
struct idr bo_list_handles;
|
2015-08-17 10:48:26 +08:00
|
|
|
struct amdgpu_ctx_mgr ctx_mgr;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* residency list
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct amdgpu_bo_list {
|
|
|
|
struct mutex lock;
|
|
|
|
struct amdgpu_bo *gds_obj;
|
|
|
|
struct amdgpu_bo *gws_obj;
|
|
|
|
struct amdgpu_bo *oa_obj;
|
2016-02-22 22:40:59 +08:00
|
|
|
unsigned first_userptr;
|
2015-04-21 04:51:00 +08:00
|
|
|
unsigned num_entries;
|
|
|
|
struct amdgpu_bo_list_entry *array;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_bo_list *
|
|
|
|
amdgpu_bo_list_get(struct amdgpu_fpriv *fpriv, int id);
|
2015-12-19 04:26:47 +08:00
|
|
|
void amdgpu_bo_list_get_list(struct amdgpu_bo_list *list,
|
|
|
|
struct list_head *validated);
|
2015-04-21 04:51:00 +08:00
|
|
|
void amdgpu_bo_list_put(struct amdgpu_bo_list *list);
|
|
|
|
void amdgpu_bo_list_free(struct amdgpu_bo_list *list);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* GFX stuff
|
|
|
|
*/
|
|
|
|
#include "clearstate_defs.h"
|
|
|
|
|
2016-04-09 03:45:13 +08:00
|
|
|
struct amdgpu_rlc_funcs {
|
|
|
|
void (*enter_safe_mode)(struct amdgpu_device *adev);
|
|
|
|
void (*exit_safe_mode)(struct amdgpu_device *adev);
|
|
|
|
};
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_rlc {
|
|
|
|
/* for power gating */
|
|
|
|
struct amdgpu_bo *save_restore_obj;
|
|
|
|
uint64_t save_restore_gpu_addr;
|
|
|
|
volatile uint32_t *sr_ptr;
|
|
|
|
const u32 *reg_list;
|
|
|
|
u32 reg_list_size;
|
|
|
|
/* for clear state */
|
|
|
|
struct amdgpu_bo *clear_state_obj;
|
|
|
|
uint64_t clear_state_gpu_addr;
|
|
|
|
volatile uint32_t *cs_ptr;
|
|
|
|
const struct cs_section_def *cs_data;
|
|
|
|
u32 clear_state_size;
|
|
|
|
/* for cp tables */
|
|
|
|
struct amdgpu_bo *cp_table_obj;
|
|
|
|
uint64_t cp_table_gpu_addr;
|
|
|
|
volatile uint32_t *cp_table_ptr;
|
|
|
|
u32 cp_table_size;
|
2016-04-09 03:45:13 +08:00
|
|
|
|
|
|
|
/* safe mode for updating CG/PG state */
|
|
|
|
bool in_safe_mode;
|
|
|
|
const struct amdgpu_rlc_funcs *funcs;
|
2016-04-15 05:26:07 +08:00
|
|
|
|
|
|
|
/* for firmware data */
|
|
|
|
u32 save_and_restore_offset;
|
|
|
|
u32 clear_state_descriptor_offset;
|
|
|
|
u32 avail_scratch_ram_locations;
|
|
|
|
u32 reg_restore_list_size;
|
|
|
|
u32 reg_list_format_start;
|
|
|
|
u32 reg_list_format_separate_start;
|
|
|
|
u32 starting_offsets_start;
|
|
|
|
u32 reg_list_format_size_bytes;
|
|
|
|
u32 reg_list_size_bytes;
|
|
|
|
|
|
|
|
u32 *register_list_format;
|
|
|
|
u32 *register_restore;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_mec {
|
|
|
|
struct amdgpu_bo *hpd_eop_obj;
|
|
|
|
u64 hpd_eop_gpu_addr;
|
2017-03-04 06:59:39 +08:00
|
|
|
struct amdgpu_bo *mec_fw_obj;
|
|
|
|
u64 mec_fw_gpu_addr;
|
2015-04-21 04:51:00 +08:00
|
|
|
u32 num_pipe;
|
|
|
|
u32 num_mec;
|
|
|
|
u32 num_queue;
|
2017-02-17 16:03:10 +08:00
|
|
|
void *mqd_backup[AMDGPU_MAX_COMPUTE_RINGS + 1];
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
2016-12-23 15:00:01 +08:00
|
|
|
struct amdgpu_kiq {
|
|
|
|
u64 eop_gpu_addr;
|
|
|
|
struct amdgpu_bo *eop_obj;
|
|
|
|
struct amdgpu_ring ring;
|
|
|
|
struct amdgpu_irq_src irq;
|
|
|
|
};
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* GPU scratch registers structures, functions & helpers
|
|
|
|
*/
|
|
|
|
struct amdgpu_scratch {
|
|
|
|
unsigned num_reg;
|
|
|
|
uint32_t reg_base;
|
2017-01-17 04:56:48 +08:00
|
|
|
uint32_t free_mask;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* GFX configurations
|
|
|
|
*/
|
2016-10-10 22:56:21 +08:00
|
|
|
#define AMDGPU_GFX_MAX_SE 4
|
|
|
|
#define AMDGPU_GFX_MAX_SH_PER_SE 2
|
|
|
|
|
|
|
|
struct amdgpu_rb_config {
|
|
|
|
uint32_t rb_backend_disable;
|
|
|
|
uint32_t user_rb_backend_disable;
|
|
|
|
uint32_t raster_config;
|
|
|
|
uint32_t raster_config_1;
|
|
|
|
};
|
|
|
|
|
2016-12-13 02:40:37 +08:00
|
|
|
struct gb_addr_config {
|
|
|
|
uint16_t pipe_interleave_size;
|
|
|
|
uint8_t num_pipes;
|
|
|
|
uint8_t max_compress_frags;
|
|
|
|
uint8_t num_banks;
|
|
|
|
uint8_t num_se;
|
|
|
|
uint8_t num_rb_per_se;
|
|
|
|
};
|
|
|
|
|
2017-02-21 10:32:37 +08:00
|
|
|
struct amdgpu_gfx_config {
|
2015-04-21 04:51:00 +08:00
|
|
|
unsigned max_shader_engines;
|
|
|
|
unsigned max_tile_pipes;
|
|
|
|
unsigned max_cu_per_sh;
|
|
|
|
unsigned max_sh_per_se;
|
|
|
|
unsigned max_backends_per_se;
|
|
|
|
unsigned max_texture_channel_caches;
|
|
|
|
unsigned max_gprs;
|
|
|
|
unsigned max_gs_threads;
|
|
|
|
unsigned max_hw_contexts;
|
|
|
|
unsigned sc_prim_fifo_size_frontend;
|
|
|
|
unsigned sc_prim_fifo_size_backend;
|
|
|
|
unsigned sc_hiz_tile_fifo_size;
|
|
|
|
unsigned sc_earlyz_tile_fifo_size;
|
|
|
|
|
|
|
|
unsigned num_tile_pipes;
|
|
|
|
unsigned backend_enable_mask;
|
|
|
|
unsigned mem_max_burst_length_bytes;
|
|
|
|
unsigned mem_row_size_in_kb;
|
|
|
|
unsigned shader_engine_tile_size;
|
|
|
|
unsigned num_gpus;
|
|
|
|
unsigned multi_gpu_tile_size;
|
|
|
|
unsigned mc_arb_ramcfg;
|
|
|
|
unsigned gb_addr_config;
|
2016-02-12 13:39:13 +08:00
|
|
|
unsigned num_rbs;
|
2017-04-27 11:12:07 +08:00
|
|
|
unsigned gs_vgt_table_depth;
|
|
|
|
unsigned gs_prim_buffer_depth;
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
uint32_t tile_mode_array[32];
|
|
|
|
uint32_t macrotile_mode_array[16];
|
2016-10-10 22:56:21 +08:00
|
|
|
|
2016-12-13 02:40:37 +08:00
|
|
|
struct gb_addr_config gb_addr_config_fields;
|
2016-10-10 22:56:21 +08:00
|
|
|
struct amdgpu_rb_config rb_config[AMDGPU_GFX_MAX_SE][AMDGPU_GFX_MAX_SH_PER_SE];
|
2017-02-17 11:05:49 +08:00
|
|
|
|
|
|
|
/* gfx configure feature */
|
|
|
|
uint32_t double_offchip_lds_buf;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
2016-05-04 04:25:53 +08:00
|
|
|
struct amdgpu_cu_info {
|
|
|
|
uint32_t number; /* total active CU number */
|
|
|
|
uint32_t ao_cu_mask;
|
2017-04-27 11:12:07 +08:00
|
|
|
uint32_t wave_front_size;
|
2016-05-04 04:25:53 +08:00
|
|
|
uint32_t bitmap[4][4];
|
|
|
|
};
|
|
|
|
|
2016-07-08 03:01:42 +08:00
|
|
|
struct amdgpu_gfx_funcs {
|
|
|
|
/* get the gpu clock counter */
|
|
|
|
uint64_t (*get_gpu_clock_counter)(struct amdgpu_device *adev);
|
2016-06-28 22:26:48 +08:00
|
|
|
void (*select_se_sh)(struct amdgpu_device *adev, u32 se_num, u32 sh_num, u32 instance);
|
2016-10-14 21:49:09 +08:00
|
|
|
void (*read_wave_data)(struct amdgpu_device *adev, uint32_t simd, uint32_t wave, uint32_t *dst, int *no_fields);
|
2016-12-06 00:39:19 +08:00
|
|
|
void (*read_wave_vgprs)(struct amdgpu_device *adev, uint32_t simd, uint32_t wave, uint32_t thread, uint32_t start, uint32_t size, uint32_t *dst);
|
|
|
|
void (*read_wave_sgprs)(struct amdgpu_device *adev, uint32_t simd, uint32_t wave, uint32_t start, uint32_t size, uint32_t *dst);
|
2016-07-08 03:01:42 +08:00
|
|
|
};
|
|
|
|
|
2017-03-29 00:52:08 +08:00
|
|
|
struct amdgpu_ngg_buf {
|
|
|
|
struct amdgpu_bo *bo;
|
|
|
|
uint64_t gpu_addr;
|
|
|
|
uint32_t size;
|
|
|
|
uint32_t bo_size;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
2017-05-04 14:49:18 +08:00
|
|
|
NGG_PRIM = 0,
|
|
|
|
NGG_POS,
|
|
|
|
NGG_CNTL,
|
|
|
|
NGG_PARAM,
|
2017-03-29 00:52:08 +08:00
|
|
|
NGG_BUF_MAX
|
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_ngg {
|
|
|
|
struct amdgpu_ngg_buf buf[NGG_BUF_MAX];
|
|
|
|
uint32_t gds_reserve_addr;
|
|
|
|
uint32_t gds_reserve_size;
|
|
|
|
bool init;
|
|
|
|
};
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_gfx {
|
|
|
|
struct mutex gpu_clock_mutex;
|
2017-02-21 10:32:37 +08:00
|
|
|
struct amdgpu_gfx_config config;
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_rlc rlc;
|
|
|
|
struct amdgpu_mec mec;
|
2016-12-23 15:00:01 +08:00
|
|
|
struct amdgpu_kiq kiq;
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_scratch scratch;
|
|
|
|
const struct firmware *me_fw; /* ME firmware */
|
|
|
|
uint32_t me_fw_version;
|
|
|
|
const struct firmware *pfp_fw; /* PFP firmware */
|
|
|
|
uint32_t pfp_fw_version;
|
|
|
|
const struct firmware *ce_fw; /* CE firmware */
|
|
|
|
uint32_t ce_fw_version;
|
|
|
|
const struct firmware *rlc_fw; /* RLC firmware */
|
|
|
|
uint32_t rlc_fw_version;
|
|
|
|
const struct firmware *mec_fw; /* MEC firmware */
|
|
|
|
uint32_t mec_fw_version;
|
|
|
|
const struct firmware *mec2_fw; /* MEC2 firmware */
|
|
|
|
uint32_t mec2_fw_version;
|
2015-06-03 19:52:06 +08:00
|
|
|
uint32_t me_feature_version;
|
|
|
|
uint32_t ce_feature_version;
|
|
|
|
uint32_t pfp_feature_version;
|
2015-08-04 10:43:50 +08:00
|
|
|
uint32_t rlc_feature_version;
|
|
|
|
uint32_t mec_feature_version;
|
|
|
|
uint32_t mec2_feature_version;
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_ring gfx_ring[AMDGPU_MAX_GFX_RINGS];
|
|
|
|
unsigned num_gfx_rings;
|
|
|
|
struct amdgpu_ring compute_ring[AMDGPU_MAX_COMPUTE_RINGS];
|
|
|
|
unsigned num_compute_rings;
|
|
|
|
struct amdgpu_irq_src eop_irq;
|
|
|
|
struct amdgpu_irq_src priv_reg_irq;
|
|
|
|
struct amdgpu_irq_src priv_inst_irq;
|
|
|
|
/* gfx status */
|
2016-05-04 04:25:53 +08:00
|
|
|
uint32_t gfx_current_status;
|
2015-06-03 17:47:54 +08:00
|
|
|
/* ce ram size*/
|
2016-05-04 04:25:53 +08:00
|
|
|
unsigned ce_ram_size;
|
|
|
|
struct amdgpu_cu_info cu_info;
|
2016-07-08 03:01:42 +08:00
|
|
|
const struct amdgpu_gfx_funcs *funcs;
|
2016-07-15 11:28:30 +08:00
|
|
|
|
|
|
|
/* reset mask */
|
|
|
|
uint32_t grbm_soft_reset;
|
|
|
|
uint32_t srbm_soft_reset;
|
2017-01-26 15:32:16 +08:00
|
|
|
bool in_reset;
|
2017-03-29 00:52:08 +08:00
|
|
|
/* NGG */
|
|
|
|
struct amdgpu_ngg ngg;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
2016-01-31 19:29:04 +08:00
|
|
|
int amdgpu_ib_get(struct amdgpu_device *adev, struct amdgpu_vm *vm,
|
2015-04-21 04:51:00 +08:00
|
|
|
unsigned size, struct amdgpu_ib *ib);
|
2016-05-04 00:46:19 +08:00
|
|
|
void amdgpu_ib_free(struct amdgpu_device *adev, struct amdgpu_ib *ib,
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence *f);
|
2016-01-31 19:29:04 +08:00
|
|
|
int amdgpu_ib_schedule(struct amdgpu_ring *ring, unsigned num_ibs,
|
2017-01-23 16:30:38 +08:00
|
|
|
struct amdgpu_ib *ibs, struct amdgpu_job *job,
|
|
|
|
struct dma_fence **f);
|
2015-04-21 04:51:00 +08:00
|
|
|
int amdgpu_ib_pool_init(struct amdgpu_device *adev);
|
|
|
|
void amdgpu_ib_pool_fini(struct amdgpu_device *adev);
|
|
|
|
int amdgpu_ib_ring_tests(struct amdgpu_device *adev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CS.
|
|
|
|
*/
|
|
|
|
struct amdgpu_cs_chunk {
|
|
|
|
uint32_t chunk_id;
|
|
|
|
uint32_t length_dw;
|
2016-05-07 04:14:00 +08:00
|
|
|
void *kdata;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_cs_parser {
|
|
|
|
struct amdgpu_device *adev;
|
|
|
|
struct drm_file *filp;
|
2015-05-11 21:34:59 +08:00
|
|
|
struct amdgpu_ctx *ctx;
|
2015-12-15 21:41:33 +08:00
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/* chunks */
|
|
|
|
unsigned nchunks;
|
|
|
|
struct amdgpu_cs_chunk *chunks;
|
|
|
|
|
2016-02-03 20:44:52 +08:00
|
|
|
/* scheduler job object */
|
|
|
|
struct amdgpu_job *job;
|
2015-04-21 04:51:00 +08:00
|
|
|
|
2015-12-15 21:41:33 +08:00
|
|
|
/* buffer objects */
|
|
|
|
struct ww_acquire_ctx ticket;
|
|
|
|
struct amdgpu_bo_list *bo_list;
|
|
|
|
struct amdgpu_bo_list_entry vm_pd;
|
|
|
|
struct list_head validated;
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence *fence;
|
2015-12-15 21:41:33 +08:00
|
|
|
uint64_t bytes_moved_threshold;
|
|
|
|
uint64_t bytes_moved;
|
2016-09-01 18:13:18 +08:00
|
|
|
struct amdgpu_bo_list_entry *evictable;
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
/* user fence */
|
2015-12-14 23:42:31 +08:00
|
|
|
struct amdgpu_bo_list_entry uf_entry;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
2016-08-26 13:28:28 +08:00
|
|
|
#define AMDGPU_PREAMBLE_IB_PRESENT (1 << 0) /* bit set means command submit involves a preamble IB */
|
|
|
|
#define AMDGPU_PREAMBLE_IB_PRESENT_FIRST (1 << 1) /* bit set means preamble IB is first presented in belonging context */
|
|
|
|
#define AMDGPU_HAVE_CTX_SWITCH (1 << 2) /* bit set means context switch occured */
|
2017-01-17 10:55:42 +08:00
|
|
|
#define AMDGPU_VM_DOMAIN (1 << 3) /* bit set means in virtual memory context */
|
2016-08-26 13:28:28 +08:00
|
|
|
|
2015-08-18 15:16:40 +08:00
|
|
|
struct amdgpu_job {
|
|
|
|
struct amd_sched_job base;
|
|
|
|
struct amdgpu_device *adev;
|
2016-05-03 21:54:54 +08:00
|
|
|
struct amdgpu_vm *vm;
|
2016-01-31 19:29:04 +08:00
|
|
|
struct amdgpu_ring *ring;
|
2016-02-08 19:13:05 +08:00
|
|
|
struct amdgpu_sync sync;
|
2015-08-18 15:16:40 +08:00
|
|
|
struct amdgpu_ib *ibs;
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence *fence; /* the hw fence */
|
2016-08-26 13:28:28 +08:00
|
|
|
uint32_t preamble_status;
|
2015-08-18 15:16:40 +08:00
|
|
|
uint32_t num_ibs;
|
2015-11-06 02:49:48 +08:00
|
|
|
void *owner;
|
2016-08-25 15:40:48 +08:00
|
|
|
uint64_t fence_ctx; /* the fence_context this job uses */
|
2016-07-01 17:59:01 +08:00
|
|
|
bool vm_needs_flush;
|
2017-05-09 13:39:40 +08:00
|
|
|
bool need_pipeline_sync;
|
2016-05-06 23:50:03 +08:00
|
|
|
unsigned vm_id;
|
|
|
|
uint64_t vm_pd_addr;
|
|
|
|
uint32_t gds_base, gds_size;
|
|
|
|
uint32_t gws_base, gws_size;
|
|
|
|
uint32_t oa_base, oa_size;
|
2016-05-07 04:14:00 +08:00
|
|
|
|
|
|
|
/* user fence handling */
|
2016-06-29 19:26:41 +08:00
|
|
|
uint64_t uf_addr;
|
2016-05-07 04:14:00 +08:00
|
|
|
uint64_t uf_sequence;
|
|
|
|
|
2015-08-18 15:16:40 +08:00
|
|
|
};
|
2015-09-09 09:21:19 +08:00
|
|
|
#define to_amdgpu_job(sched_job) \
|
|
|
|
container_of((sched_job), struct amdgpu_job, base)
|
2015-08-18 15:16:40 +08:00
|
|
|
|
2016-01-31 18:00:41 +08:00
|
|
|
static inline u32 amdgpu_get_ib_value(struct amdgpu_cs_parser *p,
|
|
|
|
uint32_t ib_idx, int idx)
|
2015-04-21 04:51:00 +08:00
|
|
|
{
|
2016-02-03 20:44:52 +08:00
|
|
|
return p->job->ibs[ib_idx].ptr[idx];
|
2015-04-21 04:51:00 +08:00
|
|
|
}
|
|
|
|
|
2016-01-31 18:00:41 +08:00
|
|
|
static inline void amdgpu_set_ib_value(struct amdgpu_cs_parser *p,
|
|
|
|
uint32_t ib_idx, int idx,
|
|
|
|
uint32_t value)
|
|
|
|
{
|
2016-02-03 20:44:52 +08:00
|
|
|
p->job->ibs[ib_idx].ptr[idx] = value;
|
2016-01-31 18:00:41 +08:00
|
|
|
}
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* Writeback
|
|
|
|
*/
|
|
|
|
#define AMDGPU_MAX_WB 1024 /* Reserve at most 1024 WB slots for amdgpu-owned rings. */
|
|
|
|
|
|
|
|
struct amdgpu_wb {
|
|
|
|
struct amdgpu_bo *wb_obj;
|
|
|
|
volatile uint32_t *wb;
|
|
|
|
uint64_t gpu_addr;
|
|
|
|
u32 num_wb; /* Number of wb slots actually reserved for amdgpu. */
|
|
|
|
unsigned long used[DIV_ROUND_UP(AMDGPU_MAX_WB, BITS_PER_LONG)];
|
|
|
|
};
|
|
|
|
|
|
|
|
int amdgpu_wb_get(struct amdgpu_device *adev, u32 *wb);
|
|
|
|
void amdgpu_wb_free(struct amdgpu_device *adev, u32 wb);
|
2016-03-18 15:08:49 +08:00
|
|
|
int amdgpu_wb_get_64bit(struct amdgpu_device *adev, u32 *wb);
|
|
|
|
void amdgpu_wb_free_64bit(struct amdgpu_device *adev, u32 wb);
|
2015-04-21 04:51:00 +08:00
|
|
|
|
2015-11-12 08:45:06 +08:00
|
|
|
void amdgpu_get_pcie_info(struct amdgpu_device *adev);
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* SDMA
|
|
|
|
*/
|
2015-10-09 04:30:37 +08:00
|
|
|
struct amdgpu_sdma_instance {
|
2015-04-21 04:51:00 +08:00
|
|
|
/* SDMA firmware */
|
|
|
|
const struct firmware *fw;
|
|
|
|
uint32_t fw_version;
|
2015-08-04 10:50:47 +08:00
|
|
|
uint32_t feature_version;
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
struct amdgpu_ring ring;
|
2015-08-31 14:06:39 +08:00
|
|
|
bool burst_nop;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
2015-10-09 04:30:37 +08:00
|
|
|
struct amdgpu_sdma {
|
|
|
|
struct amdgpu_sdma_instance instance[AMDGPU_MAX_SDMA_INSTANCES];
|
2016-01-19 14:05:23 +08:00
|
|
|
#ifdef CONFIG_DRM_AMDGPU_SI
|
|
|
|
//SI DMA has a difference trap irq number for the second engine
|
|
|
|
struct amdgpu_irq_src trap_irq_1;
|
|
|
|
#endif
|
2015-10-09 04:30:37 +08:00
|
|
|
struct amdgpu_irq_src trap_irq;
|
|
|
|
struct amdgpu_irq_src illegal_inst_irq;
|
2016-05-03 21:54:54 +08:00
|
|
|
int num_instances;
|
2016-07-13 10:28:56 +08:00
|
|
|
uint32_t srbm_soft_reset;
|
2015-10-09 04:30:37 +08:00
|
|
|
};
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* Firmware
|
|
|
|
*/
|
2016-11-01 15:35:38 +08:00
|
|
|
enum amdgpu_firmware_load_type {
|
|
|
|
AMDGPU_FW_LOAD_DIRECT = 0,
|
|
|
|
AMDGPU_FW_LOAD_SMU,
|
|
|
|
AMDGPU_FW_LOAD_PSP,
|
|
|
|
};
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_firmware {
|
|
|
|
struct amdgpu_firmware_info ucode[AMDGPU_UCODE_ID_MAXIMUM];
|
2016-11-01 15:35:38 +08:00
|
|
|
enum amdgpu_firmware_load_type load_type;
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_bo *fw_buf;
|
|
|
|
unsigned int fw_size;
|
2017-03-04 05:20:35 +08:00
|
|
|
unsigned int max_ucodes;
|
2017-03-04 07:37:23 +08:00
|
|
|
/* firmwares are loaded by psp instead of smu from vega10 */
|
|
|
|
const struct amdgpu_psp_funcs *funcs;
|
|
|
|
struct amdgpu_bo *rbuf;
|
|
|
|
struct mutex mutex;
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Benchmarking
|
|
|
|
*/
|
|
|
|
void amdgpu_benchmark(struct amdgpu_device *adev, int test_number);
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Testing
|
|
|
|
*/
|
|
|
|
void amdgpu_test_moves(struct amdgpu_device *adev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MMU Notifier
|
|
|
|
*/
|
|
|
|
#if defined(CONFIG_MMU_NOTIFIER)
|
|
|
|
int amdgpu_mn_register(struct amdgpu_bo *bo, unsigned long addr);
|
|
|
|
void amdgpu_mn_unregister(struct amdgpu_bo *bo);
|
|
|
|
#else
|
2015-07-15 19:10:41 +08:00
|
|
|
static inline int amdgpu_mn_register(struct amdgpu_bo *bo, unsigned long addr)
|
2015-04-21 04:51:00 +08:00
|
|
|
{
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2015-07-15 19:10:41 +08:00
|
|
|
static inline void amdgpu_mn_unregister(struct amdgpu_bo *bo) {}
|
2015-04-21 04:51:00 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Debugfs
|
|
|
|
*/
|
|
|
|
struct amdgpu_debugfs {
|
2016-05-03 00:46:15 +08:00
|
|
|
const struct drm_info_list *files;
|
2015-04-21 04:51:00 +08:00
|
|
|
unsigned num_files;
|
|
|
|
};
|
|
|
|
|
|
|
|
int amdgpu_debugfs_add_files(struct amdgpu_device *adev,
|
2016-05-03 00:46:15 +08:00
|
|
|
const struct drm_info_list *files,
|
2015-04-21 04:51:00 +08:00
|
|
|
unsigned nfiles);
|
|
|
|
int amdgpu_debugfs_fence_init(struct amdgpu_device *adev);
|
|
|
|
|
|
|
|
#if defined(CONFIG_DEBUG_FS)
|
|
|
|
int amdgpu_debugfs_init(struct drm_minor *minor);
|
|
|
|
#endif
|
|
|
|
|
drm/amdgpu: introduce a firmware debugfs to dump all current firmware versions
This patch implements the debugfs to dump all currect firmware
version:
root@jenkins-All-Series:/home/jenkins# cat /sys/kernel/debug/dri/0/amdgpu_firmware_info
VCE feature version: 0, firmware version: 0x34040300
UVD feature version: 0, firmware version: 0x01451000
MC feature version: 0, firmware version: 0x00000000
ME feature version: 37, firmware version: 0x00000093
PFP feature version: 37, firmware version: 0x000000da
CE feature version: 37, firmware version: 0x00000080
RLC feature version: 1, firmware version: 0x0000010e
MEC feature version: 37, firmware version: 0x0000029e
MEC2 feature version: 37, firmware version: 0x0000029e
SMC feature version: 0, firmware version: 0x013353e6
SDMA0 feature version: 31, firmware version: 0x00000036
SDMA1 feature version: 0, firmware version: 0x00000036
Suggested-by: Alex Deucher <Alexander.Deucher@amd.com>
Signed-off-by: Huang Rui <ray.huang@amd.com>
Reviewed-by: Christian König <christian.koenig@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
2016-06-12 15:51:09 +08:00
|
|
|
int amdgpu_debugfs_firmware_init(struct amdgpu_device *adev);
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* amdgpu smumgr functions
|
|
|
|
*/
|
|
|
|
struct amdgpu_smumgr_funcs {
|
|
|
|
int (*check_fw_load_finish)(struct amdgpu_device *adev, uint32_t fwtype);
|
|
|
|
int (*request_smu_load_fw)(struct amdgpu_device *adev);
|
|
|
|
int (*request_smu_specific_fw)(struct amdgpu_device *adev, uint32_t fwtype);
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* amdgpu smumgr
|
|
|
|
*/
|
|
|
|
struct amdgpu_smumgr {
|
|
|
|
struct amdgpu_bo *toc_buf;
|
|
|
|
struct amdgpu_bo *smu_buf;
|
|
|
|
/* asic priv smu data */
|
|
|
|
void *priv;
|
|
|
|
spinlock_t smu_lock;
|
|
|
|
/* smumgr functions */
|
|
|
|
const struct amdgpu_smumgr_funcs *smumgr_funcs;
|
|
|
|
/* ucode loading complete flag */
|
|
|
|
uint32_t fw_flags;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ASIC specific register table accessible by UMD
|
|
|
|
*/
|
|
|
|
struct amdgpu_allowed_register_entry {
|
|
|
|
uint32_t reg_offset;
|
|
|
|
bool untouched;
|
|
|
|
bool grbm_indexed;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ASIC specific functions.
|
|
|
|
*/
|
|
|
|
struct amdgpu_asic_funcs {
|
|
|
|
bool (*read_disabled_bios)(struct amdgpu_device *adev);
|
2015-11-24 23:14:28 +08:00
|
|
|
bool (*read_bios_from_rom)(struct amdgpu_device *adev,
|
|
|
|
u8 *bios, u32 length_bytes);
|
2015-04-21 04:51:00 +08:00
|
|
|
int (*read_register)(struct amdgpu_device *adev, u32 se_num,
|
|
|
|
u32 sh_num, u32 reg_offset, u32 *value);
|
|
|
|
void (*set_vga_state)(struct amdgpu_device *adev, bool state);
|
|
|
|
int (*reset)(struct amdgpu_device *adev);
|
|
|
|
/* get the reference clock */
|
|
|
|
u32 (*get_xclk)(struct amdgpu_device *adev);
|
|
|
|
/* MM block clocks */
|
|
|
|
int (*set_uvd_clocks)(struct amdgpu_device *adev, u32 vclk, u32 dclk);
|
|
|
|
int (*set_vce_clocks)(struct amdgpu_device *adev, u32 evclk, u32 ecclk);
|
2016-08-02 00:42:32 +08:00
|
|
|
/* static power management */
|
|
|
|
int (*get_pcie_lanes)(struct amdgpu_device *adev);
|
|
|
|
void (*set_pcie_lanes)(struct amdgpu_device *adev, int lanes);
|
2017-03-04 06:26:10 +08:00
|
|
|
/* get config memsize register */
|
|
|
|
u32 (*get_config_memsize)(struct amdgpu_device *adev);
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IOCTL.
|
|
|
|
*/
|
|
|
|
int amdgpu_gem_create_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *filp);
|
|
|
|
int amdgpu_bo_list_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *filp);
|
|
|
|
|
|
|
|
int amdgpu_gem_info_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *filp);
|
|
|
|
int amdgpu_gem_userptr_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *filp);
|
|
|
|
int amdgpu_gem_mmap_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *filp);
|
|
|
|
int amdgpu_gem_wait_idle_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *filp);
|
|
|
|
int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *filp);
|
|
|
|
int amdgpu_gem_op_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *filp);
|
|
|
|
int amdgpu_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp);
|
|
|
|
int amdgpu_cs_wait_ioctl(struct drm_device *dev, void *data, struct drm_file *filp);
|
2016-11-05 04:16:10 +08:00
|
|
|
int amdgpu_cs_wait_fences_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *filp);
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
int amdgpu_gem_metadata_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *filp);
|
|
|
|
|
|
|
|
/* VRAM scratch page for HDP bug, default vram page */
|
|
|
|
struct amdgpu_vram_scratch {
|
|
|
|
struct amdgpu_bo *robj;
|
|
|
|
volatile uint32_t *ptr;
|
|
|
|
u64 gpu_addr;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ACPI
|
|
|
|
*/
|
|
|
|
struct amdgpu_atif_notification_cfg {
|
|
|
|
bool enabled;
|
|
|
|
int command_code;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_atif_notifications {
|
|
|
|
bool display_switch;
|
|
|
|
bool expansion_mode_change;
|
|
|
|
bool thermal_state;
|
|
|
|
bool forced_power_state;
|
|
|
|
bool system_power_state;
|
|
|
|
bool display_conf_change;
|
|
|
|
bool px_gfx_switch;
|
|
|
|
bool brightness_change;
|
|
|
|
bool dgpu_display_event;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_atif_functions {
|
|
|
|
bool system_params;
|
|
|
|
bool sbios_requests;
|
|
|
|
bool select_active_disp;
|
|
|
|
bool lid_state;
|
|
|
|
bool get_tv_standard;
|
|
|
|
bool set_tv_standard;
|
|
|
|
bool get_panel_expansion_mode;
|
|
|
|
bool set_panel_expansion_mode;
|
|
|
|
bool temperature_change;
|
|
|
|
bool graphics_device_types;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_atif {
|
|
|
|
struct amdgpu_atif_notifications notifications;
|
|
|
|
struct amdgpu_atif_functions functions;
|
|
|
|
struct amdgpu_atif_notification_cfg notification_cfg;
|
|
|
|
struct amdgpu_encoder *encoder_for_bl;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_atcs_functions {
|
|
|
|
bool get_ext_state;
|
|
|
|
bool pcie_perf_req;
|
|
|
|
bool pcie_dev_rdy;
|
|
|
|
bool pcie_bus_width;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_atcs {
|
|
|
|
struct amdgpu_atcs_functions functions;
|
|
|
|
};
|
|
|
|
|
2015-07-29 02:20:03 +08:00
|
|
|
/*
|
|
|
|
* CGS
|
|
|
|
*/
|
2016-04-12 11:25:48 +08:00
|
|
|
struct cgs_device *amdgpu_cgs_create_device(struct amdgpu_device *adev);
|
|
|
|
void amdgpu_cgs_destroy_device(struct cgs_device *cgs_device);
|
2015-09-23 05:05:20 +08:00
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* Core structure, functions and helpers.
|
|
|
|
*/
|
|
|
|
typedef uint32_t (*amdgpu_rreg_t)(struct amdgpu_device*, uint32_t);
|
|
|
|
typedef void (*amdgpu_wreg_t)(struct amdgpu_device*, uint32_t, uint32_t);
|
|
|
|
|
|
|
|
typedef uint32_t (*amdgpu_block_rreg_t)(struct amdgpu_device*, uint32_t, uint32_t);
|
|
|
|
typedef void (*amdgpu_block_wreg_t)(struct amdgpu_device*, uint32_t, uint32_t, uint32_t);
|
|
|
|
|
|
|
|
struct amdgpu_device {
|
|
|
|
struct device *dev;
|
|
|
|
struct drm_device *ddev;
|
|
|
|
struct pci_dev *pdev;
|
|
|
|
|
2015-09-23 05:05:20 +08:00
|
|
|
#ifdef CONFIG_DRM_AMD_ACP
|
|
|
|
struct amdgpu_acp acp;
|
|
|
|
#endif
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/* ASIC */
|
2015-07-22 11:29:01 +08:00
|
|
|
enum amd_asic_type asic_type;
|
2015-04-21 04:51:00 +08:00
|
|
|
uint32_t family;
|
|
|
|
uint32_t rev_id;
|
|
|
|
uint32_t external_rev_id;
|
|
|
|
unsigned long flags;
|
|
|
|
int usec_timeout;
|
|
|
|
const struct amdgpu_asic_funcs *asic_funcs;
|
|
|
|
bool shutdown;
|
|
|
|
bool need_dma32;
|
|
|
|
bool accel_working;
|
2016-05-03 21:54:54 +08:00
|
|
|
struct work_struct reset_work;
|
2015-04-21 04:51:00 +08:00
|
|
|
struct notifier_block acpi_nb;
|
|
|
|
struct amdgpu_i2c_chan *i2c_bus[AMDGPU_MAX_I2C_BUS];
|
|
|
|
struct amdgpu_debugfs debugfs[AMDGPU_DEBUGFS_MAX_COMPONENTS];
|
2016-05-03 21:54:54 +08:00
|
|
|
unsigned debugfs_count;
|
2015-04-21 04:51:00 +08:00
|
|
|
#if defined(CONFIG_DEBUG_FS)
|
2016-04-16 01:08:44 +08:00
|
|
|
struct dentry *debugfs_regs[AMDGPU_DEBUGFS_MAX_COMPONENTS];
|
2015-04-21 04:51:00 +08:00
|
|
|
#endif
|
|
|
|
struct amdgpu_atif atif;
|
|
|
|
struct amdgpu_atcs atcs;
|
|
|
|
struct mutex srbm_mutex;
|
|
|
|
/* GRBM index mutex. Protects concurrent access to GRBM index */
|
|
|
|
struct mutex grbm_idx_mutex;
|
|
|
|
struct dev_pm_domain vga_pm_domain;
|
|
|
|
bool have_disp_power_ref;
|
|
|
|
|
|
|
|
/* BIOS */
|
2017-02-14 05:01:58 +08:00
|
|
|
bool is_atom_fw;
|
2015-04-21 04:51:00 +08:00
|
|
|
uint8_t *bios;
|
2016-12-07 09:56:46 +08:00
|
|
|
uint32_t bios_size;
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_bo *stollen_vga_memory;
|
2016-09-24 04:23:41 +08:00
|
|
|
uint32_t bios_scratch_reg_offset;
|
2015-04-21 04:51:00 +08:00
|
|
|
uint32_t bios_scratch[AMDGPU_BIOS_NUM_SCRATCH];
|
|
|
|
|
|
|
|
/* Register/doorbell mmio */
|
|
|
|
resource_size_t rmmio_base;
|
|
|
|
resource_size_t rmmio_size;
|
|
|
|
void __iomem *rmmio;
|
|
|
|
/* protects concurrent MM_INDEX/DATA based register access */
|
|
|
|
spinlock_t mmio_idx_lock;
|
|
|
|
/* protects concurrent SMC based register access */
|
|
|
|
spinlock_t smc_idx_lock;
|
|
|
|
amdgpu_rreg_t smc_rreg;
|
|
|
|
amdgpu_wreg_t smc_wreg;
|
|
|
|
/* protects concurrent PCIE register access */
|
|
|
|
spinlock_t pcie_idx_lock;
|
|
|
|
amdgpu_rreg_t pcie_rreg;
|
|
|
|
amdgpu_wreg_t pcie_wreg;
|
2016-08-31 13:23:25 +08:00
|
|
|
amdgpu_rreg_t pciep_rreg;
|
|
|
|
amdgpu_wreg_t pciep_wreg;
|
2015-04-21 04:51:00 +08:00
|
|
|
/* protects concurrent UVD register access */
|
|
|
|
spinlock_t uvd_ctx_idx_lock;
|
|
|
|
amdgpu_rreg_t uvd_ctx_rreg;
|
|
|
|
amdgpu_wreg_t uvd_ctx_wreg;
|
|
|
|
/* protects concurrent DIDT register access */
|
|
|
|
spinlock_t didt_idx_lock;
|
|
|
|
amdgpu_rreg_t didt_rreg;
|
|
|
|
amdgpu_wreg_t didt_wreg;
|
2016-06-08 12:47:41 +08:00
|
|
|
/* protects concurrent gc_cac register access */
|
|
|
|
spinlock_t gc_cac_idx_lock;
|
|
|
|
amdgpu_rreg_t gc_cac_rreg;
|
|
|
|
amdgpu_wreg_t gc_cac_wreg;
|
2015-04-21 04:51:00 +08:00
|
|
|
/* protects concurrent ENDPOINT (audio) register access */
|
|
|
|
spinlock_t audio_endpt_idx_lock;
|
|
|
|
amdgpu_block_rreg_t audio_endpt_rreg;
|
|
|
|
amdgpu_block_wreg_t audio_endpt_wreg;
|
|
|
|
void __iomem *rio_mem;
|
|
|
|
resource_size_t rio_mem_size;
|
|
|
|
struct amdgpu_doorbell doorbell;
|
|
|
|
|
|
|
|
/* clock/pll info */
|
|
|
|
struct amdgpu_clock clock;
|
|
|
|
|
|
|
|
/* MC */
|
|
|
|
struct amdgpu_mc mc;
|
|
|
|
struct amdgpu_gart gart;
|
|
|
|
struct amdgpu_dummy_page dummy_page;
|
|
|
|
struct amdgpu_vm_manager vm_manager;
|
2017-03-10 00:36:26 +08:00
|
|
|
struct amdgpu_vmhub vmhub[AMDGPU_MAX_VMHUBS];
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
/* memory management */
|
|
|
|
struct amdgpu_mman mman;
|
|
|
|
struct amdgpu_vram_scratch vram_scratch;
|
|
|
|
struct amdgpu_wb wb;
|
|
|
|
atomic64_t vram_usage;
|
|
|
|
atomic64_t vram_vis_usage;
|
|
|
|
atomic64_t gtt_usage;
|
|
|
|
atomic64_t num_bytes_moved;
|
2016-06-21 22:28:14 +08:00
|
|
|
atomic64_t num_evictions;
|
2015-05-06 03:13:49 +08:00
|
|
|
atomic_t gpu_reset_counter;
|
2015-04-21 04:51:00 +08:00
|
|
|
|
2016-08-18 05:49:27 +08:00
|
|
|
/* data for buffer migration throttling */
|
|
|
|
struct {
|
|
|
|
spinlock_t lock;
|
|
|
|
s64 last_update_us;
|
|
|
|
s64 accum_us; /* accumulated microseconds */
|
|
|
|
u32 log2_max_MBps;
|
|
|
|
} mm_stats;
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/* display */
|
2016-08-10 16:01:25 +08:00
|
|
|
bool enable_virtual_display;
|
2015-04-21 04:51:00 +08:00
|
|
|
struct amdgpu_mode_info mode_info;
|
|
|
|
struct work_struct hotplug_work;
|
|
|
|
struct amdgpu_irq_src crtc_irq;
|
|
|
|
struct amdgpu_irq_src pageflip_irq;
|
|
|
|
struct amdgpu_irq_src hpd_irq;
|
|
|
|
|
|
|
|
/* rings */
|
2016-06-01 21:10:02 +08:00
|
|
|
u64 fence_context;
|
2015-04-21 04:51:00 +08:00
|
|
|
unsigned num_rings;
|
|
|
|
struct amdgpu_ring *rings[AMDGPU_MAX_RINGS];
|
|
|
|
bool ib_pool_ready;
|
|
|
|
struct amdgpu_sa_manager ring_tmp_bo;
|
|
|
|
|
|
|
|
/* interrupts */
|
|
|
|
struct amdgpu_irq irq;
|
|
|
|
|
2015-12-03 06:46:21 +08:00
|
|
|
/* powerplay */
|
|
|
|
struct amd_powerplay powerplay;
|
2015-11-11 07:31:08 +08:00
|
|
|
bool pp_enabled;
|
drm/amd/powerplay: add some sysfs interfaces for powerplay.
The new sysfs interfaces:
pp_num_states: Read-only, return the number of all pp states, 0 if powerplay is not available.
pp_cur_state: Read-only, return the index number of current pp state.
pp_force_state: Read-write, to write a power state index will switch to selected state forcedly and
enable forced state mode, disable forced state mode. such as "echo >...".
pp_table: Read-write, binary output, to be used to read or write the dpm table, the maximum
file size is 4KB of page size.
pp_dpm_sclk: Read-write, reading will return a dpm levels list, to write an index number will force
powerplay to set the corresponding dpm level.
pp_dpm_mclk: same as sclk.
pp_dpm_pcie: same as sclk.
And add new setting "manual" to the existing interface power_dpm_force_performance_level.
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: Eric Huang <JinHuiEric.Huang@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
2015-12-12 05:24:34 +08:00
|
|
|
bool pp_force_state_enabled;
|
2015-12-03 06:46:21 +08:00
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/* dpm */
|
|
|
|
struct amdgpu_pm pm;
|
|
|
|
u32 cg_flags;
|
|
|
|
u32 pg_flags;
|
|
|
|
|
|
|
|
/* amdgpu smumgr */
|
|
|
|
struct amdgpu_smumgr smu;
|
|
|
|
|
|
|
|
/* gfx */
|
|
|
|
struct amdgpu_gfx gfx;
|
|
|
|
|
|
|
|
/* sdma */
|
2015-10-09 04:30:37 +08:00
|
|
|
struct amdgpu_sdma sdma;
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
/* uvd */
|
|
|
|
struct amdgpu_uvd uvd;
|
|
|
|
|
|
|
|
/* vce */
|
|
|
|
struct amdgpu_vce vce;
|
|
|
|
|
|
|
|
/* firmwares */
|
|
|
|
struct amdgpu_firmware firmware;
|
|
|
|
|
2017-03-04 07:37:23 +08:00
|
|
|
/* PSP */
|
|
|
|
struct psp_context psp;
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/* GDS */
|
|
|
|
struct amdgpu_gds gds;
|
|
|
|
|
2016-10-14 05:41:13 +08:00
|
|
|
struct amdgpu_ip_block ip_blocks[AMDGPU_MAX_IP_NUM];
|
2015-04-21 04:51:00 +08:00
|
|
|
int num_ip_blocks;
|
|
|
|
struct mutex mn_lock;
|
|
|
|
DECLARE_HASHTABLE(mn_hash, 7);
|
|
|
|
|
|
|
|
/* tracking pinned memory */
|
|
|
|
u64 vram_pin_size;
|
2016-04-05 10:48:48 +08:00
|
|
|
u64 invisible_pin_size;
|
2015-04-21 04:51:00 +08:00
|
|
|
u64 gart_pin_size;
|
2015-06-13 02:35:14 +08:00
|
|
|
|
|
|
|
/* amdkfd interface */
|
|
|
|
struct kfd_dev *kfd;
|
2015-07-06 13:42:58 +08:00
|
|
|
|
2017-01-10 07:06:57 +08:00
|
|
|
struct amdgpu_virt virt;
|
2016-08-17 11:41:30 +08:00
|
|
|
|
|
|
|
/* link all shadow bo */
|
|
|
|
struct list_head shadow_list;
|
|
|
|
struct mutex shadow_list_lock;
|
2016-08-30 16:13:10 +08:00
|
|
|
/* link all gtt */
|
|
|
|
spinlock_t gtt_list_lock;
|
|
|
|
struct list_head gtt_list;
|
|
|
|
|
2017-02-10 15:59:59 +08:00
|
|
|
/* record hw reset is performed */
|
|
|
|
bool has_hw_reset;
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
};
|
|
|
|
|
2016-09-15 20:58:48 +08:00
|
|
|
static inline struct amdgpu_device *amdgpu_ttm_adev(struct ttm_bo_device *bdev)
|
|
|
|
{
|
|
|
|
return container_of(bdev, struct amdgpu_device, mman.bdev);
|
|
|
|
}
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
bool amdgpu_device_is_px(struct drm_device *dev);
|
|
|
|
int amdgpu_device_init(struct amdgpu_device *adev,
|
|
|
|
struct drm_device *ddev,
|
|
|
|
struct pci_dev *pdev,
|
|
|
|
uint32_t flags);
|
|
|
|
void amdgpu_device_fini(struct amdgpu_device *adev);
|
|
|
|
int amdgpu_gpu_wait_for_idle(struct amdgpu_device *adev);
|
|
|
|
|
|
|
|
uint32_t amdgpu_mm_rreg(struct amdgpu_device *adev, uint32_t reg,
|
2017-01-25 15:07:40 +08:00
|
|
|
uint32_t acc_flags);
|
2015-04-21 04:51:00 +08:00
|
|
|
void amdgpu_mm_wreg(struct amdgpu_device *adev, uint32_t reg, uint32_t v,
|
2017-01-25 15:07:40 +08:00
|
|
|
uint32_t acc_flags);
|
2015-04-21 04:51:00 +08:00
|
|
|
u32 amdgpu_io_rreg(struct amdgpu_device *adev, u32 reg);
|
|
|
|
void amdgpu_io_wreg(struct amdgpu_device *adev, u32 reg, u32 v);
|
|
|
|
|
|
|
|
u32 amdgpu_mm_rdoorbell(struct amdgpu_device *adev, u32 index);
|
|
|
|
void amdgpu_mm_wdoorbell(struct amdgpu_device *adev, u32 index, u32 v);
|
2016-03-18 15:23:08 +08:00
|
|
|
u64 amdgpu_mm_rdoorbell64(struct amdgpu_device *adev, u32 index);
|
|
|
|
void amdgpu_mm_wdoorbell64(struct amdgpu_device *adev, u32 index, u64 v);
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Registers read & write functions.
|
|
|
|
*/
|
2017-01-25 15:07:40 +08:00
|
|
|
|
|
|
|
#define AMDGPU_REGS_IDX (1<<0)
|
|
|
|
#define AMDGPU_REGS_NO_KIQ (1<<1)
|
|
|
|
|
|
|
|
#define RREG32_NO_KIQ(reg) amdgpu_mm_rreg(adev, (reg), AMDGPU_REGS_NO_KIQ)
|
|
|
|
#define WREG32_NO_KIQ(reg, v) amdgpu_mm_wreg(adev, (reg), (v), AMDGPU_REGS_NO_KIQ)
|
|
|
|
|
|
|
|
#define RREG32(reg) amdgpu_mm_rreg(adev, (reg), 0)
|
|
|
|
#define RREG32_IDX(reg) amdgpu_mm_rreg(adev, (reg), AMDGPU_REGS_IDX)
|
|
|
|
#define DREG32(reg) printk(KERN_INFO "REGISTER: " #reg " : 0x%08X\n", amdgpu_mm_rreg(adev, (reg), 0))
|
|
|
|
#define WREG32(reg, v) amdgpu_mm_wreg(adev, (reg), (v), 0)
|
|
|
|
#define WREG32_IDX(reg, v) amdgpu_mm_wreg(adev, (reg), (v), AMDGPU_REGS_IDX)
|
2015-04-21 04:51:00 +08:00
|
|
|
#define REG_SET(FIELD, v) (((v) << FIELD##_SHIFT) & FIELD##_MASK)
|
|
|
|
#define REG_GET(FIELD, v) (((v) << FIELD##_SHIFT) & FIELD##_MASK)
|
|
|
|
#define RREG32_PCIE(reg) adev->pcie_rreg(adev, (reg))
|
|
|
|
#define WREG32_PCIE(reg, v) adev->pcie_wreg(adev, (reg), (v))
|
2016-08-31 13:23:25 +08:00
|
|
|
#define RREG32_PCIE_PORT(reg) adev->pciep_rreg(adev, (reg))
|
|
|
|
#define WREG32_PCIE_PORT(reg, v) adev->pciep_wreg(adev, (reg), (v))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define RREG32_SMC(reg) adev->smc_rreg(adev, (reg))
|
|
|
|
#define WREG32_SMC(reg, v) adev->smc_wreg(adev, (reg), (v))
|
|
|
|
#define RREG32_UVD_CTX(reg) adev->uvd_ctx_rreg(adev, (reg))
|
|
|
|
#define WREG32_UVD_CTX(reg, v) adev->uvd_ctx_wreg(adev, (reg), (v))
|
|
|
|
#define RREG32_DIDT(reg) adev->didt_rreg(adev, (reg))
|
|
|
|
#define WREG32_DIDT(reg, v) adev->didt_wreg(adev, (reg), (v))
|
2016-06-08 12:47:41 +08:00
|
|
|
#define RREG32_GC_CAC(reg) adev->gc_cac_rreg(adev, (reg))
|
|
|
|
#define WREG32_GC_CAC(reg, v) adev->gc_cac_wreg(adev, (reg), (v))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define RREG32_AUDIO_ENDPT(block, reg) adev->audio_endpt_rreg(adev, (block), (reg))
|
|
|
|
#define WREG32_AUDIO_ENDPT(block, reg, v) adev->audio_endpt_wreg(adev, (block), (reg), (v))
|
|
|
|
#define WREG32_P(reg, val, mask) \
|
|
|
|
do { \
|
|
|
|
uint32_t tmp_ = RREG32(reg); \
|
|
|
|
tmp_ &= (mask); \
|
|
|
|
tmp_ |= ((val) & ~(mask)); \
|
|
|
|
WREG32(reg, tmp_); \
|
|
|
|
} while (0)
|
|
|
|
#define WREG32_AND(reg, and) WREG32_P(reg, 0, and)
|
|
|
|
#define WREG32_OR(reg, or) WREG32_P(reg, or, ~(or))
|
|
|
|
#define WREG32_PLL_P(reg, val, mask) \
|
|
|
|
do { \
|
|
|
|
uint32_t tmp_ = RREG32_PLL(reg); \
|
|
|
|
tmp_ &= (mask); \
|
|
|
|
tmp_ |= ((val) & ~(mask)); \
|
|
|
|
WREG32_PLL(reg, tmp_); \
|
|
|
|
} while (0)
|
|
|
|
#define DREG32_SYS(sqf, adev, reg) seq_printf((sqf), #reg " : 0x%08X\n", amdgpu_mm_rreg((adev), (reg), false))
|
|
|
|
#define RREG32_IO(reg) amdgpu_io_rreg(adev, (reg))
|
|
|
|
#define WREG32_IO(reg, v) amdgpu_io_wreg(adev, (reg), (v))
|
|
|
|
|
|
|
|
#define RDOORBELL32(index) amdgpu_mm_rdoorbell(adev, (index))
|
|
|
|
#define WDOORBELL32(index, v) amdgpu_mm_wdoorbell(adev, (index), (v))
|
2016-03-18 15:23:08 +08:00
|
|
|
#define RDOORBELL64(index) amdgpu_mm_rdoorbell64(adev, (index))
|
|
|
|
#define WDOORBELL64(index, v) amdgpu_mm_wdoorbell64(adev, (index), (v))
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
#define REG_FIELD_SHIFT(reg, field) reg##__##field##__SHIFT
|
|
|
|
#define REG_FIELD_MASK(reg, field) reg##__##field##_MASK
|
|
|
|
|
|
|
|
#define REG_SET_FIELD(orig_val, reg, field, field_val) \
|
|
|
|
(((orig_val) & ~REG_FIELD_MASK(reg, field)) | \
|
|
|
|
(REG_FIELD_MASK(reg, field) & ((field_val) << REG_FIELD_SHIFT(reg, field))))
|
|
|
|
|
|
|
|
#define REG_GET_FIELD(value, reg, field) \
|
|
|
|
(((value) & REG_FIELD_MASK(reg, field)) >> REG_FIELD_SHIFT(reg, field))
|
2016-08-09 22:13:21 +08:00
|
|
|
|
|
|
|
#define WREG32_FIELD(reg, field, val) \
|
|
|
|
WREG32(mm##reg, (RREG32(mm##reg) & ~REG_FIELD_MASK(reg, field)) | (val) << REG_FIELD_SHIFT(reg, field))
|
2015-04-21 04:51:00 +08:00
|
|
|
|
2017-04-04 21:14:13 +08:00
|
|
|
#define WREG32_FIELD_OFFSET(reg, offset, field, val) \
|
|
|
|
WREG32(mm##reg + offset, (RREG32(mm##reg + offset) & ~REG_FIELD_MASK(reg, field)) | (val) << REG_FIELD_SHIFT(reg, field))
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* BIOS helpers.
|
|
|
|
*/
|
|
|
|
#define RBIOS8(i) (adev->bios[i])
|
|
|
|
#define RBIOS16(i) (RBIOS8(i) | (RBIOS8((i)+1) << 8))
|
|
|
|
#define RBIOS32(i) ((RBIOS16(i)) | (RBIOS16((i)+2) << 16))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* RING helpers.
|
|
|
|
*/
|
|
|
|
static inline void amdgpu_ring_write(struct amdgpu_ring *ring, uint32_t v)
|
|
|
|
{
|
|
|
|
if (ring->count_dw <= 0)
|
2015-05-13 22:52:42 +08:00
|
|
|
DRM_ERROR("amdgpu: writing more dwords to the ring than expected!\n");
|
2016-03-12 09:32:30 +08:00
|
|
|
ring->ring[ring->wptr++ & ring->buf_mask] = v;
|
2015-04-21 04:51:00 +08:00
|
|
|
ring->wptr &= ring->ptr_mask;
|
|
|
|
ring->count_dw--;
|
|
|
|
}
|
|
|
|
|
2017-01-17 10:52:33 +08:00
|
|
|
static inline void amdgpu_ring_write_multiple(struct amdgpu_ring *ring, void *src, int count_dw)
|
|
|
|
{
|
|
|
|
unsigned occupied, chunk1, chunk2;
|
|
|
|
void *dst;
|
|
|
|
|
|
|
|
if (ring->count_dw < count_dw) {
|
|
|
|
DRM_ERROR("amdgpu: writing more dwords to the ring than expected!\n");
|
|
|
|
} else {
|
2017-03-23 16:10:04 +08:00
|
|
|
occupied = ring->wptr & ring->buf_mask;
|
2017-01-17 10:52:33 +08:00
|
|
|
dst = (void *)&ring->ring[occupied];
|
2017-03-23 16:10:04 +08:00
|
|
|
chunk1 = ring->buf_mask + 1 - occupied;
|
2017-01-17 10:52:33 +08:00
|
|
|
chunk1 = (chunk1 >= count_dw) ? count_dw: chunk1;
|
|
|
|
chunk2 = count_dw - chunk1;
|
|
|
|
chunk1 <<= 2;
|
|
|
|
chunk2 <<= 2;
|
|
|
|
|
|
|
|
if (chunk1)
|
|
|
|
memcpy(dst, src, chunk1);
|
|
|
|
|
|
|
|
if (chunk2) {
|
|
|
|
src += chunk1;
|
|
|
|
dst = (void *)ring->ring;
|
|
|
|
memcpy(dst, src, chunk2);
|
|
|
|
}
|
|
|
|
|
|
|
|
ring->wptr += count_dw;
|
|
|
|
ring->wptr &= ring->ptr_mask;
|
|
|
|
ring->count_dw -= count_dw;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-09 04:30:37 +08:00
|
|
|
static inline struct amdgpu_sdma_instance *
|
|
|
|
amdgpu_get_sdma_instance(struct amdgpu_ring *ring)
|
2015-09-01 12:56:17 +08:00
|
|
|
{
|
|
|
|
struct amdgpu_device *adev = ring->adev;
|
|
|
|
int i;
|
|
|
|
|
2015-10-09 04:30:37 +08:00
|
|
|
for (i = 0; i < adev->sdma.num_instances; i++)
|
|
|
|
if (&adev->sdma.instance[i].ring == ring)
|
2015-09-01 12:56:17 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
if (i < AMDGPU_MAX_SDMA_INSTANCES)
|
2015-10-09 04:30:37 +08:00
|
|
|
return &adev->sdma.instance[i];
|
2015-09-01 12:56:17 +08:00
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
/*
|
|
|
|
* ASICs macro.
|
|
|
|
*/
|
|
|
|
#define amdgpu_asic_set_vga_state(adev, state) (adev)->asic_funcs->set_vga_state((adev), (state))
|
|
|
|
#define amdgpu_asic_reset(adev) (adev)->asic_funcs->reset((adev))
|
|
|
|
#define amdgpu_asic_get_xclk(adev) (adev)->asic_funcs->get_xclk((adev))
|
|
|
|
#define amdgpu_asic_set_uvd_clocks(adev, v, d) (adev)->asic_funcs->set_uvd_clocks((adev), (v), (d))
|
|
|
|
#define amdgpu_asic_set_vce_clocks(adev, ev, ec) (adev)->asic_funcs->set_vce_clocks((adev), (ev), (ec))
|
2016-08-02 00:42:32 +08:00
|
|
|
#define amdgpu_get_pcie_lanes(adev) (adev)->asic_funcs->get_pcie_lanes((adev))
|
|
|
|
#define amdgpu_set_pcie_lanes(adev, l) (adev)->asic_funcs->set_pcie_lanes((adev), (l))
|
|
|
|
#define amdgpu_asic_get_gpu_clock_counter(adev) (adev)->asic_funcs->get_gpu_clock_counter((adev))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define amdgpu_asic_read_disabled_bios(adev) (adev)->asic_funcs->read_disabled_bios((adev))
|
2015-11-24 23:14:28 +08:00
|
|
|
#define amdgpu_asic_read_bios_from_rom(adev, b, l) (adev)->asic_funcs->read_bios_from_rom((adev), (b), (l))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define amdgpu_asic_read_register(adev, se, sh, offset, v)((adev)->asic_funcs->read_register((adev), (se), (sh), (offset), (v)))
|
2017-03-04 06:26:10 +08:00
|
|
|
#define amdgpu_asic_get_config_memsize(adev) (adev)->asic_funcs->get_config_memsize((adev))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define amdgpu_gart_flush_gpu_tlb(adev, vmid) (adev)->gart.gart_funcs->flush_gpu_tlb((adev), (vmid))
|
|
|
|
#define amdgpu_gart_set_pte_pde(adev, pt, idx, addr, flags) (adev)->gart.gart_funcs->set_pte_pde((adev), (pt), (idx), (addr), (flags))
|
|
|
|
#define amdgpu_vm_copy_pte(adev, ib, pe, src, count) ((adev)->vm_manager.vm_pte_funcs->copy_pte((ib), (pe), (src), (count)))
|
2016-08-12 17:33:30 +08:00
|
|
|
#define amdgpu_vm_write_pte(adev, ib, pe, value, count, incr) ((adev)->vm_manager.vm_pte_funcs->write_pte((ib), (pe), (value), (count), (incr)))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define amdgpu_vm_set_pte_pde(adev, ib, pe, addr, count, incr, flags) ((adev)->vm_manager.vm_pte_funcs->set_pte_pde((ib), (pe), (addr), (count), (incr), (flags)))
|
2017-02-15 01:22:57 +08:00
|
|
|
#define amdgpu_vm_get_pte_flags(adev, flags) (adev)->gart.gart_funcs->get_vm_pte_flags((adev),(flags))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define amdgpu_ring_parse_cs(r, p, ib) ((r)->funcs->parse_cs((p), (ib)))
|
|
|
|
#define amdgpu_ring_test_ring(r) (r)->funcs->test_ring((r))
|
2016-07-06 03:07:17 +08:00
|
|
|
#define amdgpu_ring_test_ib(r, t) (r)->funcs->test_ib((r), (t))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define amdgpu_ring_get_rptr(r) (r)->funcs->get_rptr((r))
|
|
|
|
#define amdgpu_ring_get_wptr(r) (r)->funcs->get_wptr((r))
|
|
|
|
#define amdgpu_ring_set_wptr(r) (r)->funcs->set_wptr((r))
|
2016-05-06 23:50:03 +08:00
|
|
|
#define amdgpu_ring_emit_ib(r, ib, vm_id, c) (r)->funcs->emit_ib((r), (ib), (vm_id), (c))
|
2016-03-01 22:42:52 +08:00
|
|
|
#define amdgpu_ring_emit_pipeline_sync(r) (r)->funcs->emit_pipeline_sync((r))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define amdgpu_ring_emit_vm_flush(r, vmid, addr) (r)->funcs->emit_vm_flush((r), (vmid), (addr))
|
2015-06-01 14:35:03 +08:00
|
|
|
#define amdgpu_ring_emit_fence(r, addr, seq, flags) (r)->funcs->emit_fence((r), (addr), (seq), (flags))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define amdgpu_ring_emit_gds_switch(r, v, db, ds, wb, ws, ab, as) (r)->funcs->emit_gds_switch((r), (v), (db), (ds), (wb), (ws), (ab), (as))
|
2015-05-11 20:10:34 +08:00
|
|
|
#define amdgpu_ring_emit_hdp_flush(r) (r)->funcs->emit_hdp_flush((r))
|
2016-03-03 11:38:48 +08:00
|
|
|
#define amdgpu_ring_emit_hdp_invalidate(r) (r)->funcs->emit_hdp_invalidate((r))
|
2016-08-26 14:12:37 +08:00
|
|
|
#define amdgpu_ring_emit_switch_buffer(r) (r)->funcs->emit_switch_buffer((r))
|
2016-08-26 13:28:28 +08:00
|
|
|
#define amdgpu_ring_emit_cntxcntl(r, d) (r)->funcs->emit_cntxcntl((r), (d))
|
2017-01-10 12:53:52 +08:00
|
|
|
#define amdgpu_ring_emit_rreg(r, d) (r)->funcs->emit_rreg((r), (d))
|
|
|
|
#define amdgpu_ring_emit_wreg(r, d, v) (r)->funcs->emit_wreg((r), (d), (v))
|
2016-01-31 19:20:55 +08:00
|
|
|
#define amdgpu_ring_pad_ib(r, ib) ((r)->funcs->pad_ib((r), (ib)))
|
2016-01-14 19:07:38 +08:00
|
|
|
#define amdgpu_ring_init_cond_exec(r) (r)->funcs->init_cond_exec((r))
|
|
|
|
#define amdgpu_ring_patch_cond_exec(r,o) (r)->funcs->patch_cond_exec((r),(o))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define amdgpu_ih_get_wptr(adev) (adev)->irq.ih_funcs->get_wptr((adev))
|
|
|
|
#define amdgpu_ih_decode_iv(adev, iv) (adev)->irq.ih_funcs->decode_iv((adev), (iv))
|
|
|
|
#define amdgpu_ih_set_rptr(adev) (adev)->irq.ih_funcs->set_rptr((adev))
|
|
|
|
#define amdgpu_display_set_vga_render_state(adev, r) (adev)->mode_info.funcs->set_vga_render_state((adev), (r))
|
|
|
|
#define amdgpu_display_vblank_get_counter(adev, crtc) (adev)->mode_info.funcs->vblank_get_counter((adev), (crtc))
|
|
|
|
#define amdgpu_display_vblank_wait(adev, crtc) (adev)->mode_info.funcs->vblank_wait((adev), (crtc))
|
|
|
|
#define amdgpu_display_backlight_set_level(adev, e, l) (adev)->mode_info.funcs->backlight_set_level((e), (l))
|
|
|
|
#define amdgpu_display_backlight_get_level(adev, e) (adev)->mode_info.funcs->backlight_get_level((e))
|
|
|
|
#define amdgpu_display_hpd_sense(adev, h) (adev)->mode_info.funcs->hpd_sense((adev), (h))
|
|
|
|
#define amdgpu_display_hpd_set_polarity(adev, h) (adev)->mode_info.funcs->hpd_set_polarity((adev), (h))
|
|
|
|
#define amdgpu_display_hpd_get_gpio_reg(adev) (adev)->mode_info.funcs->hpd_get_gpio_reg((adev))
|
|
|
|
#define amdgpu_display_bandwidth_update(adev) (adev)->mode_info.funcs->bandwidth_update((adev))
|
2016-05-06 04:03:57 +08:00
|
|
|
#define amdgpu_display_page_flip(adev, crtc, base, async) (adev)->mode_info.funcs->page_flip((adev), (crtc), (base), (async))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define amdgpu_display_page_flip_get_scanoutpos(adev, crtc, vbl, pos) (adev)->mode_info.funcs->page_flip_get_scanoutpos((adev), (crtc), (vbl), (pos))
|
|
|
|
#define amdgpu_display_add_encoder(adev, e, s, c) (adev)->mode_info.funcs->add_encoder((adev), (e), (s), (c))
|
|
|
|
#define amdgpu_display_add_connector(adev, ci, sd, ct, ib, coi, h, r) (adev)->mode_info.funcs->add_connector((adev), (ci), (sd), (ct), (ib), (coi), (h), (r))
|
|
|
|
#define amdgpu_display_stop_mc_access(adev, s) (adev)->mode_info.funcs->stop_mc_access((adev), (s))
|
|
|
|
#define amdgpu_display_resume_mc_access(adev, s) (adev)->mode_info.funcs->resume_mc_access((adev), (s))
|
2015-08-25 17:23:45 +08:00
|
|
|
#define amdgpu_emit_copy_buffer(adev, ib, s, d, b) (adev)->mman.buffer_funcs->emit_copy_buffer((ib), (s), (d), (b))
|
2015-08-27 13:46:09 +08:00
|
|
|
#define amdgpu_emit_fill_buffer(adev, ib, s, d, b) (adev)->mman.buffer_funcs->emit_fill_buffer((ib), (s), (d), (b))
|
2016-07-08 03:01:42 +08:00
|
|
|
#define amdgpu_gfx_get_gpu_clock_counter(adev) (adev)->gfx.funcs->get_gpu_clock_counter((adev))
|
2016-06-28 22:26:48 +08:00
|
|
|
#define amdgpu_gfx_select_se_sh(adev, se, sh, instance) (adev)->gfx.funcs->select_se_sh((adev), (se), (sh), (instance))
|
2015-04-21 04:51:00 +08:00
|
|
|
#define amdgpu_gds_switch(adev, r, v, d, w, a) (adev)->gds.funcs->patch_gds_switch((r), (v), (d), (w), (a))
|
2017-03-04 07:37:23 +08:00
|
|
|
#define amdgpu_psp_check_fw_loading_status(adev, i) (adev)->firmware.funcs->check_fw_loading_status((adev), (i))
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
/* Common functions */
|
|
|
|
int amdgpu_gpu_reset(struct amdgpu_device *adev);
|
2016-08-05 17:30:17 +08:00
|
|
|
bool amdgpu_need_backup(struct amdgpu_device *adev);
|
2015-04-21 04:51:00 +08:00
|
|
|
void amdgpu_pci_config_reset(struct amdgpu_device *adev);
|
2017-02-10 15:59:59 +08:00
|
|
|
bool amdgpu_need_post(struct amdgpu_device *adev);
|
2015-04-21 04:51:00 +08:00
|
|
|
void amdgpu_update_display_priority(struct amdgpu_device *adev);
|
2015-07-21 16:52:10 +08:00
|
|
|
|
2015-04-21 04:51:00 +08:00
|
|
|
int amdgpu_cs_parser_init(struct amdgpu_cs_parser *p, void *data);
|
|
|
|
int amdgpu_cs_get_ring(struct amdgpu_device *adev, u32 ip_type,
|
|
|
|
u32 ip_instance, u32 ring,
|
|
|
|
struct amdgpu_ring **out_ring);
|
2017-02-09 18:33:37 +08:00
|
|
|
void amdgpu_cs_report_moved_bytes(struct amdgpu_device *adev, u64 num_bytes);
|
2016-09-15 21:06:50 +08:00
|
|
|
void amdgpu_ttm_placement_from_domain(struct amdgpu_bo *abo, u32 domain);
|
2015-04-21 04:51:00 +08:00
|
|
|
bool amdgpu_ttm_bo_is_amdgpu_bo(struct ttm_buffer_object *bo);
|
2016-02-23 19:36:59 +08:00
|
|
|
int amdgpu_ttm_tt_get_user_pages(struct ttm_tt *ttm, struct page **pages);
|
2015-04-21 04:51:00 +08:00
|
|
|
int amdgpu_ttm_tt_set_userptr(struct ttm_tt *ttm, uint64_t addr,
|
|
|
|
uint32_t flags);
|
|
|
|
bool amdgpu_ttm_tt_has_userptr(struct ttm_tt *ttm);
|
2016-02-08 18:08:35 +08:00
|
|
|
struct mm_struct *amdgpu_ttm_tt_get_usermm(struct ttm_tt *ttm);
|
2016-02-08 17:57:22 +08:00
|
|
|
bool amdgpu_ttm_tt_affect_userptr(struct ttm_tt *ttm, unsigned long start,
|
|
|
|
unsigned long end);
|
2016-02-23 19:36:59 +08:00
|
|
|
bool amdgpu_ttm_tt_userptr_invalidated(struct ttm_tt *ttm,
|
|
|
|
int *last_invalidated);
|
2015-04-21 04:51:00 +08:00
|
|
|
bool amdgpu_ttm_tt_is_readonly(struct ttm_tt *ttm);
|
2016-09-21 16:19:19 +08:00
|
|
|
uint64_t amdgpu_ttm_tt_pte_flags(struct amdgpu_device *adev, struct ttm_tt *ttm,
|
2015-04-21 04:51:00 +08:00
|
|
|
struct ttm_mem_reg *mem);
|
|
|
|
void amdgpu_vram_location(struct amdgpu_device *adev, struct amdgpu_mc *mc, u64 base);
|
|
|
|
void amdgpu_gtt_location(struct amdgpu_device *adev, struct amdgpu_mc *mc);
|
|
|
|
void amdgpu_ttm_set_active_vram_size(struct amdgpu_device *adev, u64 size);
|
2016-09-15 21:43:26 +08:00
|
|
|
int amdgpu_ttm_init(struct amdgpu_device *adev);
|
|
|
|
void amdgpu_ttm_fini(struct amdgpu_device *adev);
|
2015-04-21 04:51:00 +08:00
|
|
|
void amdgpu_program_register_sequence(struct amdgpu_device *adev,
|
|
|
|
const u32 *registers,
|
|
|
|
const u32 array_size);
|
|
|
|
|
|
|
|
bool amdgpu_device_is_px(struct drm_device *dev);
|
|
|
|
/* atpx handler */
|
|
|
|
#if defined(CONFIG_VGA_SWITCHEROO)
|
|
|
|
void amdgpu_register_atpx_handler(void);
|
|
|
|
void amdgpu_unregister_atpx_handler(void);
|
2016-06-02 01:08:21 +08:00
|
|
|
bool amdgpu_has_atpx_dgpu_power_cntl(void);
|
2016-06-02 21:04:01 +08:00
|
|
|
bool amdgpu_is_atpx_hybrid(void);
|
2016-09-15 02:01:41 +08:00
|
|
|
bool amdgpu_atpx_dgpu_req_power_for_displays(void);
|
2017-04-05 23:07:13 +08:00
|
|
|
bool amdgpu_has_atpx(void);
|
2015-04-21 04:51:00 +08:00
|
|
|
#else
|
|
|
|
static inline void amdgpu_register_atpx_handler(void) {}
|
|
|
|
static inline void amdgpu_unregister_atpx_handler(void) {}
|
2016-06-02 01:08:21 +08:00
|
|
|
static inline bool amdgpu_has_atpx_dgpu_power_cntl(void) { return false; }
|
2016-06-02 21:04:01 +08:00
|
|
|
static inline bool amdgpu_is_atpx_hybrid(void) { return false; }
|
2016-09-15 02:01:41 +08:00
|
|
|
static inline bool amdgpu_atpx_dgpu_req_power_for_displays(void) { return false; }
|
2017-04-05 23:07:13 +08:00
|
|
|
static inline bool amdgpu_has_atpx(void) { return false; }
|
2015-04-21 04:51:00 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* KMS
|
|
|
|
*/
|
|
|
|
extern const struct drm_ioctl_desc amdgpu_ioctls_kms[];
|
2016-04-10 22:29:59 +08:00
|
|
|
extern const int amdgpu_max_kms_ioctl;
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
int amdgpu_driver_load_kms(struct drm_device *dev, unsigned long flags);
|
2017-01-07 01:57:31 +08:00
|
|
|
void amdgpu_driver_unload_kms(struct drm_device *dev);
|
2015-04-21 04:51:00 +08:00
|
|
|
void amdgpu_driver_lastclose_kms(struct drm_device *dev);
|
|
|
|
int amdgpu_driver_open_kms(struct drm_device *dev, struct drm_file *file_priv);
|
|
|
|
void amdgpu_driver_postclose_kms(struct drm_device *dev,
|
|
|
|
struct drm_file *file_priv);
|
2016-12-06 23:38:29 +08:00
|
|
|
int amdgpu_suspend(struct amdgpu_device *adev);
|
2016-08-24 01:25:49 +08:00
|
|
|
int amdgpu_device_suspend(struct drm_device *dev, bool suspend, bool fbcon);
|
|
|
|
int amdgpu_device_resume(struct drm_device *dev, bool resume, bool fbcon);
|
2015-09-25 00:35:31 +08:00
|
|
|
u32 amdgpu_get_vblank_counter_kms(struct drm_device *dev, unsigned int pipe);
|
|
|
|
int amdgpu_enable_vblank_kms(struct drm_device *dev, unsigned int pipe);
|
|
|
|
void amdgpu_disable_vblank_kms(struct drm_device *dev, unsigned int pipe);
|
|
|
|
int amdgpu_get_vblank_timestamp_kms(struct drm_device *dev, unsigned int pipe,
|
2015-04-21 04:51:00 +08:00
|
|
|
int *max_error,
|
|
|
|
struct timeval *vblank_time,
|
|
|
|
unsigned flags);
|
|
|
|
long amdgpu_kms_compat_ioctl(struct file *filp, unsigned int cmd,
|
|
|
|
unsigned long arg);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* functions used by amdgpu_encoder.c
|
|
|
|
*/
|
|
|
|
struct amdgpu_afmt_acr {
|
|
|
|
u32 clock;
|
|
|
|
|
|
|
|
int n_32khz;
|
|
|
|
int cts_32khz;
|
|
|
|
|
|
|
|
int n_44_1khz;
|
|
|
|
int cts_44_1khz;
|
|
|
|
|
|
|
|
int n_48khz;
|
|
|
|
int cts_48khz;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
struct amdgpu_afmt_acr amdgpu_afmt_acr(uint32_t clock);
|
|
|
|
|
|
|
|
/* amdgpu_acpi.c */
|
|
|
|
#if defined(CONFIG_ACPI)
|
|
|
|
int amdgpu_acpi_init(struct amdgpu_device *adev);
|
|
|
|
void amdgpu_acpi_fini(struct amdgpu_device *adev);
|
|
|
|
bool amdgpu_acpi_is_pcie_performance_request_supported(struct amdgpu_device *adev);
|
|
|
|
int amdgpu_acpi_pcie_performance_request(struct amdgpu_device *adev,
|
|
|
|
u8 perf_req, bool advertise);
|
|
|
|
int amdgpu_acpi_pcie_notify_device_ready(struct amdgpu_device *adev);
|
|
|
|
#else
|
|
|
|
static inline int amdgpu_acpi_init(struct amdgpu_device *adev) { return 0; }
|
|
|
|
static inline void amdgpu_acpi_fini(struct amdgpu_device *adev) { }
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct amdgpu_bo_va_mapping *
|
|
|
|
amdgpu_cs_find_mapping(struct amdgpu_cs_parser *parser,
|
|
|
|
uint64_t addr, struct amdgpu_bo **bo);
|
2016-09-05 23:00:57 +08:00
|
|
|
int amdgpu_cs_sysvm_access_required(struct amdgpu_cs_parser *parser);
|
2015-04-21 04:51:00 +08:00
|
|
|
|
|
|
|
#include "amdgpu_object.h"
|
|
|
|
#endif
|