From e49d93a960f8995affeb4541941eb7f16d04eafd Mon Sep 17 00:00:00 2001 From: Terje Bergstrom Date: Wed, 11 Oct 2017 14:58:57 -0700 Subject: gpu: nvgpu: Linux specific GPU characteristics flags Make GPU characteristics flags specific to Linux code only. The rest of driver is moved to using nvgpu_is_enabled() API. JIRA NVGPU-259 Change-Id: I2faf46ef64c964361c267887b28c9d19806d6d51 Signed-off-by: Terje Bergstrom Reviewed-on: https://git-master.nvidia.com/r/1583876 Reviewed-by: mobile promotions Tested-by: mobile promotions --- drivers/gpu/nvgpu/common/linux/ioctl_channel.c | 7 +-- drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c | 87 +++++++++++++++++++++++++- drivers/gpu/nvgpu/common/mm/vm.c | 4 +- drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c | 4 +- drivers/gpu/nvgpu/gk20a/gk20a.c | 24 ++++--- drivers/gpu/nvgpu/gm20b/gr_gm20b.c | 6 +- drivers/gpu/nvgpu/gp106/hal_gp106.c | 20 +++--- drivers/gpu/nvgpu/gp10b/gp10b.c | 54 ++++++++-------- drivers/gpu/nvgpu/gp10b/gr_gp10b.c | 1 + drivers/gpu/nvgpu/include/nvgpu/enabled.h | 64 ++++++++++++++++++- drivers/gpu/nvgpu/vgpu/fecs_trace_vgpu.c | 4 +- drivers/gpu/nvgpu/vgpu/vgpu.c | 6 +- 12 files changed, 209 insertions(+), 72 deletions(-) diff --git a/drivers/gpu/nvgpu/common/linux/ioctl_channel.c b/drivers/gpu/nvgpu/common/linux/ioctl_channel.c index ed00ad31..ee4755c8 100644 --- a/drivers/gpu/nvgpu/common/linux/ioctl_channel.c +++ b/drivers/gpu/nvgpu/common/linux/ioctl_channel.c @@ -28,6 +28,7 @@ #include #include #include +#include #include "gk20a/gk20a.h" #include "gk20a/ctxsw_trace_gk20a.h" @@ -99,8 +100,7 @@ static int gk20a_channel_cycle_stats(struct channel_gk20a *ch, void *virtual_address; /* is it allowed to handle calls for current GPU? */ - if (0 == (ch->g->gpu_characteristics.flags & - NVGPU_GPU_FLAGS_SUPPORT_CYCLE_STATS)) + if (!nvgpu_is_enabled(ch->g, NVGPU_SUPPORT_CYCLE_STATS)) return -ENOSYS; if (args->dmabuf_fd && !ch->cyclestate.cyclestate_buffer_handler) { @@ -176,8 +176,7 @@ static int gk20a_channel_cycle_stats_snapshot(struct channel_gk20a *ch, int ret; /* is it allowed to handle calls for current GPU? */ - if (0 == (ch->g->gpu_characteristics.flags & - NVGPU_GPU_FLAGS_SUPPORT_CYCLE_STATS_SNAPSHOT)) + if (!nvgpu_is_enabled(ch->g, NVGPU_SUPPORT_CYCLE_STATS_SNAPSHOT)) return -ENOSYS; if (!args->dmabuf_fd) diff --git a/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c b/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c index 4bb79375..6c9fc26f 100644 --- a/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c +++ b/drivers/gpu/nvgpu/common/linux/ioctl_ctrl.c @@ -20,6 +20,7 @@ #include #include #include +#include #include #include @@ -27,10 +28,14 @@ #include #include #include +#include #include #include "ioctl_ctrl.h" +#ifdef CONFIG_TEGRA_19x_GPU +#include "common/linux/ioctl_ctrl_t19x.h" +#endif #include "ioctl_tsg.h" #include "ioctl_channel.h" #include "gk20a/gk20a.h" @@ -113,6 +118,77 @@ int gk20a_ctrl_dev_release(struct inode *inode, struct file *filp) return 0; } +struct nvgpu_flags_mapping { + u64 ioctl_flag; + int enabled_flag; +}; + +static struct nvgpu_flags_mapping flags_mapping[] = { + {NVGPU_GPU_FLAGS_HAS_SYNCPOINTS, + NVGPU_HAS_SYNCPOINTS}, + {NVGPU_GPU_FLAGS_SUPPORT_PARTIAL_MAPPINGS, + NVGPU_SUPPORT_PARTIAL_MAPPINGS}, + {NVGPU_GPU_FLAGS_SUPPORT_SPARSE_ALLOCS, + NVGPU_SUPPORT_SPARSE_ALLOCS}, + {NVGPU_GPU_FLAGS_SUPPORT_SYNC_FENCE_FDS, + NVGPU_SUPPORT_SYNC_FENCE_FDS}, + {NVGPU_GPU_FLAGS_SUPPORT_CYCLE_STATS, + NVGPU_SUPPORT_CYCLE_STATS}, + {NVGPU_GPU_FLAGS_SUPPORT_CYCLE_STATS_SNAPSHOT, + NVGPU_SUPPORT_CYCLE_STATS_SNAPSHOT}, + {NVGPU_GPU_FLAGS_SUPPORT_USERSPACE_MANAGED_AS, + NVGPU_SUPPORT_USERSPACE_MANAGED_AS}, + {NVGPU_GPU_FLAGS_SUPPORT_TSG, + NVGPU_SUPPORT_TSG}, + {NVGPU_GPU_FLAGS_SUPPORT_CLOCK_CONTROLS, + NVGPU_SUPPORT_CLOCK_CONTROLS}, + {NVGPU_GPU_FLAGS_SUPPORT_GET_VOLTAGE, + NVGPU_SUPPORT_GET_VOLTAGE}, + {NVGPU_GPU_FLAGS_SUPPORT_GET_CURRENT, + NVGPU_SUPPORT_GET_CURRENT}, + {NVGPU_GPU_FLAGS_SUPPORT_GET_POWER, + NVGPU_SUPPORT_GET_POWER}, + {NVGPU_GPU_FLAGS_SUPPORT_GET_TEMPERATURE, + NVGPU_SUPPORT_GET_TEMPERATURE}, + {NVGPU_GPU_FLAGS_SUPPORT_SET_THERM_ALERT_LIMIT, + NVGPU_SUPPORT_SET_THERM_ALERT_LIMIT}, + {NVGPU_GPU_FLAGS_SUPPORT_DEVICE_EVENTS, + NVGPU_SUPPORT_DEVICE_EVENTS}, + {NVGPU_GPU_FLAGS_SUPPORT_FECS_CTXSW_TRACE, + NVGPU_SUPPORT_FECS_CTXSW_TRACE}, + {NVGPU_GPU_FLAGS_SUPPORT_DETERMINISTIC_SUBMIT_NO_JOBTRACKING, + NVGPU_SUPPORT_DETERMINISTIC_SUBMIT_NO_JOBTRACKING}, + {NVGPU_GPU_FLAGS_SUPPORT_DETERMINISTIC_SUBMIT_FULL, + NVGPU_SUPPORT_DETERMINISTIC_SUBMIT_FULL}, + {NVGPU_GPU_FLAGS_SUPPORT_IO_COHERENCE, + NVGPU_SUPPORT_IO_COHERENCE}, + {NVGPU_GPU_FLAGS_SUPPORT_RESCHEDULE_RUNLIST, + NVGPU_SUPPORT_RESCHEDULE_RUNLIST}, + {NVGPU_GPU_FLAGS_SUPPORT_MAP_DIRECT_KIND_CTRL, + NVGPU_SUPPORT_MAP_DIRECT_KIND_CTRL}, + {NVGPU_GPU_FLAGS_ECC_ENABLED_SM_LRF, + NVGPU_ECC_ENABLED_SM_LRF}, + {NVGPU_GPU_FLAGS_ECC_ENABLED_SM_SHM, + NVGPU_ECC_ENABLED_SM_SHM}, + {NVGPU_GPU_FLAGS_ECC_ENABLED_TEX, + NVGPU_ECC_ENABLED_TEX}, + {NVGPU_GPU_FLAGS_ECC_ENABLED_LTC, + NVGPU_ECC_ENABLED_LTC}, +}; + +static u64 nvgpu_ctrl_ioctl_gpu_characteristics_flags(struct gk20a *g) +{ + unsigned int i; + u64 ioctl_flags = 0; + + for (i = 0; i < sizeof(flags_mapping)/sizeof(*flags_mapping); i++) { + if (nvgpu_is_enabled(g, flags_mapping[i].enabled_flag)) + ioctl_flags |= flags_mapping[i].ioctl_flag; + } + + return ioctl_flags; +} + static long gk20a_ctrl_ioctl_gpu_characteristics( struct gk20a *g, @@ -121,6 +197,11 @@ gk20a_ctrl_ioctl_gpu_characteristics( struct nvgpu_gpu_characteristics *pgpu = &g->gpu_characteristics; long err = 0; + pgpu->flags = nvgpu_ctrl_ioctl_gpu_characteristics_flags(g); +#ifdef CONFIG_TEGRA_19x_GPU + pgpu->flags |= nvgpu_ctrl_ioctl_gpu_characteristics_flags_t19x(g); +#endif + if (request->gpu_characteristics_buf_size > 0) { size_t write_size = sizeof(*pgpu); @@ -1108,7 +1189,7 @@ static int nvgpu_gpu_get_voltage(struct gk20a *g, if (args->reserved) return -EINVAL; - if (!(g->gpu_characteristics.flags & NVGPU_GPU_FLAGS_SUPPORT_GET_VOLTAGE)) + if (!nvgpu_is_enabled(g, NVGPU_SUPPORT_GET_VOLTAGE)) return -EINVAL; err = gk20a_busy(g); @@ -1144,7 +1225,7 @@ static int nvgpu_gpu_get_current(struct gk20a *g, if (args->reserved[0] || args->reserved[1] || args->reserved[2]) return -EINVAL; - if (!(g->gpu_characteristics.flags & NVGPU_GPU_FLAGS_SUPPORT_GET_CURRENT)) + if (!nvgpu_is_enabled(g, NVGPU_SUPPORT_GET_CURRENT)) return -EINVAL; err = gk20a_busy(g); @@ -1168,7 +1249,7 @@ static int nvgpu_gpu_get_power(struct gk20a *g, if (args->reserved[0] || args->reserved[1] || args->reserved[2]) return -EINVAL; - if (!(g->gpu_characteristics.flags & NVGPU_GPU_FLAGS_SUPPORT_GET_POWER)) + if (!nvgpu_is_enabled(g, NVGPU_SUPPORT_GET_POWER)) return -EINVAL; err = gk20a_busy(g); diff --git a/drivers/gpu/nvgpu/common/mm/vm.c b/drivers/gpu/nvgpu/common/mm/vm.c index c6c99b31..88af6456 100644 --- a/drivers/gpu/nvgpu/common/mm/vm.c +++ b/drivers/gpu/nvgpu/common/mm/vm.c @@ -175,7 +175,7 @@ static int nvgpu_init_sema_pool(struct vm_gk20a *vm) /* * Don't waste the memory on semaphores if we don't need them. */ - if (g->gpu_characteristics.flags & NVGPU_GPU_FLAGS_HAS_SYNCPOINTS) + if (nvgpu_is_enabled(g, NVGPU_HAS_SYNCPOINTS)) return 0; if (vm->sema_pool) @@ -520,7 +520,7 @@ static void __nvgpu_vm_remove(struct vm_gk20a *vm) * pool involves unmapping a GMMU mapping which means aquiring the * update_gmmu_lock. */ - if (!(g->gpu_characteristics.flags & NVGPU_GPU_FLAGS_HAS_SYNCPOINTS)) { + if (!nvgpu_is_enabled(g, NVGPU_HAS_SYNCPOINTS)) { if (vm->sema_pool) { nvgpu_semaphore_pool_unmap(vm->sema_pool, vm); nvgpu_semaphore_pool_put(vm->sema_pool); diff --git a/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c b/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c index 12d7dcb9..1517d25a 100644 --- a/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c @@ -33,6 +33,7 @@ #include #include #include +#include #include "ctxsw_trace_gk20a.h" #include "fecs_trace_gk20a.h" @@ -594,8 +595,7 @@ int gk20a_fecs_trace_init(struct gk20a *g) hash_init(trace->pid_hash_table); - g->gpu_characteristics.flags |= - NVGPU_GPU_FLAGS_SUPPORT_FECS_CTXSW_TRACE; + __nvgpu_set_enabled(g, NVGPU_SUPPORT_FECS_CTXSW_TRACE, true); gk20a_fecs_trace_debugfs_init(g); diff --git a/drivers/gpu/nvgpu/gk20a/gk20a.c b/drivers/gpu/nvgpu/gk20a/gk20a.c index e3c2397c..2b99b52c 100644 --- a/drivers/gpu/nvgpu/gk20a/gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/gk20a.c @@ -417,24 +417,26 @@ int gk20a_init_gpu_characteristics(struct gk20a *g) gpu->available_big_page_sizes |= g->ops.mm.get_big_page_sizes(); } - gpu->flags = NVGPU_GPU_FLAGS_SUPPORT_PARTIAL_MAPPINGS | - NVGPU_GPU_FLAGS_SUPPORT_MAP_DIRECT_KIND_CTRL; + __nvgpu_set_enabled(g, NVGPU_SUPPORT_PARTIAL_MAPPINGS, true); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_MAP_DIRECT_KIND_CTRL, true); if (IS_ENABLED(CONFIG_SYNC)) - gpu->flags |= NVGPU_GPU_FLAGS_SUPPORT_SYNC_FENCE_FDS; + __nvgpu_set_enabled(g, NVGPU_SUPPORT_SYNC_FENCE_FDS, true); if (g->ops.mm.support_sparse && g->ops.mm.support_sparse(g)) - gpu->flags |= NVGPU_GPU_FLAGS_SUPPORT_SPARSE_ALLOCS; + __nvgpu_set_enabled(g, NVGPU_SUPPORT_SPARSE_ALLOCS, true); if (gk20a_platform_has_syncpoints(g)) - gpu->flags |= NVGPU_GPU_FLAGS_HAS_SYNCPOINTS; + __nvgpu_set_enabled(g, NVGPU_HAS_SYNCPOINTS, true); /* * Fast submits are supported as long as the user doesn't request * anything that depends on job tracking. (Here, fast means strictly no * metadata, just the gpfifo contents are copied and gp_put updated). */ - gpu->flags |= NVGPU_GPU_FLAGS_SUPPORT_DETERMINISTIC_SUBMIT_NO_JOBTRACKING; + __nvgpu_set_enabled(g, + NVGPU_SUPPORT_DETERMINISTIC_SUBMIT_NO_JOBTRACKING, + true); /* * Sync framework requires deferred job cleanup, wrapping syncs in FDs, @@ -443,13 +445,15 @@ int gk20a_init_gpu_characteristics(struct gk20a *g) * that depends on deferred cleanup. */ if (!gk20a_channel_sync_needs_sync_framework(g)) - gpu->flags |= NVGPU_GPU_FLAGS_SUPPORT_DETERMINISTIC_SUBMIT_FULL; + __nvgpu_set_enabled(g, + NVGPU_SUPPORT_DETERMINISTIC_SUBMIT_FULL, + true); - gpu->flags |= NVGPU_GPU_FLAGS_SUPPORT_USERSPACE_MANAGED_AS; - gpu->flags |= NVGPU_GPU_FLAGS_SUPPORT_TSG; + __nvgpu_set_enabled(g, NVGPU_SUPPORT_USERSPACE_MANAGED_AS, true); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_TSG, true); if (g->ops.clk_arb.get_arbiter_clk_domains) - gpu->flags |= NVGPU_GPU_FLAGS_SUPPORT_CLOCK_CONTROLS; + __nvgpu_set_enabled(g, NVGPU_SUPPORT_CLOCK_CONTROLS, true); gpu->gpc_mask = (1 << g->gr.gpc_count)-1; diff --git a/drivers/gpu/nvgpu/gm20b/gr_gm20b.c b/drivers/gpu/nvgpu/gm20b/gr_gm20b.c index c10517b7..7ec8e2cb 100644 --- a/drivers/gpu/nvgpu/gm20b/gr_gm20b.c +++ b/drivers/gpu/nvgpu/gm20b/gr_gm20b.c @@ -1126,10 +1126,8 @@ u32 gr_gm20b_get_max_fbps_count(struct gk20a *g) void gr_gm20b_init_cyclestats(struct gk20a *g) { #if defined(CONFIG_GK20A_CYCLE_STATS) - g->gpu_characteristics.flags |= - NVGPU_GPU_FLAGS_SUPPORT_CYCLE_STATS; - g->gpu_characteristics.flags |= - NVGPU_GPU_FLAGS_SUPPORT_CYCLE_STATS_SNAPSHOT; + __nvgpu_set_enabled(g, NVGPU_SUPPORT_CYCLE_STATS, true); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_CYCLE_STATS_SNAPSHOT, true); g->gpu_characteristics.max_css_buffer_size = 0xffffffff; #else (void)g; diff --git a/drivers/gpu/nvgpu/gp106/hal_gp106.c b/drivers/gpu/nvgpu/gp106/hal_gp106.c index 1e81796e..c5b62948 100644 --- a/drivers/gpu/nvgpu/gp106/hal_gp106.c +++ b/drivers/gpu/nvgpu/gp106/hal_gp106.c @@ -189,26 +189,24 @@ static int gp106_get_litter_value(struct gk20a *g, int value) static int gp106_init_gpu_characteristics(struct gk20a *g) { - struct nvgpu_gpu_characteristics *gpu = &g->gpu_characteristics; - int err; err = gk20a_init_gpu_characteristics(g); if (err) return err; - gpu->flags |= NVGPU_GPU_FLAGS_SUPPORT_GET_VOLTAGE | - NVGPU_GPU_FLAGS_SUPPORT_GET_CURRENT | - NVGPU_GPU_FLAGS_SUPPORT_GET_POWER | - NVGPU_GPU_FLAGS_SUPPORT_GET_TEMPERATURE | - NVGPU_GPU_FLAGS_SUPPORT_DEVICE_EVENTS | - NVGPU_GPU_FLAGS_SUPPORT_SET_THERM_ALERT_LIMIT; + __nvgpu_set_enabled(g, NVGPU_SUPPORT_GET_VOLTAGE, true); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_GET_CURRENT, true); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_GET_POWER, true); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_GET_TEMPERATURE, true); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_DEVICE_EVENTS, true); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_SET_THERM_ALERT_LIMIT, true); /* WAR for missing INA3221 on HW2.5 RevA */ if (g->power_sensor_missing) { - gpu->flags &= ~(NVGPU_GPU_FLAGS_SUPPORT_GET_VOLTAGE | - NVGPU_GPU_FLAGS_SUPPORT_GET_CURRENT | - NVGPU_GPU_FLAGS_SUPPORT_GET_POWER); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_GET_VOLTAGE, false); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_GET_CURRENT, false); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_GET_POWER, false); } return 0; diff --git a/drivers/gpu/nvgpu/gp10b/gp10b.c b/drivers/gpu/nvgpu/gp10b/gp10b.c index 769d6ef3..51dc4301 100644 --- a/drivers/gpu/nvgpu/gp10b/gp10b.c +++ b/drivers/gpu/nvgpu/gp10b/gp10b.c @@ -24,14 +24,15 @@ #include "gk20a/gk20a.h" +#include + #include "gp10b.h" #include #include -static u64 gp10b_detect_ecc_enabled_units(struct gk20a *g) +static void gp10b_detect_ecc_enabled_units(struct gk20a *g) { - u64 ecc_enabled_units = 0; u32 opt_ecc_en = gk20a_readl(g, fuse_opt_ecc_en_r()); u32 opt_feature_fuses_override_disable = gk20a_readl(g, @@ -41,23 +42,25 @@ static u64 gp10b_detect_ecc_enabled_units(struct gk20a *g) gr_fecs_feature_override_ecc_r()); if (opt_feature_fuses_override_disable) { - if (opt_ecc_en) - ecc_enabled_units = NVGPU_GPU_FLAGS_ALL_ECC_ENABLED; - else - ecc_enabled_units = 0; + if (opt_ecc_en) { + __nvgpu_set_enabled(g, NVGPU_ECC_ENABLED_SM_LRF, true); + __nvgpu_set_enabled(g, NVGPU_ECC_ENABLED_SM_SHM, true); + __nvgpu_set_enabled(g, NVGPU_ECC_ENABLED_TEX, true); + __nvgpu_set_enabled(g, NVGPU_ECC_ENABLED_LTC, true); + } } else { /* SM LRF */ if (gr_fecs_feature_override_ecc_sm_lrf_override_v( fecs_feature_override_ecc)) { if (gr_fecs_feature_override_ecc_sm_lrf_v( fecs_feature_override_ecc)) { - ecc_enabled_units |= - NVGPU_GPU_FLAGS_ECC_ENABLED_SM_LRF; + __nvgpu_set_enabled(g, + NVGPU_ECC_ENABLED_SM_LRF, true); } } else { if (opt_ecc_en) { - ecc_enabled_units |= - NVGPU_GPU_FLAGS_ECC_ENABLED_SM_LRF; + __nvgpu_set_enabled(g, + NVGPU_ECC_ENABLED_SM_LRF, true); } } @@ -66,13 +69,13 @@ static u64 gp10b_detect_ecc_enabled_units(struct gk20a *g) fecs_feature_override_ecc)) { if (gr_fecs_feature_override_ecc_sm_shm_v( fecs_feature_override_ecc)) { - ecc_enabled_units |= - NVGPU_GPU_FLAGS_ECC_ENABLED_SM_SHM; + __nvgpu_set_enabled(g, + NVGPU_ECC_ENABLED_SM_SHM, true); } } else { if (opt_ecc_en) { - ecc_enabled_units |= - NVGPU_GPU_FLAGS_ECC_ENABLED_SM_SHM; + __nvgpu_set_enabled(g, + NVGPU_ECC_ENABLED_SM_SHM, true); } } @@ -81,13 +84,13 @@ static u64 gp10b_detect_ecc_enabled_units(struct gk20a *g) fecs_feature_override_ecc)) { if (gr_fecs_feature_override_ecc_tex_v( fecs_feature_override_ecc)) { - ecc_enabled_units |= - NVGPU_GPU_FLAGS_ECC_ENABLED_TEX; + __nvgpu_set_enabled(g, + NVGPU_ECC_ENABLED_TEX, true); } } else { if (opt_ecc_en) { - ecc_enabled_units |= - NVGPU_GPU_FLAGS_ECC_ENABLED_TEX; + __nvgpu_set_enabled(g, + NVGPU_ECC_ENABLED_TEX, true); } } @@ -96,25 +99,22 @@ static u64 gp10b_detect_ecc_enabled_units(struct gk20a *g) fecs_feature_override_ecc)) { if (gr_fecs_feature_override_ecc_ltc_v( fecs_feature_override_ecc)) { - ecc_enabled_units |= - NVGPU_GPU_FLAGS_ECC_ENABLED_LTC; + __nvgpu_set_enabled(g, + NVGPU_ECC_ENABLED_LTC, true); } } else { if (opt_ecc_en) { - ecc_enabled_units |= - NVGPU_GPU_FLAGS_ECC_ENABLED_LTC; + __nvgpu_set_enabled(g, + NVGPU_ECC_ENABLED_LTC, true); } } } - - return ecc_enabled_units; } int gp10b_init_gpu_characteristics(struct gk20a *g) { gk20a_init_gpu_characteristics(g); - g->gpu_characteristics.flags |= gp10b_detect_ecc_enabled_units(g); - g->gpu_characteristics.flags |= - NVGPU_GPU_FLAGS_SUPPORT_RESCHEDULE_RUNLIST; + gp10b_detect_ecc_enabled_units(g); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_RESCHEDULE_RUNLIST, true); return 0; } diff --git a/drivers/gpu/nvgpu/gp10b/gr_gp10b.c b/drivers/gpu/nvgpu/gp10b/gr_gp10b.c index a01cfbfa..a6d72907 100644 --- a/drivers/gpu/nvgpu/gp10b/gr_gp10b.c +++ b/drivers/gpu/nvgpu/gp10b/gr_gp10b.c @@ -32,6 +32,7 @@ #include #include #include +#include #include "gk20a/gk20a.h" #include "gk20a/gr_gk20a.h" diff --git a/drivers/gpu/nvgpu/include/nvgpu/enabled.h b/drivers/gpu/nvgpu/include/nvgpu/enabled.h index 8c0bb9d3..87449ccc 100644 --- a/drivers/gpu/nvgpu/include/nvgpu/enabled.h +++ b/drivers/gpu/nvgpu/include/nvgpu/enabled.h @@ -34,6 +34,18 @@ struct gk20a; #define NVGPU_IS_FMODEL 1 #define NVGPU_DRIVER_IS_DYING 2 #define NVGPU_GR_USE_DMA_FOR_FW_BOOTSTRAP 3 + +/* + * ECC flags + */ +/* SM LRF ECC is enabled */ +#define NVGPU_ECC_ENABLED_SM_LRF 8 +/* SM SHM ECC is enabled */ +#define NVGPU_ECC_ENABLED_SM_SHM 9 +/* TEX ECC is enabled */ +#define NVGPU_ECC_ENABLED_TEX 10 +/* L2 ECC is enabled */ +#define NVGPU_ECC_ENABLED_LTC 11 /* * MM flags. */ @@ -44,13 +56,47 @@ struct gk20a; #define NVGPU_MM_UNIFIED_MEMORY 18 /* kernel mode ce vidmem clearing channels need to be in a tsg */ #define NVGPU_MM_CE_TSG_REQUIRED 19 +/* User-space managed address spaces support */ +#define NVGPU_SUPPORT_USERSPACE_MANAGED_AS 20 +/* IO coherence support is available */ +#define NVGPU_SUPPORT_IO_COHERENCE 21 +/* MAP_BUFFER_EX with partial mappings */ +#define NVGPU_SUPPORT_PARTIAL_MAPPINGS 22 +/* MAP_BUFFER_EX with sparse allocations */ +#define NVGPU_SUPPORT_SPARSE_ALLOCS 23 +/* Direct PTE kind control is supported (map_buffer_ex) */ +#define NVGPU_SUPPORT_MAP_DIRECT_KIND_CTRL 24 + +/* + * Host flags + */ +#define NVGPU_HAS_SYNCPOINTS 30 +/* sync fence FDs are available in, e.g., submit_gpfifo */ +#define NVGPU_SUPPORT_SYNC_FENCE_FDS 31 +/* NVGPU_IOCTL_CHANNEL_CYCLE_STATS is available */ +#define NVGPU_SUPPORT_CYCLE_STATS 32 +/* NVGPU_IOCTL_CHANNEL_CYCLE_STATS_SNAPSHOT is available */ +#define NVGPU_SUPPORT_CYCLE_STATS_SNAPSHOT 33 +/* Both gpu driver and device support TSG */ +#define NVGPU_SUPPORT_TSG 33 +/* Fast deterministic submits with no job tracking are supported */ +#define NVGPU_SUPPORT_DETERMINISTIC_SUBMIT_NO_JOBTRACKING 34 +/* Deterministic submits are supported even with job tracking */ +#define NVGPU_SUPPORT_DETERMINISTIC_SUBMIT_FULL 35 +/* NVGPU_SUBMIT_GPFIFO_FLAGS_RESCHEDULE_RUNLIST is available */ +#define NVGPU_SUPPORT_RESCHEDULE_RUNLIST 36 + +/* NVGPU_GPU_IOCTL_GET_EVENT_FD is available */ +#define NVGPU_SUPPORT_DEVICE_EVENTS 37 +/* FECS context switch tracing is available */ +#define NVGPU_SUPPORT_FECS_CTXSW_TRACE 38 /* * Security flags */ -#define NVGPU_SEC_SECUREGPCCS 32 -#define NVGPU_SEC_PRIVSECURITY 33 +#define NVGPU_SEC_SECUREGPCCS 40 +#define NVGPU_SEC_PRIVSECURITY 41 /* * PMU flags. @@ -63,9 +109,21 @@ struct gk20a; #define NVGPU_GPU_CAN_BLCG 52 #define NVGPU_GPU_CAN_SLCG 53 #define NVGPU_GPU_CAN_ELCG 54 +/* Clock control support */ +#define NVGPU_SUPPORT_CLOCK_CONTROLS 55 +/* NVGPU_GPU_IOCTL_GET_VOLTAGE is available */ +#define NVGPU_SUPPORT_GET_VOLTAGE 56 +/* NVGPU_GPU_IOCTL_GET_CURRENT is available */ +#define NVGPU_SUPPORT_GET_CURRENT 57 +/* NVGPU_GPU_IOCTL_GET_POWER is available */ +#define NVGPU_SUPPORT_GET_POWER 58 +/* NVGPU_GPU_IOCTL_GET_TEMPERATURE is available */ +#define NVGPU_SUPPORT_GET_TEMPERATURE 59 +/* NVGPU_GPU_IOCTL_SET_THERM_ALERT_LIMIT is available */ +#define NVGPU_SUPPORT_SET_THERM_ALERT_LIMIT 60 /* whether to run PREOS binary on dGPUs */ -#define NVGPU_PMU_RUN_PREOS 52 +#define NVGPU_PMU_RUN_PREOS 61 /* * Must be greater than the largest bit offset in the above list. diff --git a/drivers/gpu/nvgpu/vgpu/fecs_trace_vgpu.c b/drivers/gpu/nvgpu/vgpu/fecs_trace_vgpu.c index 762cc10a..72f2ae8b 100644 --- a/drivers/gpu/nvgpu/vgpu/fecs_trace_vgpu.c +++ b/drivers/gpu/nvgpu/vgpu/fecs_trace_vgpu.c @@ -26,6 +26,7 @@ #include #include +#include #include "gk20a/gk20a.h" #include "gk20a/ctxsw_trace_gk20a.h" @@ -63,8 +64,7 @@ int vgpu_fecs_trace_init(struct gk20a *g) dev_info(dev_from_gk20a(g), "does not support fecs trace\n"); goto fail; } - g->gpu_characteristics.flags |= - NVGPU_GPU_FLAGS_SUPPORT_FECS_CTXSW_TRACE; + __nvgpu_set_enabled(g, NVGPU_SUPPORT_FECS_CTXSW_TRACE, true); hv_np = args.np; mempool = args.args[0]; diff --git a/drivers/gpu/nvgpu/vgpu/vgpu.c b/drivers/gpu/nvgpu/vgpu/vgpu.c index 84034b38..f0f05637 100644 --- a/drivers/gpu/nvgpu/vgpu/vgpu.c +++ b/drivers/gpu/nvgpu/vgpu/vgpu.c @@ -370,10 +370,8 @@ int vgpu_init_gpu_characteristics(struct gk20a *g) g->gpu_characteristics.map_buffer_batch_limit = 0; /* features vgpu does not support */ - g->gpu_characteristics.flags &= ~NVGPU_GPU_FLAGS_SUPPORT_CYCLE_STATS; - g->gpu_characteristics.flags &= ~NVGPU_GPU_FLAGS_SUPPORT_MAP_COMPBITS; - g->gpu_characteristics.flags &= - ~NVGPU_GPU_FLAGS_SUPPORT_RESCHEDULE_RUNLIST; + __nvgpu_set_enabled(g, NVGPU_SUPPORT_CYCLE_STATS, false); + __nvgpu_set_enabled(g, NVGPU_SUPPORT_RESCHEDULE_RUNLIST, false); return 0; } -- cgit v1.2.2