Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/C/Linux/drivers/gpu/drm/radeon/   (Browser von der Mozilla Stiftung Version 136.0.1©)  Datei vom 24.10.2025 mit Größe 94 kB image not shown  

Quelle  radeon.h   Sprache: C

 
/*
 * 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 __RADEON_H__
#define __RADEON_H__

/* TODO: Here are things that needs to be done :
 * - surface allocator & initializer : (bit like scratch reg) should
 *   initialize HDP_ stuff on RS600, R600, R700 hw, well anythings
 *   related to surface
 * - WB : write back stuff (do it bit like scratch reg things)
 * - Vblank : look at Jesse's rework and what we should do
 * - r600/r700: gart & cp
 * - cs : clean cs ioctl use bitmap & things like that.
 * - power management stuff
 * - Barrier in gart code
 * - Unmappabled vram ?
 * - TESTING, TESTING, TESTING
 */


/* Initialization path:
 *  We expect that acceleration initialization might fail for various
 *  reasons even thought we work hard to make it works on most
 *  configurations. In order to still have a working userspace in such
 *  situation the init path must succeed up to the memory controller
 *  initialization point. Failure before this point are considered as
 *  fatal error. Here is the init callchain :
 *      radeon_device_init  perform common structure, mutex initialization
 *      asic_init           setup the GPU memory layout and perform all
 *                          one time initialization (failure in this
 *                          function are considered fatal)
 *      asic_startup        setup the GPU acceleration, in order to
 *                          follow guideline the first thing this
 *                          function should do is setting the GPU
 *                          memory controller (only MC setup failure
 *                          are considered as fatal)
 */


#include <linux/agp_backend.h>
#include <linux/atomic.h>
#include <linux/wait.h>
#include <linux/list.h>
#include <linux/kref.h>
#include <linux/interval_tree.h>
#include <linux/hashtable.h>
#include <linux/dma-fence.h>

#ifdef CONFIG_MMU_NOTIFIER
#include <linux/mmu_notifier.h>
#endif

#include <drm/ttm/ttm_bo.h>
#include <drm/ttm/ttm_placement.h>

#include <drm/drm_exec.h>
#include <drm/drm_gem.h>
#include <drm/drm_audio_component.h>
#include <drm/drm_suballoc.h>

#include "radeon_family.h"
#include "radeon_mode.h"
#include "radeon_reg.h"

/*
 * Modules parameters.
 */

extern int radeon_no_wb;
extern int radeon_modeset;
extern int radeon_dynclks;
extern int radeon_r4xx_atom;
extern int radeon_agpmode;
extern int radeon_vram_limit;
extern int radeon_gart_size;
extern int radeon_benchmarking;
extern int radeon_testing;
extern int radeon_connector_table;
extern int radeon_tv;
extern int radeon_audio;
extern int radeon_disp_priority;
extern int radeon_hw_i2c;
extern int radeon_pcie_gen2;
extern int radeon_msi;
extern int radeon_lockup_timeout;
extern int radeon_fastfb;
extern int radeon_dpm;
extern int radeon_aspm;
extern int radeon_runtime_pm;
extern int radeon_hard_reset;
extern int radeon_vm_size;
extern int radeon_vm_block_size;
extern int radeon_deep_color;
extern int radeon_use_pflipirq;
extern int radeon_bapm;
extern int radeon_backlight;
extern int radeon_auxch;
extern int radeon_uvd;
extern int radeon_vce;
extern int radeon_si_support;
extern int radeon_cik_support;

/*
 * Copy from radeon_drv.h so we don't have to include both and have conflicting
 * symbol;
 */

#define RADEON_MAX_USEC_TIMEOUT   100000 /* 100 ms */
#define RADEON_FENCE_JIFFIES_TIMEOUT  (HZ / 2)
#define RADEON_USEC_IB_TEST_TIMEOUT  1000000 /* 1s */
/* RADEON_IB_POOL_SIZE must be a power of 2 */
#define RADEON_IB_POOL_SIZE   16
#define RADEON_DEBUGFS_MAX_COMPONENTS  32
#define RADEON_BIOS_NUM_SCRATCH   8

/* internal ring indices */
/* r1xx+ has gfx CP ring */
#define RADEON_RING_TYPE_GFX_INDEX  0

/* cayman has 2 compute CP rings */
#define CAYMAN_RING_TYPE_CP1_INDEX  1
#define CAYMAN_RING_TYPE_CP2_INDEX  2

/* R600+ has an async dma ring */
#define R600_RING_TYPE_DMA_INDEX  3
/* cayman add a second async dma ring */
#define CAYMAN_RING_TYPE_DMA1_INDEX  4

/* R600+ */
#define R600_RING_TYPE_UVD_INDEX  5

/* TN+ */
#define TN_RING_TYPE_VCE1_INDEX   6
#define TN_RING_TYPE_VCE2_INDEX   7

/* max number of rings */
#define RADEON_NUM_RINGS   8

/* number of hw syncs before falling back on blocking */
#define RADEON_NUM_SYNCS   4

/* hardcode those limit for now */
#define RADEON_VA_IB_OFFSET   (1 << 20)
#define RADEON_VA_RESERVED_SIZE   (8 << 20)
#define RADEON_IB_VM_MAX_SIZE   (64 << 10)

/* hard reset data */
#define RADEON_ASIC_RESET_DATA                  0x39d5e86b

/* reset flags */
#define RADEON_RESET_GFX   (1 << 0)
#define RADEON_RESET_COMPUTE   (1 << 1)
#define RADEON_RESET_DMA   (1 << 2)
#define RADEON_RESET_CP    (1 << 3)
#define RADEON_RESET_GRBM   (1 << 4)
#define RADEON_RESET_DMA1   (1 << 5)
#define RADEON_RESET_RLC   (1 << 6)
#define RADEON_RESET_SEM   (1 << 7)
#define RADEON_RESET_IH    (1 << 8)
#define RADEON_RESET_VMC   (1 << 9)
#define RADEON_RESET_MC    (1 << 10)
#define RADEON_RESET_DISPLAY   (1 << 11)

/* CG block flags */
#define RADEON_CG_BLOCK_GFX   (1 << 0)
#define RADEON_CG_BLOCK_MC   (1 << 1)
#define RADEON_CG_BLOCK_SDMA   (1 << 2)
#define RADEON_CG_BLOCK_UVD   (1 << 3)
#define RADEON_CG_BLOCK_VCE   (1 << 4)
#define RADEON_CG_BLOCK_HDP   (1 << 5)
#define RADEON_CG_BLOCK_BIF   (1 << 6)

/* CG flags */
#define RADEON_CG_SUPPORT_GFX_MGCG  (1 << 0)
#define RADEON_CG_SUPPORT_GFX_MGLS  (1 << 1)
#define RADEON_CG_SUPPORT_GFX_CGCG  (1 << 2)
#define RADEON_CG_SUPPORT_GFX_CGLS  (1 << 3)
#define RADEON_CG_SUPPORT_GFX_CGTS  (1 << 4)
#define RADEON_CG_SUPPORT_GFX_CGTS_LS  (1 << 5)
#define RADEON_CG_SUPPORT_GFX_CP_LS  (1 << 6)
#define RADEON_CG_SUPPORT_GFX_RLC_LS  (1 << 7)
#define RADEON_CG_SUPPORT_MC_LS   (1 << 8)
#define RADEON_CG_SUPPORT_MC_MGCG  (1 << 9)
#define RADEON_CG_SUPPORT_SDMA_LS  (1 << 10)
#define RADEON_CG_SUPPORT_SDMA_MGCG  (1 << 11)
#define RADEON_CG_SUPPORT_BIF_LS  (1 << 12)
#define RADEON_CG_SUPPORT_UVD_MGCG  (1 << 13)
#define RADEON_CG_SUPPORT_VCE_MGCG  (1 << 14)
#define RADEON_CG_SUPPORT_HDP_LS  (1 << 15)
#define RADEON_CG_SUPPORT_HDP_MGCG  (1 << 16)

/* PG flags */
#define RADEON_PG_SUPPORT_GFX_PG  (1 << 0)
#define RADEON_PG_SUPPORT_GFX_SMG  (1 << 1)
#define RADEON_PG_SUPPORT_GFX_DMG  (1 << 2)
#define RADEON_PG_SUPPORT_UVD   (1 << 3)
#define RADEON_PG_SUPPORT_VCE   (1 << 4)
#define RADEON_PG_SUPPORT_CP   (1 << 5)
#define RADEON_PG_SUPPORT_GDS   (1 << 6)
#define RADEON_PG_SUPPORT_RLC_SMU_HS  (1 << 7)
#define RADEON_PG_SUPPORT_SDMA   (1 << 8)
#define RADEON_PG_SUPPORT_ACP   (1 << 9)
#define RADEON_PG_SUPPORT_SAMU   (1 << 10)

/* max cursor sizes (in pixels) */
#define CURSOR_WIDTH 64
#define CURSOR_HEIGHT 64

#define CIK_CURSOR_WIDTH 128
#define CIK_CURSOR_HEIGHT 128

/*
 * Errata workarounds.
 */

enum radeon_pll_errata {
 CHIP_ERRATA_R300_CG             = 0x00000001,
 CHIP_ERRATA_PLL_DUMMYREADS      = 0x00000002,
 CHIP_ERRATA_PLL_DELAY           = 0x00000004
};


struct radeon_device;


/*
 * BIOS.
 */

bool radeon_get_bios(struct radeon_device *rdev);

/*
 * Dummy page
 */

struct radeon_dummy_page {
 uint64_t entry;
 struct page *page;
 dma_addr_t addr;
};
int radeon_dummy_page_init(struct radeon_device *rdev);
void radeon_dummy_page_fini(struct radeon_device *rdev);


/*
 * Clocks
 */

struct radeon_clock {
 struct radeon_pll p1pll;
 struct radeon_pll p2pll;
 struct radeon_pll dcpll;
 struct radeon_pll spll;
 struct radeon_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;
 uint32_t vco_freq;
};

/*
 * Power management
 */

int radeon_pm_init(struct radeon_device *rdev);
int radeon_pm_late_init(struct radeon_device *rdev);
void radeon_pm_fini(struct radeon_device *rdev);
void radeon_pm_compute_clocks(struct radeon_device *rdev);
void radeon_pm_suspend(struct radeon_device *rdev);
void radeon_pm_resume(struct radeon_device *rdev);
void radeon_combios_get_power_modes(struct radeon_device *rdev);
void radeon_atombios_get_power_modes(struct radeon_device *rdev);
int radeon_atom_get_clock_dividers(struct radeon_device *rdev,
       u8 clock_type,
       u32 clock,
       bool strobe_mode,
       struct atom_clock_dividers *dividers);
int radeon_atom_get_memory_pll_dividers(struct radeon_device *rdev,
     u32 clock,
     bool strobe_mode,
     struct atom_mpll_param *mpll_param);
void radeon_atom_set_voltage(struct radeon_device *rdev, u16 voltage_level, u8 voltage_type);
int radeon_atom_get_voltage_gpio_settings(struct radeon_device *rdev,
       u16 voltage_level, u8 voltage_type,
       u32 *gpio_value, u32 *gpio_mask);
void radeon_atom_set_engine_dram_timings(struct radeon_device *rdev,
      u32 eng_clock, u32 mem_clock);
int radeon_atom_get_voltage_step(struct radeon_device *rdev,
     u8 voltage_type, u16 *voltage_step);
int radeon_atom_get_max_vddc(struct radeon_device *rdev, u8 voltage_type,
        u16 voltage_id, u16 *voltage);
int radeon_atom_get_leakage_vddc_based_on_leakage_idx(struct radeon_device *rdev,
            u16 *voltage,
            u16 leakage_idx);
int radeon_atom_get_leakage_id_from_vbios(struct radeon_device *rdev,
       u16 *leakage_id);
int radeon_atom_get_leakage_vddc_based_on_leakage_params(struct radeon_device *rdev,
        u16 *vddc, u16 *vddci,
        u16 virtual_voltage_id,
        u16 vbios_voltage_id);
int radeon_atom_get_voltage_evv(struct radeon_device *rdev,
    u16 virtual_voltage_id,
    u16 *voltage);
int radeon_atom_round_to_true_voltage(struct radeon_device *rdev,
          u8 voltage_type,
          u16 nominal_voltage,
          u16 *true_voltage);
int radeon_atom_get_min_voltage(struct radeon_device *rdev,
    u8 voltage_type, u16 *min_voltage);
int radeon_atom_get_max_voltage(struct radeon_device *rdev,
    u8 voltage_type, u16 *max_voltage);
int radeon_atom_get_voltage_table(struct radeon_device *rdev,
      u8 voltage_type, u8 voltage_mode,
      struct atom_voltage_table *voltage_table);
bool radeon_atom_is_voltage_gpio(struct radeon_device *rdev,
     u8 voltage_type, u8 voltage_mode);
int radeon_atom_get_svi2_info(struct radeon_device *rdev,
         u8 voltage_type,
         u8 *svd_gpio_id, u8 *svc_gpio_id);
void radeon_atom_update_memory_dll(struct radeon_device *rdev,
       u32 mem_clock);
void radeon_atom_set_ac_timing(struct radeon_device *rdev,
          u32 mem_clock);
int radeon_atom_init_mc_reg_table(struct radeon_device *rdev,
      u8 module_index,
      struct atom_mc_reg_table *reg_table);
int radeon_atom_get_memory_info(struct radeon_device *rdev,
    u8 module_index, struct atom_memory_info *mem_info);
int radeon_atom_get_mclk_range_table(struct radeon_device *rdev,
         bool gddr5, u8 module_index,
         struct atom_memory_clock_range_table *mclk_range_table);
int radeon_atom_get_max_vddc(struct radeon_device *rdev, u8 voltage_type,
        u16 voltage_id, u16 *voltage);
void rs690_pm_info(struct radeon_device *rdev);
extern void evergreen_tiling_fields(unsigned tiling_flags, unsigned *bankw,
        unsigned *bankh, unsigned *mtaspect,
        unsigned *tile_split);

/*
 * Fences.
 */

struct radeon_fence_driver {
 struct radeon_device  *rdev;
 uint32_t   scratch_reg;
 uint64_t   gpu_addr;
 volatile uint32_t  *cpu_addr;
 /* sync_seq is protected by ring emission lock */
 uint64_t   sync_seq[RADEON_NUM_RINGS];
 atomic64_t   last_seq;
 bool    initialized, delayed_irq;
 struct delayed_work  lockup_work;
};

struct radeon_fence {
 struct dma_fence  base;

 struct radeon_device *rdev;
 uint64_t  seq;
 /* RB, DMA, etc. */
 unsigned  ring;
 bool   is_vm_update;

 wait_queue_entry_t  fence_wake;
};

int radeon_fence_driver_start_ring(struct radeon_device *rdev, int ring);
void radeon_fence_driver_init(struct radeon_device *rdev);
void radeon_fence_driver_fini(struct radeon_device *rdev);
void radeon_fence_driver_force_completion(struct radeon_device *rdev, int ring);
int radeon_fence_emit(struct radeon_device *rdev, struct radeon_fence **fence, int ring);
void radeon_fence_process(struct radeon_device *rdev, int ring);
bool radeon_fence_signaled(struct radeon_fence *fence);
long radeon_fence_wait_timeout(struct radeon_fence *fence, bool interruptible, long timeout);
int radeon_fence_wait(struct radeon_fence *fence, bool interruptible);
int radeon_fence_wait_next(struct radeon_device *rdev, int ring);
int radeon_fence_wait_empty(struct radeon_device *rdev, int ring);
struct radeon_fence *radeon_fence_ref(struct radeon_fence *fence);
void radeon_fence_unref(struct radeon_fence **fence);
unsigned radeon_fence_count_emitted(struct radeon_device *rdev, int ring);
bool radeon_fence_need_sync(struct radeon_fence *fence, int ring);
void radeon_fence_note_sync(struct radeon_fence *fence, int ring);
static inline struct radeon_fence *radeon_fence_later(struct radeon_fence *a,
            struct radeon_fence *b)
{
 if (!a) {
  return b;
 }

 if (!b) {
  return a;
 }

 BUG_ON(a->ring != b->ring);

 if (a->seq > b->seq) {
  return a;
 } else {
  return b;
 }
}

static inline bool radeon_fence_is_earlier(struct radeon_fence *a,
        struct radeon_fence *b)
{
 if (!a) {
  return false;
 }

 if (!b) {
  return true;
 }

 BUG_ON(a->ring != b->ring);

 return a->seq < b->seq;
}

/*
 * Tiling registers
 */

struct radeon_surface_reg {
 struct radeon_bo *bo;
};

#define RADEON_GEM_MAX_SURFACES 8

/*
 * TTM.
 */

struct radeon_mman {
 struct ttm_device  bdev;
 bool    initialized;
};

struct radeon_bo_list {
 struct radeon_bo  *robj;
 struct list_head  list;
 bool    shared;
 uint64_t   gpu_offset;
 unsigned   preferred_domains;
 unsigned   allowed_domains;
 uint32_t   tiling_flags;
};

/* bo virtual address in a specific vm */
struct radeon_bo_va {
 /* protected by bo being reserved */
 struct list_head  bo_list;
 uint32_t   flags;
 struct radeon_fence  *last_pt_update;
 unsigned   ref_count;

 /* protected by vm mutex */
 struct interval_tree_node it;
 struct list_head  vm_status;

 /* constant after initialization */
 struct radeon_vm  *vm;
 struct radeon_bo  *bo;
};

struct radeon_bo {
 /* Protected by gem.mutex */
 struct list_head  list;
 /* Protected by tbo.reserved */
 u32    initial_domain;
 struct ttm_place  placements[4];
 struct ttm_placement  placement;
 struct ttm_buffer_object tbo;
 struct ttm_bo_kmap_obj  kmap;
 u32    flags;
 void    *kptr;
 u32    tiling_flags;
 u32    pitch;
 int    surface_reg;
 unsigned   prime_shared_count;
 /* list of all virtual address to which this bo
 * is associated to
 */

 struct list_head  va;
 /* Constant after initialization */
 struct radeon_device  *rdev;

 pid_t    pid;

#ifdef CONFIG_MMU_NOTIFIER
 struct mmu_interval_notifier notifier;
#endif
};
#define gem_to_radeon_bo(gobj) container_of((gobj), struct radeon_bo, tbo.base)

struct radeon_sa_manager {
 struct drm_suballoc_manager base;
 struct radeon_bo  *bo;
 uint64_t   gpu_addr;
 void    *cpu_ptr;
 u32 domain;
};

/*
 * GEM objects.
 */

struct radeon_gem {
 struct mutex  mutex;
 struct list_head objects;
};

extern const struct drm_gem_object_funcs radeon_gem_object_funcs;

int radeon_align_pitch(struct radeon_device *rdev, int width, int cpp, bool tiled);

int radeon_gem_init(struct radeon_device *rdev);
void radeon_gem_fini(struct radeon_device *rdev);
int radeon_gem_object_create(struct radeon_device *rdev, unsigned long size,
    int alignment, int initial_domain,
    u32 flags, bool kernel,
    struct drm_gem_object **obj);

int radeon_mode_dumb_create(struct drm_file *file_priv,
       struct drm_device *dev,
       struct drm_mode_create_dumb *args);
int radeon_mode_dumb_mmap(struct drm_file *filp,
     struct drm_device *dev,
     uint32_t handle, uint64_t *offset_p);

/*
 * Semaphores.
 */

struct radeon_semaphore {
 struct drm_suballoc *sa_bo;
 signed   waiters;
 uint64_t  gpu_addr;
};

int radeon_semaphore_create(struct radeon_device *rdev,
       struct radeon_semaphore **semaphore);
bool radeon_semaphore_emit_signal(struct radeon_device *rdev, int ring,
      struct radeon_semaphore *semaphore);
bool radeon_semaphore_emit_wait(struct radeon_device *rdev, int ring,
    struct radeon_semaphore *semaphore);
void radeon_semaphore_free(struct radeon_device *rdev,
      struct radeon_semaphore **semaphore,
      struct radeon_fence *fence);

/*
 * Synchronization
 */

struct radeon_sync {
 struct radeon_semaphore *semaphores[RADEON_NUM_SYNCS];
 struct radeon_fence *sync_to[RADEON_NUM_RINGS];
 struct radeon_fence *last_vm_update;
};

void radeon_sync_create(struct radeon_sync *sync);
void radeon_sync_fence(struct radeon_sync *sync,
         struct radeon_fence *fence);
int radeon_sync_resv(struct radeon_device *rdev,
       struct radeon_sync *sync,
       struct dma_resv *resv,
       bool shared);
int radeon_sync_rings(struct radeon_device *rdev,
        struct radeon_sync *sync,
        int waiting_ring);
void radeon_sync_free(struct radeon_device *rdev, struct radeon_sync *sync,
        struct radeon_fence *fence);

/*
 * GART structures, functions & helpers
 */

struct radeon_mc;

#define RADEON_GPU_PAGE_SIZE 4096
#define RADEON_GPU_PAGE_MASK (RADEON_GPU_PAGE_SIZE - 1)
#define RADEON_GPU_PAGE_SHIFT 12
#define RADEON_GPU_PAGE_ALIGN(a) (((a) + RADEON_GPU_PAGE_MASK) & ~RADEON_GPU_PAGE_MASK)

#define RADEON_GART_PAGE_DUMMY  0
#define RADEON_GART_PAGE_VALID (1 << 0)
#define RADEON_GART_PAGE_READ (1 << 1)
#define RADEON_GART_PAGE_WRITE (1 << 2)
#define RADEON_GART_PAGE_SNOOP (1 << 3)

struct radeon_gart {
 dma_addr_t   table_addr;
 struct radeon_bo  *robj;
 void    *ptr;
 unsigned   num_gpu_pages;
 unsigned   num_cpu_pages;
 unsigned   table_size;
 struct page   **pages;
 uint64_t   *pages_entry;
 bool    ready;
};

int radeon_gart_table_ram_alloc(struct radeon_device *rdev);
void radeon_gart_table_ram_free(struct radeon_device *rdev);
int radeon_gart_table_vram_alloc(struct radeon_device *rdev);
void radeon_gart_table_vram_free(struct radeon_device *rdev);
int radeon_gart_table_vram_pin(struct radeon_device *rdev);
void radeon_gart_table_vram_unpin(struct radeon_device *rdev);
int radeon_gart_init(struct radeon_device *rdev);
void radeon_gart_fini(struct radeon_device *rdev);
void radeon_gart_unbind(struct radeon_device *rdev, unsigned offset,
   int pages);
int radeon_gart_bind(struct radeon_device *rdev, unsigned offset,
       int pages, struct page **pagelist,
       dma_addr_t *dma_addr, uint32_t flags);


/*
 * GPU MC structures, functions & helpers
 */

struct radeon_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;
 bool   vram_is_ddr;
 bool   igp_sideport_enabled;
 u64                     gtt_base_align;
 u64                     mc_mask;
};

bool radeon_combios_sideport_present(struct radeon_device *rdev);
bool radeon_atombios_sideport_present(struct radeon_device *rdev);

/*
 * GPU scratch registers structures, functions & helpers
 */

struct radeon_scratch {
 unsigned  num_reg;
 uint32_t                reg_base;
 bool   free[32];
 uint32_t  reg[32];
};

int radeon_scratch_get(struct radeon_device *rdev, uint32_t *reg);
void radeon_scratch_free(struct radeon_device *rdev, uint32_t reg);

/*
 * GPU doorbell structures, functions & helpers
 */

#define RADEON_MAX_DOORBELLS 1024 /* Reserve at most 1024 doorbell slots for radeon-owned rings. */

struct radeon_doorbell {
 /* doorbell mmio */
 resource_size_t  base;
 resource_size_t  size;
 u32 __iomem  *ptr;
 u32   num_doorbells; /* Number of doorbells actually reserved for radeon. */
 DECLARE_BITMAP(used, RADEON_MAX_DOORBELLS);
};

int radeon_doorbell_get(struct radeon_device *rdev, u32 *page);
void radeon_doorbell_free(struct radeon_device *rdev, u32 doorbell);

/*
 * IRQS.
 */


struct radeon_flip_work {
 struct work_struct  flip_work;
 struct work_struct  unpin_work;
 struct radeon_device  *rdev;
 int    crtc_id;
 u32    target_vblank;
 uint64_t   base;
 struct drm_pending_vblank_event *event;
 struct radeon_bo  *old_rbo;
 struct dma_fence  *fence;
 bool    async;
};

struct r500_irq_stat_regs {
 u32 disp_int;
 u32 hdmi0_status;
};

struct r600_irq_stat_regs {
 u32 disp_int;
 u32 disp_int_cont;
 u32 disp_int_cont2;
 u32 d1grph_int;
 u32 d2grph_int;
 u32 hdmi0_status;
 u32 hdmi1_status;
};

struct evergreen_irq_stat_regs {
 u32 disp_int[6];
 u32 grph_int[6];
 u32 afmt_status[6];
};

struct cik_irq_stat_regs {
 u32 disp_int;
 u32 disp_int_cont;
 u32 disp_int_cont2;
 u32 disp_int_cont3;
 u32 disp_int_cont4;
 u32 disp_int_cont5;
 u32 disp_int_cont6;
 u32 d1grph_int;
 u32 d2grph_int;
 u32 d3grph_int;
 u32 d4grph_int;
 u32 d5grph_int;
 u32 d6grph_int;
};

union radeon_irq_stat_regs {
 struct r500_irq_stat_regs r500;
 struct r600_irq_stat_regs r600;
 struct evergreen_irq_stat_regs evergreen;
 struct cik_irq_stat_regs cik;
};

struct radeon_irq {
 bool    installed;
 spinlock_t   lock;
 atomic_t   ring_int[RADEON_NUM_RINGS];
 bool    crtc_vblank_int[RADEON_MAX_CRTCS];
 atomic_t   pflip[RADEON_MAX_CRTCS];
 wait_queue_head_t  vblank_queue;
 bool    hpd[RADEON_MAX_HPD_PINS];
 bool    afmt[RADEON_MAX_AFMT_BLOCKS];
 union radeon_irq_stat_regs stat_regs;
 bool    dpm_thermal;
};

int radeon_irq_kms_init(struct radeon_device *rdev);
void radeon_irq_kms_fini(struct radeon_device *rdev);
void radeon_irq_kms_sw_irq_get(struct radeon_device *rdev, int ring);
bool radeon_irq_kms_sw_irq_get_delayed(struct radeon_device *rdev, int ring);
void radeon_irq_kms_sw_irq_put(struct radeon_device *rdev, int ring);
void radeon_irq_kms_pflip_irq_get(struct radeon_device *rdev, int crtc);
void radeon_irq_kms_pflip_irq_put(struct radeon_device *rdev, int crtc);
void radeon_irq_kms_enable_afmt(struct radeon_device *rdev, int block);
void radeon_irq_kms_disable_afmt(struct radeon_device *rdev, int block);
void radeon_irq_kms_enable_hpd(struct radeon_device *rdev, unsigned hpd_mask);
void radeon_irq_kms_disable_hpd(struct radeon_device *rdev, unsigned hpd_mask);

/*
 * CP & rings.
 */


struct radeon_ib {
 struct drm_suballoc  *sa_bo;
 uint32_t   length_dw;
 uint64_t   gpu_addr;
 uint32_t   *ptr;
 int    ring;
 struct radeon_fence  *fence;
 struct radeon_vm  *vm;
 bool    is_const_ib;
 struct radeon_sync  sync;
};

struct radeon_ring {
 struct radeon_device *rdev;
 struct radeon_bo *ring_obj;
 volatile uint32_t *ring;
 unsigned  rptr_offs;
 unsigned  rptr_save_reg;
 u64   next_rptr_gpu_addr;
 volatile u32  *next_rptr_cpu_addr;
 unsigned  wptr;
 unsigned  wptr_old;
 unsigned  ring_size;
 unsigned  ring_free_dw;
 int   count_dw;
 atomic_t  last_rptr;
 atomic64_t  last_activity;
 uint64_t  gpu_addr;
 uint32_t  align_mask;
 uint32_t  ptr_mask;
 bool   ready;
 u32   nop;
 u32   idx;
 u64   last_semaphore_signal_addr;
 u64   last_semaphore_wait_addr;
 /* for CIK queues */
 u32 me;
 u32 pipe;
 u32 queue;
 struct radeon_bo *mqd_obj;
 u32 doorbell_index;
 unsigned  wptr_offs;
};

struct radeon_mec {
 struct radeon_bo *hpd_eop_obj;
 u64   hpd_eop_gpu_addr;
 u32 num_pipe;
 u32 num_mec;
 u32 num_queue;
};

/*
 * VM
 */


/* maximum number of VMIDs */
#define RADEON_NUM_VM 16

/* number of entries in page table */
#define RADEON_VM_PTE_COUNT (1 << radeon_vm_block_size)

/* PTBs (Page Table Blocks) need to be aligned to 32K */
#define RADEON_VM_PTB_ALIGN_SIZE   32768
#define RADEON_VM_PTB_ALIGN_MASK (RADEON_VM_PTB_ALIGN_SIZE - 1)
#define RADEON_VM_PTB_ALIGN(a) (((a) + RADEON_VM_PTB_ALIGN_MASK) & ~RADEON_VM_PTB_ALIGN_MASK)

#define R600_PTE_VALID  (1 << 0)
#define R600_PTE_SYSTEM  (1 << 1)
#define R600_PTE_SNOOPED (1 << 2)
#define R600_PTE_READABLE (1 << 5)
#define R600_PTE_WRITEABLE (1 << 6)

/* PTE (Page Table Entry) fragment field for different page sizes */
#define R600_PTE_FRAG_4KB (0 << 7)
#define R600_PTE_FRAG_64KB (4 << 7)
#define R600_PTE_FRAG_256KB (6 << 7)

/* flags needed to be set so we can copy directly from the GART table */
#define R600_PTE_GART_MASK ( R600_PTE_READABLE | R600_PTE_WRITEABLE | \
      R600_PTE_SYSTEM | R600_PTE_VALID )

struct radeon_vm_pt {
 struct radeon_bo  *bo;
 uint64_t   addr;
};

struct radeon_vm_id {
 unsigned  id;
 uint64_t  pd_gpu_addr;
 /* last flushed PD/PT update */
 struct radeon_fence *flushed_updates;
 /* last use of vmid */
 struct radeon_fence *last_id_use;
};

struct radeon_vm {
 struct mutex  mutex;

 struct rb_root_cached va;

 /* protecting invalidated and freed */
 spinlock_t  status_lock;

 /* BOs moved, but not yet updated in the PT */
 struct list_head invalidated;

 /* BOs freed, but not yet updated in the PT */
 struct list_head freed;

 /* BOs cleared in the PT */
 struct list_head cleared;

 /* contains the page directory */
 struct radeon_bo *page_directory;
 unsigned  max_pde_used;

 /* array of page tables, one for each page directory entry */
 struct radeon_vm_pt *page_tables;

 struct radeon_bo_va *ib_bo_va;

 /* for id and flush management per ring */
 struct radeon_vm_id ids[RADEON_NUM_RINGS];
};

struct radeon_vm_manager {
 struct radeon_fence  *active[RADEON_NUM_VM];
 uint32_t   max_pfn;
 /* number of VMIDs */
 unsigned   nvm;
 /* vram base address for page table entry  */
 u64    vram_base_offset;
 /* is vm enabled? */
 bool    enabled;
 /* for hw to save the PD addr on suspend/resume */
 uint32_t   saved_table_addr[RADEON_NUM_VM];
};

/*
 * file private structure
 */

struct radeon_fpriv {
 struct radeon_vm  vm;
};

/*
 * R6xx+ IH ring
 */

struct r600_ih {
 struct radeon_bo *ring_obj;
 volatile uint32_t *ring;
 unsigned  rptr;
 unsigned  ring_size;
 uint64_t  gpu_addr;
 uint32_t  ptr_mask;
 atomic_t  lock;
 bool                    enabled;
};

/*
 * RLC stuff
 */

#include "clearstate_defs.h"

struct radeon_rlc {
 /* for power gating */
 struct radeon_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 radeon_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 radeon_bo *cp_table_obj;
 uint64_t  cp_table_gpu_addr;
 volatile uint32_t *cp_table_ptr;
 u32                     cp_table_size;
};

int radeon_ib_get(struct radeon_device *rdev, int ring,
    struct radeon_ib *ib, struct radeon_vm *vm,
    unsigned size);
void radeon_ib_free(struct radeon_device *rdev, struct radeon_ib *ib);
int radeon_ib_schedule(struct radeon_device *rdev, struct radeon_ib *ib,
         struct radeon_ib *const_ib, bool hdp_flush);
int radeon_ib_pool_init(struct radeon_device *rdev);
void radeon_ib_pool_fini(struct radeon_device *rdev);
int radeon_ib_ring_tests(struct radeon_device *rdev);
/* Ring access between begin & end cannot sleep */
bool radeon_ring_supports_scratch_reg(struct radeon_device *rdev,
          struct radeon_ring *ring);
void radeon_ring_free_size(struct radeon_device *rdev, struct radeon_ring *cp);
int radeon_ring_alloc(struct radeon_device *rdev, struct radeon_ring *cp, unsigned ndw);
int radeon_ring_lock(struct radeon_device *rdev, struct radeon_ring *cp, unsigned ndw);
void radeon_ring_commit(struct radeon_device *rdev, struct radeon_ring *cp,
   bool hdp_flush);
void radeon_ring_unlock_commit(struct radeon_device *rdev, struct radeon_ring *cp,
          bool hdp_flush);
void radeon_ring_undo(struct radeon_ring *ring);
void radeon_ring_unlock_undo(struct radeon_device *rdev, struct radeon_ring *cp);
int radeon_ring_test(struct radeon_device *rdev, struct radeon_ring *cp);
void radeon_ring_lockup_update(struct radeon_device *rdev,
          struct radeon_ring *ring);
bool radeon_ring_test_lockup(struct radeon_device *rdev, struct radeon_ring *ring);
unsigned radeon_ring_backup(struct radeon_device *rdev, struct radeon_ring *ring,
       uint32_t **data);
int radeon_ring_restore(struct radeon_device *rdev, struct radeon_ring *ring,
   unsigned size, uint32_t *data);
int radeon_ring_init(struct radeon_device *rdev, struct radeon_ring *cp, unsigned ring_size,
       unsigned rptr_offs, u32 nop);
void radeon_ring_fini(struct radeon_device *rdev, struct radeon_ring *cp);


/* r600 async dma */
void r600_dma_stop(struct radeon_device *rdev);
int r600_dma_resume(struct radeon_device *rdev);
void r600_dma_fini(struct radeon_device *rdev);

void cayman_dma_stop(struct radeon_device *rdev);
int cayman_dma_resume(struct radeon_device *rdev);
void cayman_dma_fini(struct radeon_device *rdev);

/*
 * CS.
 */

struct radeon_cs_chunk {
 uint32_t  length_dw;
 uint32_t  *kdata;
 void __user  *user_ptr;
};

struct radeon_cs_parser {
 struct device  *dev;
 struct radeon_device *rdev;
 struct drm_file  *filp;
 /* chunks */
 unsigned  nchunks;
 struct radeon_cs_chunk *chunks;
 uint64_t  *chunks_array;
 /* IB */
 unsigned  idx;
 /* relocations */
 unsigned  nrelocs;
 struct radeon_bo_list *relocs;
 struct radeon_bo_list *vm_bos;
 struct list_head validated;
 unsigned  dma_reloc_idx;
 struct drm_exec  exec;
 /* indices of various chunks */
 struct radeon_cs_chunk  *chunk_ib;
 struct radeon_cs_chunk  *chunk_relocs;
 struct radeon_cs_chunk  *chunk_flags;
 struct radeon_cs_chunk  *chunk_const_ib;
 struct radeon_ib ib;
 struct radeon_ib const_ib;
 void   *track;
 unsigned  family;
 int   parser_error;
 u32   cs_flags;
 u32   ring;
 s32   priority;
};

static inline u32 radeon_get_ib_value(struct radeon_cs_parser *p, int idx)
{
 struct radeon_cs_chunk *ibc = p->chunk_ib;

 if (ibc->kdata)
  return ibc->kdata[idx];
 return p->ib.ptr[idx];
}


struct radeon_cs_packet {
 unsigned idx;
 unsigned type;
 unsigned reg;
 unsigned opcode;
 int  count;
 unsigned one_reg_wr;
};

typedef int (*radeon_packet0_check_t)(struct radeon_cs_parser *p,
          struct radeon_cs_packet *pkt,
          unsigned idx, unsigned reg);

/*
 * AGP
 */


struct radeon_agp_mode {
 unsigned long mode; /**< AGP mode */
};

struct radeon_agp_info {
 int agp_version_major;
 int agp_version_minor;
 unsigned long mode;
 unsigned long aperture_base; /* physical address */
 unsigned long aperture_size; /* bytes */
 unsigned long memory_allowed; /* bytes */
 unsigned long memory_used;

 /* PCI information */
 unsigned short id_vendor;
 unsigned short id_device;
};

struct radeon_agp_head {
 struct agp_kern_info agp_info;
 struct list_head memory;
 unsigned long mode;
 struct agp_bridge_data *bridge;
 int enabled;
 int acquired;
 unsigned long base;
 int agp_mtrr;
 int cant_use_aperture;
 unsigned long page_mask;
};

#if IS_ENABLED(CONFIG_AGP)
struct radeon_agp_head *radeon_agp_head_init(struct drm_device *dev);
#else
static inline struct radeon_agp_head *radeon_agp_head_init(struct drm_device *dev)
{
 return NULL;
}
#endif
int radeon_agp_init(struct radeon_device *rdev);
void radeon_agp_resume(struct radeon_device *rdev);
void radeon_agp_suspend(struct radeon_device *rdev);
void radeon_agp_fini(struct radeon_device *rdev);


/*
 * Writeback
 */

struct radeon_wb {
 struct radeon_bo *wb_obj;
 volatile uint32_t *wb;
 uint64_t  gpu_addr;
 bool                    enabled;
 bool                    use_event;
};

#define RADEON_WB_SCRATCH_OFFSET 0
#define RADEON_WB_RING0_NEXT_RPTR 256
#define RADEON_WB_CP_RPTR_OFFSET 1024
#define RADEON_WB_CP1_RPTR_OFFSET 1280
#define RADEON_WB_CP2_RPTR_OFFSET 1536
#define R600_WB_DMA_RPTR_OFFSET   1792
#define R600_WB_IH_WPTR_OFFSET   2048
#define CAYMAN_WB_DMA1_RPTR_OFFSET   2304
#define R600_WB_EVENT_OFFSET     3072
#define CIK_WB_CP1_WPTR_OFFSET     3328
#define CIK_WB_CP2_WPTR_OFFSET     3584
#define R600_WB_DMA_RING_TEST_OFFSET 3588
#define CAYMAN_WB_DMA1_RING_TEST_OFFSET 3592

/**
 * struct radeon_pm - power management datas
 * @max_bandwidth:      maximum bandwidth the gpu has (MByte/s)
 * @igp_sideport_mclk:  sideport memory clock Mhz (rs690,rs740,rs780,rs880)
 * @igp_system_mclk:    system clock Mhz (rs690,rs740,rs780,rs880)
 * @igp_ht_link_clk:    ht link clock Mhz (rs690,rs740,rs780,rs880)
 * @igp_ht_link_width:  ht link width in bits (rs690,rs740,rs780,rs880)
 * @k8_bandwidth:       k8 bandwidth the gpu has (MByte/s) (IGP)
 * @sideport_bandwidth: sideport bandwidth the gpu has (MByte/s) (IGP)
 * @ht_bandwidth:       ht bandwidth the gpu has (MByte/s) (IGP)
 * @core_bandwidth:     core GPU bandwidth the gpu has (MByte/s) (IGP)
 * @sclk:           GPU clock Mhz (core bandwidth depends of this clock)
 * @needed_bandwidth:   current bandwidth needs
 *
 * It keeps track of various data needed to take powermanagement decision.
 * Bandwidth need is used to determine minimun clock of the GPU and memory.
 * Equation between gpu/memory clock and available bandwidth is hw dependent
 * (type of memory, bus size, efficiency, ...)
 */


enum radeon_pm_method {
 PM_METHOD_PROFILE,
 PM_METHOD_DYNPM,
 PM_METHOD_DPM,
};

enum radeon_dynpm_state {
 DYNPM_STATE_DISABLED,
 DYNPM_STATE_MINIMUM,
 DYNPM_STATE_PAUSED,
 DYNPM_STATE_ACTIVE,
 DYNPM_STATE_SUSPENDED,
};
enum radeon_dynpm_action {
 DYNPM_ACTION_NONE,
 DYNPM_ACTION_MINIMUM,
 DYNPM_ACTION_DOWNCLOCK,
 DYNPM_ACTION_UPCLOCK,
 DYNPM_ACTION_DEFAULT
};

enum radeon_voltage_type {
 VOLTAGE_NONE = 0,
 VOLTAGE_GPIO,
 VOLTAGE_VDDC,
 VOLTAGE_SW
};

enum radeon_pm_state_type {
 /* not used for dpm */
 POWER_STATE_TYPE_DEFAULT,
 POWER_STATE_TYPE_POWERSAVE,
 /* user selectable states */
 POWER_STATE_TYPE_BATTERY,
 POWER_STATE_TYPE_BALANCED,
 POWER_STATE_TYPE_PERFORMANCE,
 /* internal states */
 POWER_STATE_TYPE_INTERNAL_UVD,
 POWER_STATE_TYPE_INTERNAL_UVD_SD,
 POWER_STATE_TYPE_INTERNAL_UVD_HD,
 POWER_STATE_TYPE_INTERNAL_UVD_HD2,
 POWER_STATE_TYPE_INTERNAL_UVD_MVC,
 POWER_STATE_TYPE_INTERNAL_BOOT,
 POWER_STATE_TYPE_INTERNAL_THERMAL,
 POWER_STATE_TYPE_INTERNAL_ACPI,
 POWER_STATE_TYPE_INTERNAL_ULV,
 POWER_STATE_TYPE_INTERNAL_3DPERF,
};

enum radeon_pm_profile_type {
 PM_PROFILE_DEFAULT,
 PM_PROFILE_AUTO,
 PM_PROFILE_LOW,
 PM_PROFILE_MID,
 PM_PROFILE_HIGH,
};

#define PM_PROFILE_DEFAULT_IDX 0
#define PM_PROFILE_LOW_SH_IDX  1
#define PM_PROFILE_MID_SH_IDX  2
#define PM_PROFILE_HIGH_SH_IDX 3
#define PM_PROFILE_LOW_MH_IDX  4
#define PM_PROFILE_MID_MH_IDX  5
#define PM_PROFILE_HIGH_MH_IDX 6
#define PM_PROFILE_MAX         7

struct radeon_pm_profile {
 int dpms_off_ps_idx;
 int dpms_on_ps_idx;
 int dpms_off_cm_idx;
 int dpms_on_cm_idx;
};

enum radeon_int_thermal_type {
 THERMAL_TYPE_NONE,
 THERMAL_TYPE_EXTERNAL,
 THERMAL_TYPE_EXTERNAL_GPIO,
 THERMAL_TYPE_RV6XX,
 THERMAL_TYPE_RV770,
 THERMAL_TYPE_ADT7473_WITH_INTERNAL,
 THERMAL_TYPE_EVERGREEN,
 THERMAL_TYPE_SUMO,
 THERMAL_TYPE_NI,
 THERMAL_TYPE_SI,
 THERMAL_TYPE_EMC2103_WITH_INTERNAL,
 THERMAL_TYPE_CI,
 THERMAL_TYPE_KV,
};

struct radeon_voltage {
 enum radeon_voltage_type type;
 /* gpio voltage */
 struct radeon_gpio_rec gpio;
 u32 delay; /* delay in usec from voltage drop to sclk change */
 bool active_high; /* voltage drop is active when bit is high */
 /* VDDC voltage */
 u8 vddc_id; /* index into vddc voltage table */
 u8 vddci_id; /* index into vddci voltage table */
 bool vddci_enabled;
 /* r6xx+ sw */
 u16 voltage;
 /* evergreen+ vddci */
 u16 vddci;
};

/* clock mode flags */
#define RADEON_PM_MODE_NO_DISPLAY          (1 << 0)

struct radeon_pm_clock_info {
 /* memory clock */
 u32 mclk;
 /* engine clock */
 u32 sclk;
 /* voltage info */
 struct radeon_voltage voltage;
 /* standardized clock flags */
 u32 flags;
};

/* state flags */
#define RADEON_PM_STATE_SINGLE_DISPLAY_ONLY (1 << 0)

struct radeon_power_state {
 enum radeon_pm_state_type type;
 struct radeon_pm_clock_info *clock_info;
 /* number of valid clock modes in this power state */
 int num_clock_modes;
 struct radeon_pm_clock_info *default_clock_mode;
 /* standardized state flags */
 u32 flags;
 u32 misc; /* vbios specific flags */
 u32 misc2; /* vbios specific flags */
 int pcie_lanes; /* pcie lanes */
};

/*
 * Some modes are overclocked by very low value, accept them
 */

#define RADEON_MODE_OVERCLOCK_MARGIN 500 /* 5 MHz */

enum radeon_dpm_auto_throttle_src {
 RADEON_DPM_AUTO_THROTTLE_SRC_THERMAL,
 RADEON_DPM_AUTO_THROTTLE_SRC_EXTERNAL
};

enum radeon_dpm_event_src {
 RADEON_DPM_EVENT_SRC_ANALOG = 0,
 RADEON_DPM_EVENT_SRC_EXTERNAL = 1,
 RADEON_DPM_EVENT_SRC_DIGITAL = 2,
 RADEON_DPM_EVENT_SRC_ANALOG_OR_EXTERNAL = 3,
 RADEON_DPM_EVENT_SRC_DIGIAL_OR_EXTERNAL = 4
};

#define RADEON_MAX_VCE_LEVELS 6

enum radeon_vce_level {
 RADEON_VCE_LEVEL_AC_ALL = 0,     /* AC, All cases */
 RADEON_VCE_LEVEL_DC_EE = 1,      /* DC, entropy encoding */
 RADEON_VCE_LEVEL_DC_LL_LOW = 2,  /* DC, low latency queue, res <= 720 */
 RADEON_VCE_LEVEL_DC_LL_HIGH = 3, /* DC, low latency queue, 1080 >= res > 720 */
 RADEON_VCE_LEVEL_DC_GP_LOW = 4,  /* DC, general purpose queue, res <= 720 */
 RADEON_VCE_LEVEL_DC_GP_HIGH = 5, /* DC, general purpose queue, 1080 >= res > 720 */
};

struct radeon_ps {
 u32 caps; /* vbios flags */
 u32 class/* vbios flags */
 u32 class2; /* vbios flags */
 /* UVD clocks */
 u32 vclk;
 u32 dclk;
 /* VCE clocks */
 u32 evclk;
 u32 ecclk;
 bool vce_active;
 enum radeon_vce_level vce_level;
 /* asic priv */
 void *ps_priv;
};

struct radeon_dpm_thermal {
 /* thermal interrupt work */
 struct work_struct work;
 /* low temperature threshold */
 int                min_temp;
 /* high temperature threshold */
 int                max_temp;
 /* was interrupt low to high or high to low */
 bool               high_to_low;
};

enum radeon_clk_action {
 RADEON_SCLK_UP = 1,
 RADEON_SCLK_DOWN
};

struct radeon_blacklist_clocks {
 u32 sclk;
 u32 mclk;
 enum radeon_clk_action action;
};

struct radeon_clock_and_voltage_limits {
 u32 sclk;
 u32 mclk;
 u16 vddc;
 u16 vddci;
};

struct radeon_clock_array {
 u32 count;
 u32 *values;
};

struct radeon_clock_voltage_dependency_entry {
 u32 clk;
 u16 v;
};

struct radeon_clock_voltage_dependency_table {
 u32 count;
 struct radeon_clock_voltage_dependency_entry *entries;
};

union radeon_cac_leakage_entry {
 struct {
  u16 vddc;
  u32 leakage;
 };
 struct {
  u16 vddc1;
  u16 vddc2;
  u16 vddc3;
 };
};

struct radeon_cac_leakage_table {
 u32 count;
 union radeon_cac_leakage_entry *entries;
};

struct radeon_phase_shedding_limits_entry {
 u16 voltage;
 u32 sclk;
 u32 mclk;
};

struct radeon_phase_shedding_limits_table {
 u32 count;
 struct radeon_phase_shedding_limits_entry *entries;
};

struct radeon_uvd_clock_voltage_dependency_entry {
 u32 vclk;
 u32 dclk;
 u16 v;
};

struct radeon_uvd_clock_voltage_dependency_table {
 u8 count;
 struct radeon_uvd_clock_voltage_dependency_entry *entries;
};

struct radeon_vce_clock_voltage_dependency_entry {
 u32 ecclk;
 u32 evclk;
 u16 v;
};

struct radeon_vce_clock_voltage_dependency_table {
 u8 count;
 struct radeon_vce_clock_voltage_dependency_entry *entries;
};

struct radeon_ppm_table {
 u8 ppm_design;
 u16 cpu_core_number;
 u32 platform_tdp;
 u32 small_ac_platform_tdp;
 u32 platform_tdc;
 u32 small_ac_platform_tdc;
 u32 apu_tdp;
 u32 dgpu_tdp;
 u32 dgpu_ulv_power;
 u32 tj_max;
};

struct radeon_cac_tdp_table {
 u16 tdp;
 u16 configurable_tdp;
 u16 tdc;
 u16 battery_power_limit;
 u16 small_power_limit;
 u16 low_cac_leakage;
 u16 high_cac_leakage;
 u16 maximum_power_delivery_limit;
};

struct radeon_dpm_dynamic_state {
 struct radeon_clock_voltage_dependency_table vddc_dependency_on_sclk;
 struct radeon_clock_voltage_dependency_table vddci_dependency_on_mclk;
 struct radeon_clock_voltage_dependency_table vddc_dependency_on_mclk;
 struct radeon_clock_voltage_dependency_table mvdd_dependency_on_mclk;
 struct radeon_clock_voltage_dependency_table vddc_dependency_on_dispclk;
 struct radeon_uvd_clock_voltage_dependency_table uvd_clock_voltage_dependency_table;
 struct radeon_vce_clock_voltage_dependency_table vce_clock_voltage_dependency_table;
 struct radeon_clock_voltage_dependency_table samu_clock_voltage_dependency_table;
 struct radeon_clock_voltage_dependency_table acp_clock_voltage_dependency_table;
 struct radeon_clock_array valid_sclk_values;
 struct radeon_clock_array valid_mclk_values;
 struct radeon_clock_and_voltage_limits max_clock_voltage_on_dc;
 struct radeon_clock_and_voltage_limits max_clock_voltage_on_ac;
 u32 mclk_sclk_ratio;
 u32 sclk_mclk_delta;
 u16 vddc_vddci_delta;
 u16 min_vddc_for_pcie_gen2;
 struct radeon_cac_leakage_table cac_leakage_table;
 struct radeon_phase_shedding_limits_table phase_shedding_limits_table;
 struct radeon_ppm_table *ppm_table;
 struct radeon_cac_tdp_table *cac_tdp_table;
};

struct radeon_dpm_fan {
 u16 t_min;
 u16 t_med;
 u16 t_high;
 u16 pwm_min;
 u16 pwm_med;
 u16 pwm_high;
 u8 t_hyst;
 u32 cycle_delay;
 u16 t_max;
 u8 control_mode;
 u16 default_max_fan_pwm;
 u16 default_fan_output_sensitivity;
 u16 fan_output_sensitivity;
 bool ucode_fan_control;
};

enum radeon_pcie_gen {
 RADEON_PCIE_GEN1 = 0,
 RADEON_PCIE_GEN2 = 1,
 RADEON_PCIE_GEN3 = 2,
 RADEON_PCIE_GEN_INVALID = 0xffff
};

enum radeon_dpm_forced_level {
 RADEON_DPM_FORCED_LEVEL_AUTO = 0,
 RADEON_DPM_FORCED_LEVEL_LOW = 1,
 RADEON_DPM_FORCED_LEVEL_HIGH = 2,
};

struct radeon_vce_state {
 /* vce clocks */
 u32 evclk;
 u32 ecclk;
 /* gpu clocks */
 u32 sclk;
 u32 mclk;
 u8 clk_idx;
 u8 pstate;
};

struct radeon_dpm {
 struct radeon_ps        *ps;
 /* number of valid power states */
 int                     num_ps;
 /* current power state that is active */
 struct radeon_ps        *current_ps;
 /* requested power state */
 struct radeon_ps        *requested_ps;
 /* boot up power state */
 struct radeon_ps        *boot_ps;
 /* default uvd power state */
 struct radeon_ps        *uvd_ps;
 /* vce requirements */
 struct radeon_vce_state vce_states[RADEON_MAX_VCE_LEVELS];
 enum radeon_vce_level vce_level;
 enum radeon_pm_state_type state;
 enum radeon_pm_state_type user_state;
 u32                     platform_caps;
 u32                     voltage_response_time;
 u32                     backbias_response_time;
 void                    *priv;
 u32   new_active_crtcs;
 int   new_active_crtc_count;
 int   high_pixelclock_count;
 u32   current_active_crtcs;
 int   current_active_crtc_count;
 bool single_display;
 struct radeon_dpm_dynamic_state dyn_state;
 struct radeon_dpm_fan fan;
 u32 tdp_limit;
 u32 near_tdp_limit;
 u32 near_tdp_limit_adjusted;
 u32 sq_ramping_threshold;
 u32 cac_leakage;
 u16 tdp_od_limit;
 u32 tdp_adjustment;
 u16 load_line_slope;
 bool power_control;
 bool ac_power;
 /* special states active */
 bool                    thermal_active;
 bool                    uvd_active;
 bool                    vce_active;
 /* thermal handling */
 struct radeon_dpm_thermal thermal;
 /* forced levels */
 enum radeon_dpm_forced_level forced_level;
 /* track UVD streams */
 unsigned sd;
 unsigned hd;
};

void radeon_dpm_enable_uvd(struct radeon_device *rdev, bool enable);
void radeon_dpm_enable_vce(struct radeon_device *rdev, bool enable);

struct radeon_pm {
 struct mutex  mutex;
 /* write locked while reprogramming mclk */
 struct rw_semaphore mclk_lock;
 u32   active_crtcs;
 int   active_crtc_count;
 int   req_vblank;
 bool   vblank_sync;
 fixed20_12  max_bandwidth;
 fixed20_12  igp_sideport_mclk;
 fixed20_12  igp_system_mclk;
 fixed20_12  igp_ht_link_clk;
 fixed20_12  igp_ht_link_width;
 fixed20_12  k8_bandwidth;
 fixed20_12  sideport_bandwidth;
 fixed20_12  ht_bandwidth;
 fixed20_12  core_bandwidth;
 fixed20_12  sclk;
 fixed20_12  mclk;
 fixed20_12  needed_bandwidth;
 struct radeon_power_state *power_state;
 /* number of valid power states */
 int                     num_power_states;
 int                     current_power_state_index;
 int                     current_clock_mode_index;
 int                     requested_power_state_index;
 int                     requested_clock_mode_index;
 int                     default_power_state_index;
 u32                     current_sclk;
 u32                     current_mclk;
 u16                     current_vddc;
 u16                     current_vddci;
 u32                     default_sclk;
 u32                     default_mclk;
 u16                     default_vddc;
 u16                     default_vddci;
 struct radeon_i2c_chan *i2c_bus;
 /* selected pm method */
 enum radeon_pm_method     pm_method;
 /* dynpm power management */
 struct delayed_work dynpm_idle_work;
 enum radeon_dynpm_state dynpm_state;
 enum radeon_dynpm_action dynpm_planned_action;
 unsigned long  dynpm_action_timeout;
 bool                    dynpm_can_upclock;
 bool                    dynpm_can_downclock;
 /* profile-based power management */
 enum radeon_pm_profile_type profile;
 int                     profile_index;
 struct radeon_pm_profile profiles[PM_PROFILE_MAX];
 /* internal thermal controller on rv6xx+ */
 enum radeon_int_thermal_type int_thermal_type;
 struct device         *int_hwmon_dev;
 /* fan control parameters */
 bool                    no_fan;
 u8                      fan_pulses_per_revolution;
 u8                      fan_min_rpm;
 u8                      fan_max_rpm;
 /* dpm */
 bool                    dpm_enabled;
 bool                    sysfs_initialized;
 struct radeon_dpm       dpm;
};

#define RADEON_PCIE_SPEED_25 1
#define RADEON_PCIE_SPEED_50 2
#define RADEON_PCIE_SPEED_80 4

int radeon_pm_get_type_index(struct radeon_device *rdev,
        enum radeon_pm_state_type ps_type,
        int instance);
/*
 * UVD
 */

#define RADEON_DEFAULT_UVD_HANDLES 10
#define RADEON_MAX_UVD_HANDLES  30
#define RADEON_UVD_STACK_SIZE  (200*1024)
#define RADEON_UVD_HEAP_SIZE  (256*1024)
#define RADEON_UVD_SESSION_SIZE  (50*1024)

struct radeon_uvd {
 bool   fw_header_present;
 struct radeon_bo *vcpu_bo;
 void   *cpu_addr;
 uint64_t  gpu_addr;
 unsigned  max_handles;
 atomic_t  handles[RADEON_MAX_UVD_HANDLES];
 struct drm_file  *filp[RADEON_MAX_UVD_HANDLES];
 unsigned  img_size[RADEON_MAX_UVD_HANDLES];
 struct delayed_work idle_work;
};

int radeon_uvd_init(struct radeon_device *rdev);
void radeon_uvd_fini(struct radeon_device *rdev);
int radeon_uvd_suspend(struct radeon_device *rdev);
int radeon_uvd_resume(struct radeon_device *rdev);
int radeon_uvd_get_create_msg(struct radeon_device *rdev, int ring,
         uint32_t handle, struct radeon_fence **fence);
int radeon_uvd_get_destroy_msg(struct radeon_device *rdev, int ring,
          uint32_t handle, struct radeon_fence **fence);
void radeon_uvd_force_into_uvd_segment(struct radeon_bo *rbo,
           uint32_t allowed_domains);
void radeon_uvd_free_handles(struct radeon_device *rdev,
        struct drm_file *filp);
int radeon_uvd_cs_parse(struct radeon_cs_parser *parser);
void radeon_uvd_note_usage(struct radeon_device *rdev);
int radeon_uvd_calc_upll_dividers(struct radeon_device *rdev,
      unsigned vclk, unsigned dclk,
      unsigned vco_min, unsigned vco_max,
      unsigned fb_factor, unsigned fb_mask,
      unsigned pd_min, unsigned pd_max,
      unsigned pd_even,
      unsigned *optimal_fb_div,
      unsigned *optimal_vclk_div,
      unsigned *optimal_dclk_div);
int radeon_uvd_send_upll_ctlreq(struct radeon_device *rdev,
                                unsigned cg_upll_func_cntl);

/*
 * VCE
 */

#define RADEON_MAX_VCE_HANDLES 16

struct radeon_vce {
 struct radeon_bo *vcpu_bo;
 uint64_t  gpu_addr;
 unsigned  fw_version;
 unsigned  fb_version;
 atomic_t  handles[RADEON_MAX_VCE_HANDLES];
 struct drm_file  *filp[RADEON_MAX_VCE_HANDLES];
 unsigned  img_size[RADEON_MAX_VCE_HANDLES];
 struct delayed_work idle_work;
 uint32_t  keyselect;
};

int radeon_vce_init(struct radeon_device *rdev);
void radeon_vce_fini(struct radeon_device *rdev);
int radeon_vce_suspend(struct radeon_device *rdev);
int radeon_vce_resume(struct radeon_device *rdev);
int radeon_vce_get_create_msg(struct radeon_device *rdev, int ring,
         uint32_t handle, struct radeon_fence **fence);
int radeon_vce_get_destroy_msg(struct radeon_device *rdev, int ring,
          uint32_t handle, struct radeon_fence **fence);
void radeon_vce_free_handles(struct radeon_device *rdev, struct drm_file *filp);
void radeon_vce_note_usage(struct radeon_device *rdev);
int radeon_vce_cs_reloc(struct radeon_cs_parser *p, int lo, int hi, unsigned size);
int radeon_vce_cs_parse(struct radeon_cs_parser *p);
bool radeon_vce_semaphore_emit(struct radeon_device *rdev,
          struct radeon_ring *ring,
          struct radeon_semaphore *semaphore,
          bool emit_wait);
void radeon_vce_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib);
void radeon_vce_fence_emit(struct radeon_device *rdev,
      struct radeon_fence *fence);
int radeon_vce_ring_test(struct radeon_device *rdev, struct radeon_ring *ring);
int radeon_vce_ib_test(struct radeon_device *rdev, struct radeon_ring *ring);

struct r600_audio_pin {
 int   channels;
 int   rate;
 int   bits_per_sample;
 u8   status_bits;
 u8   category_code;
 u32   offset;
 bool   connected;
 u32   id;
};

struct r600_audio {
 bool enabled;
 struct r600_audio_pin pin[RADEON_MAX_AFMT_BLOCKS];
 int num_pins;
 struct radeon_audio_funcs *hdmi_funcs;
 struct radeon_audio_funcs *dp_funcs;
 struct radeon_audio_basic_funcs *funcs;
 struct drm_audio_component *component;
 bool component_registered;
 struct mutex component_mutex;
};

/*
 * Benchmarking
 */

void radeon_benchmark(struct radeon_device *rdev, int test_number);


/*
 * Testing
 */

void radeon_test_moves(struct radeon_device *rdev);
void radeon_test_ring_sync(struct radeon_device *rdev,
      struct radeon_ring *cpA,
      struct radeon_ring *cpB);
void radeon_test_syncing(struct radeon_device *rdev);

/*
 * MMU Notifier
 */

#if defined(CONFIG_MMU_NOTIFIER)
int radeon_mn_register(struct radeon_bo *bo, unsigned long addr);
void radeon_mn_unregister(struct radeon_bo *bo);
#else
static inline int radeon_mn_register(struct radeon_bo *bo, unsigned long addr)
{
 return -ENODEV;
}
static inline void radeon_mn_unregister(struct radeon_bo *bo) {}
#endif

/*
 * Debugfs
 */

void radeon_debugfs_fence_init(struct radeon_device *rdev);
void radeon_gem_debugfs_init(struct radeon_device *rdev);

/*
 * ASIC ring specific functions.
 */

struct radeon_asic_ring {
 /* ring read/write ptr handling */
 u32 (*get_rptr)(struct radeon_device *rdev, struct radeon_ring *ring);
 u32 (*get_wptr)(struct radeon_device *rdev, struct radeon_ring *ring);
 void (*set_wptr)(struct radeon_device *rdev, struct radeon_ring *ring);

 /* validating and patching of IBs */
 int (*ib_parse)(struct radeon_device *rdev, struct radeon_ib *ib);
 int (*cs_parse)(struct radeon_cs_parser *p);

 /* command emmit functions */
 void (*ib_execute)(struct radeon_device *rdev, struct radeon_ib *ib);
 void (*emit_fence)(struct radeon_device *rdev, struct radeon_fence *fence);
 void (*hdp_flush)(struct radeon_device *rdev, struct radeon_ring *ring);
 bool (*emit_semaphore)(struct radeon_device *rdev, struct radeon_ring *cp,
          struct radeon_semaphore *semaphore, bool emit_wait);
 void (*vm_flush)(struct radeon_device *rdev, struct radeon_ring *ring,
    unsigned vm_id, uint64_t pd_addr);

 /* testing functions */
 int (*ring_test)(struct radeon_device *rdev, struct radeon_ring *cp);
 int (*ib_test)(struct radeon_device *rdev, struct radeon_ring *cp);
 bool (*is_lockup)(struct radeon_device *rdev, struct radeon_ring *cp);

 /* deprecated */
 void (*ring_start)(struct radeon_device *rdev, struct radeon_ring *cp);
};

/*
 * ASIC specific functions.
 */

struct radeon_asic {
 int (*init)(struct radeon_device *rdev);
 void (*fini)(struct radeon_device *rdev);
 int (*resume)(struct radeon_device *rdev);
 int (*suspend)(struct radeon_device *rdev);
 void (*vga_set_state)(struct radeon_device *rdev, bool state);
 int (*asic_reset)(struct radeon_device *rdev, bool hard);
 /* Flush the HDP cache via MMIO */
 void (*mmio_hdp_flush)(struct radeon_device *rdev);
 /* check if 3D engine is idle */
 bool (*gui_idle)(struct radeon_device *rdev);
 /* wait for mc_idle */
 int (*mc_wait_for_idle)(struct radeon_device *rdev);
 /* get the reference clock */
 u32 (*get_xclk)(struct radeon_device *rdev);
 /* get the gpu clock counter */
 uint64_t (*get_gpu_clock_counter)(struct radeon_device *rdev);
 /* get register for info ioctl */
 int (*get_allowed_info_register)(struct radeon_device *rdev, u32 reg, u32 *val);
 /* gart */
 struct {
  void (*tlb_flush)(struct radeon_device *rdev);
  uint64_t (*get_page_entry)(uint64_t addr, uint32_t flags);
  void (*set_page)(struct radeon_device *rdev, unsigned i,
     uint64_t entry);
 } gart;
 struct {
  int (*init)(struct radeon_device *rdev);
  void (*fini)(struct radeon_device *rdev);
  void (*copy_pages)(struct radeon_device *rdev,
       struct radeon_ib *ib,
       uint64_t pe, uint64_t src,
       unsigned count);
  void (*write_pages)(struct radeon_device *rdev,
        struct radeon_ib *ib,
        uint64_t pe,
        uint64_t addr, unsigned count,
        uint32_t incr, uint32_t flags);
  void (*set_pages)(struct radeon_device *rdev,
      struct radeon_ib *ib,
      uint64_t pe,
      uint64_t addr, unsigned count,
      uint32_t incr, uint32_t flags);
  void (*pad_ib)(struct radeon_ib *ib);
 } vm;
 /* ring specific callbacks */
 const struct radeon_asic_ring *ring[RADEON_NUM_RINGS];
 /* irqs */
 struct {
  int (*set)(struct radeon_device *rdev);
  int (*process)(struct radeon_device *rdev);
 } irq;
 /* displays */
 struct {
  /* display watermarks */
  void (*bandwidth_update)(struct radeon_device *rdev);
  /* get frame count */
  u32 (*get_vblank_counter)(struct radeon_device *rdev, int crtc);
  /* wait for vblank */
  void (*wait_for_vblank)(struct radeon_device *rdev, int crtc);
  /* set backlight level */
  void (*set_backlight_level)(struct radeon_encoder *radeon_encoder, u8 level);
  /* get backlight level */
  u8 (*get_backlight_level)(struct radeon_encoder *radeon_encoder);
  /* audio callbacks */
  void (*hdmi_enable)(struct drm_encoder *encoder, bool enable);
  void (*hdmi_setmode)(struct drm_encoder *encoder, struct drm_display_mode *mode);
 } display;
 /* copy functions for bo handling */
 struct {
  struct radeon_fence *(*blit)(struct radeon_device *rdev,
          uint64_t src_offset,
          uint64_t dst_offset,
          unsigned num_gpu_pages,
          struct dma_resv *resv);
  u32 blit_ring_index;
  struct radeon_fence *(*dma)(struct radeon_device *rdev,
         uint64_t src_offset,
         uint64_t dst_offset,
         unsigned num_gpu_pages,
         struct dma_resv *resv);
  u32 dma_ring_index;
  /* method used for bo copy */
  struct radeon_fence *(*copy)(struct radeon_device *rdev,
          uint64_t src_offset,
          uint64_t dst_offset,
          unsigned num_gpu_pages,
          struct dma_resv *resv);
  /* ring used for bo copies */
  u32 copy_ring_index;
 } copy;
 /* surfaces */
 struct {
  int (*set_reg)(struct radeon_device *rdev, int reg,
           uint32_t tiling_flags, uint32_t pitch,
           uint32_t offset, uint32_t obj_size);
  void (*clear_reg)(struct radeon_device *rdev, int reg);
 } surface;
 /* hotplug detect */
 struct {
  void (*init)(struct radeon_device *rdev);
  void (*fini)(struct radeon_device *rdev);
  bool (*sense)(struct radeon_device *rdev, enum radeon_hpd_id hpd);
  void (*set_polarity)(struct radeon_device *rdev, enum radeon_hpd_id hpd);
 } hpd;
 /* static power management */
 struct {
  void (*misc)(struct radeon_device *rdev);
  void (*prepare)(struct radeon_device *rdev);
  void (*finish)(struct radeon_device *rdev);
  void (*init_profile)(struct radeon_device *rdev);
  void (*get_dynpm_state)(struct radeon_device *rdev);
  uint32_t (*get_engine_clock)(struct radeon_device *rdev);
  void (*set_engine_clock)(struct radeon_device *rdev, uint32_t eng_clock);
  uint32_t (*get_memory_clock)(struct radeon_device *rdev);
  void (*set_memory_clock)(struct radeon_device *rdev, uint32_t mem_clock);
  int (*get_pcie_lanes)(struct radeon_device *rdev);
  void (*set_pcie_lanes)(struct radeon_device *rdev, int lanes);
  void (*set_clock_gating)(struct radeon_device *rdev, int enable);
  int (*set_uvd_clocks)(struct radeon_device *rdev, u32 vclk, u32 dclk);
  int (*set_vce_clocks)(struct radeon_device *rdev, u32 evclk, u32 ecclk);
  int (*get_temperature)(struct radeon_device *rdev);
 } pm;
 /* dynamic power management */
 struct {
  int (*init)(struct radeon_device *rdev);
  void (*setup_asic)(struct radeon_device *rdev);
  int (*enable)(struct radeon_device *rdev);
  int (*late_enable)(struct radeon_device *rdev);
  void (*disable)(struct radeon_device *rdev);
  int (*pre_set_power_state)(struct radeon_device *rdev);
  int (*set_power_state)(struct radeon_device *rdev);
  void (*post_set_power_state)(struct radeon_device *rdev);
  void (*display_configuration_changed)(struct radeon_device *rdev);
  void (*fini)(struct radeon_device *rdev);
  u32 (*get_sclk)(struct radeon_device *rdev, bool low);
  u32 (*get_mclk)(struct radeon_device *rdev, bool low);
  void (*print_power_state)(struct radeon_device *rdev, struct radeon_ps *ps);
  void (*debugfs_print_current_performance_level)(struct radeon_device *rdev, struct seq_file *m);
  int (*force_performance_level)(struct radeon_device *rdev, enum radeon_dpm_forced_level level);
  bool (*vblank_too_short)(struct radeon_device *rdev);
  void (*powergate_uvd)(struct radeon_device *rdev, bool gate);
  void (*enable_bapm)(struct radeon_device *rdev, bool enable);
  void (*fan_ctrl_set_mode)(struct radeon_device *rdev, u32 mode);
  u32 (*fan_ctrl_get_mode)(struct radeon_device *rdev);
  int (*set_fan_speed_percent)(struct radeon_device *rdev, u32 speed);
  int (*get_fan_speed_percent)(struct radeon_device *rdev, u32 *speed);
  u32 (*get_current_sclk)(struct radeon_device *rdev);
  u32 (*get_current_mclk)(struct radeon_device *rdev);
  u16 (*get_current_vddc)(struct radeon_device *rdev);
 } dpm;
 /* pageflipping */
 struct {
  void (*page_flip)(struct radeon_device *rdev, int crtc, u64 crtc_base, bool async);
  bool (*page_flip_pending)(struct radeon_device *rdev, int crtc);
 } pflip;
};

/*
 * Asic structures
 */

struct r100_asic {
 const unsigned  *reg_safe_bm;
 unsigned  reg_safe_bm_size;
 u32   hdp_cntl;
};

struct r300_asic {
 const unsigned  *reg_safe_bm;
 unsigned  reg_safe_bm_size;
 u32   resync_scratch;
 u32   hdp_cntl;
};

struct r600_asic {
 unsigned  max_pipes;
 unsigned  max_tile_pipes;
 unsigned  max_simds;
 unsigned  max_backends;
 unsigned  max_gprs;
 unsigned  max_threads;
 unsigned  max_stack_entries;
 unsigned  max_hw_contexts;
 unsigned  max_gs_threads;
 unsigned  sx_max_export_size;
 unsigned  sx_max_export_pos_size;
 unsigned  sx_max_export_smx_size;
 unsigned  sq_num_cf_insts;
 unsigned  tiling_nbanks;
 unsigned  tiling_npipes;
 unsigned  tiling_group_size;
 unsigned  tile_config;
 unsigned  backend_map;
 unsigned  active_simds;
};

struct rv770_asic {
 unsigned  max_pipes;
 unsigned  max_tile_pipes;
 unsigned  max_simds;
 unsigned  max_backends;
 unsigned  max_gprs;
 unsigned  max_threads;
 unsigned  max_stack_entries;
 unsigned  max_hw_contexts;
 unsigned  max_gs_threads;
 unsigned  sx_max_export_size;
 unsigned  sx_max_export_pos_size;
 unsigned  sx_max_export_smx_size;
 unsigned  sq_num_cf_insts;
 unsigned  sx_num_of_sets;
 unsigned  sc_prim_fifo_size;
 unsigned  sc_hiz_tile_fifo_size;
 unsigned  sc_earlyz_tile_fifo_fize;
 unsigned  tiling_nbanks;
 unsigned  tiling_npipes;
 unsigned  tiling_group_size;
 unsigned  tile_config;
 unsigned  backend_map;
 unsigned  active_simds;
};

struct evergreen_asic {
 unsigned num_ses;
 unsigned max_pipes;
 unsigned max_tile_pipes;
 unsigned max_simds;
 unsigned max_backends;
 unsigned max_gprs;
 unsigned max_threads;
 unsigned max_stack_entries;
 unsigned max_hw_contexts;
 unsigned max_gs_threads;
 unsigned sx_max_export_size;
 unsigned sx_max_export_pos_size;
 unsigned sx_max_export_smx_size;
 unsigned sq_num_cf_insts;
 unsigned sx_num_of_sets;
 unsigned sc_prim_fifo_size;
 unsigned sc_hiz_tile_fifo_size;
 unsigned sc_earlyz_tile_fifo_size;
 unsigned tiling_nbanks;
 unsigned tiling_npipes;
 unsigned tiling_group_size;
 unsigned tile_config;
 unsigned backend_map;
 unsigned active_simds;
};

struct cayman_asic {
 unsigned max_shader_engines;
 unsigned max_pipes_per_simd;
 unsigned max_tile_pipes;
 unsigned max_simds_per_se;
 unsigned max_backends_per_se;
 unsigned max_texture_channel_caches;
 unsigned max_gprs;
 unsigned max_threads;
 unsigned max_gs_threads;
 unsigned max_stack_entries;
 unsigned sx_num_of_sets;
 unsigned sx_max_export_size;
 unsigned sx_max_export_pos_size;
 unsigned sx_max_export_smx_size;
 unsigned max_hw_contexts;
 unsigned sq_num_cf_insts;
 unsigned sc_prim_fifo_size;
 unsigned sc_hiz_tile_fifo_size;
 unsigned sc_earlyz_tile_fifo_size;

 unsigned num_shader_engines;
 unsigned num_shader_pipes_per_simd;
 unsigned num_tile_pipes;
 unsigned num_simds_per_se;
 unsigned num_backends_per_se;
 unsigned backend_disable_mask_per_asic;
 unsigned backend_map;
 unsigned num_texture_channel_caches;
 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 tile_config;
 unsigned active_simds;
};

struct si_asic {
 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 backend_disable_mask_per_asic;
 unsigned backend_map;
 unsigned num_texture_channel_caches;
 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 tile_config;
 uint32_t tile_mode_array[32];
 uint32_t active_cus;
};

struct cik_asic {
 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 backend_disable_mask_per_asic;
 unsigned backend_map;
 unsigned num_texture_channel_caches;
 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 tile_config;
 uint32_t tile_mode_array[32];
 uint32_t macrotile_mode_array[16];
 uint32_t active_cus;
};

union radeon_asic_config {
 struct r300_asic r300;
 struct r100_asic r100;
 struct r600_asic r600;
 struct rv770_asic rv770;
 struct evergreen_asic evergreen;
 struct cayman_asic cayman;
 struct si_asic  si;
 struct cik_asic  cik;
};

/*
 * asic initizalization from radeon_asic.c
 */

void radeon_agp_disable(struct radeon_device *rdev);
int radeon_asic_init(struct radeon_device *rdev);


/*
 * IOCTL.
 */

int radeon_gem_info_ioctl(struct drm_device *dev, void *data,
     struct drm_file *filp);
int radeon_gem_create_ioctl(struct drm_device *dev, void *data,
       struct drm_file *filp);
int radeon_gem_userptr_ioctl(struct drm_device *dev, void *data,
        struct drm_file *filp);
int radeon_gem_pin_ioctl(struct drm_device *dev, void *data,
    struct drm_file *file_priv);
int radeon_gem_unpin_ioctl(struct drm_device *dev, void *data,
      struct drm_file *file_priv);
int radeon_gem_set_domain_ioctl(struct drm_device *dev, void *data,
    struct drm_file *filp);
int radeon_gem_mmap_ioctl(struct drm_device *dev, void *data,
     struct drm_file *filp);
int radeon_gem_busy_ioctl(struct drm_device *dev, void *data,
     struct drm_file *filp);
int radeon_gem_wait_idle_ioctl(struct drm_device *dev, void *data,
         struct drm_file *filp);
int radeon_gem_va_ioctl(struct drm_device *dev, void *data,
     struct drm_file *filp);
int radeon_gem_op_ioctl(struct drm_device *dev, void *data,
   struct drm_file *filp);
int radeon_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp);
int radeon_gem_set_tiling_ioctl(struct drm_device *dev, void *data,
    struct drm_file *filp);
int radeon_gem_get_tiling_ioctl(struct drm_device *dev, void *data,
    struct drm_file *filp);
int radeon_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp);
--> --------------------

--> maximum size reached

--> --------------------

Messung V0.5
C=92 H=97 G=94

¤ Dauer der Verarbeitung: 0.29 Sekunden  (vorverarbeitet)  ¤

*© Formatika GbR, Deutschland






Versionsinformation zu Columbo

Bemerkung:

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Anfrage:

Dauer der Verarbeitung:

Sekunden

sprechenden Kalenders