drivers/gpu/nvgpu/gk20a/gk20a.h

   1 /*
   2  * GK20A Graphics
   3  *
   4  * Copyright (c) 2011-2015, NVIDIA CORPORATION.  All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 #ifndef GK20A_H
  19 #define GK20A_H
  20
  21
  22 struct gk20a;
  23 struct fifo_gk20a;
  24 struct channel_gk20a;
  25 struct gr_gk20a;
  26 struct sim_gk20a;
  27 struct gk20a_ctxsw_ucode_segments;
  28 struct acr_gm20b;
  29
  30 #include <linux/sched.h>
  31 #include <linux/spinlock.h>
  32 #include <linux/nvgpu.h>
  33 #include <linux/irqreturn.h>
  34 #include <linux/tegra-soc.h>
  35
  36 #include "../../../arch/arm/mach-tegra/iomap.h"
  37
  38 #include "as_gk20a.h"
  39 #include "clk_gk20a.h"
  40 #include "ce2_gk20a.h"
  41 #include "fifo_gk20a.h"
  42 #include "tsg_gk20a.h"
  43 #include "gr_gk20a.h"
  44 #include "sim_gk20a.h"
  45 #include "pmu_gk20a.h"
  46 #include "priv_ring_gk20a.h"
  47 #include "therm_gk20a.h"
  48 #include "platform_gk20a.h"
  49 #include "gm20b/acr_gm20b.h"
  50 #include "cde_gk20a.h"
  51 #include "debug_gk20a.h"
  52
  53 struct cooling_device_gk20a {
  54         struct thermal_cooling_device *gk20a_cooling_dev;
  55         unsigned int gk20a_freq_state;
  56         unsigned int gk20a_freq_table_size;
  57         struct gk20a *g;
  58 };
  59
  60 enum gk20a_cbc_op {
  61         gk20a_cbc_op_clear,
  62         gk20a_cbc_op_clean,
  63         gk20a_cbc_op_invalidate,
  64 };
  65
  66 #define MC_INTR_UNIT_DISABLE    false
  67 #define MC_INTR_UNIT_ENABLE             true
  68
  69 struct gpu_ops {
  70         struct {
  71                 int (*determine_L2_size_bytes)(struct gk20a *gk20a);
  72                 void (*set_max_ways_evict_last)(struct gk20a *g, u32 max_ways);
  73                 int (*init_comptags)(struct gk20a *g, struct gr_gk20a *gr);
  74                 int (*cbc_ctrl)(struct gk20a *g, enum gk20a_cbc_op op,
  75                                 u32 min, u32 max);
  76                 void (*set_zbc_color_entry)(struct gk20a *g,
  77                                             struct zbc_entry *color_val,
  78                                             u32 index);
  79                 void (*set_zbc_depth_entry)(struct gk20a *g,
  80                                             struct zbc_entry *depth_val,
  81                                             u32 index);
  82                 void (*init_cbc)(struct gk20a *g, struct gr_gk20a *gr);
  83                 void (*sync_debugfs)(struct gk20a *g);
  84                 void (*init_fs_state)(struct gk20a *g);
  85                 void (*elpg_flush)(struct gk20a *g);
  86                 void (*isr)(struct gk20a *g);
  87                 u32 (*cbc_fix_config)(struct gk20a *g, int base);
  88                 void (*flush)(struct gk20a *g);
  89         } ltc;
  90         struct {
  91                 void (*isr_stall)(struct gk20a *g);
  92                 void (*isr_nonstall)(struct gk20a *g);
  93         } ce2;
  94         struct {
  95                 int (*init_fs_state)(struct gk20a *g);
  96                 void (*access_smpc_reg)(struct gk20a *g, u32 quad, u32 offset);
  97                 void (*bundle_cb_defaults)(struct gk20a *g);
  98                 void (*cb_size_default)(struct gk20a *g);
  99                 int (*calc_global_ctx_buffer_size)(struct gk20a *g);
 100                 void (*commit_global_attrib_cb)(struct gk20a *g,
 101                                                 struct channel_ctx_gk20a *ch_ctx,
 102                                                 u64 addr, bool patch);
 103                 void (*commit_global_bundle_cb)(struct gk20a *g,
 104                                                 struct channel_ctx_gk20a *ch_ctx,
 105                                                 u64 addr, u64 size, bool patch);
 106                 int (*commit_global_cb_manager)(struct gk20a *g,
 107                                                 struct channel_gk20a *ch,
 108                                                 bool patch);
 109                 void (*commit_global_pagepool)(struct gk20a *g,
 110                                                struct channel_ctx_gk20a *ch_ctx,
 111                                                u64 addr, u32 size, bool patch);
 112                 void (*init_gpc_mmu)(struct gk20a *g);
 113                 int (*handle_sw_method)(struct gk20a *g, u32 addr,
 114                                          u32 class_num, u32 offset, u32 data);
 115                 void (*set_alpha_circular_buffer_size)(struct gk20a *g,
 116                                                        u32 data);
 117                 void (*set_circular_buffer_size)(struct gk20a *g, u32 data);
 118                 void (*enable_hww_exceptions)(struct gk20a *g);
 119                 bool (*is_valid_class)(struct gk20a *g, u32 class_num);
 120                 void (*get_sm_dsm_perf_regs)(struct gk20a *g,
 121                                                   u32 *num_sm_dsm_perf_regs,
 122                                                   u32 **sm_dsm_perf_regs,
 123                                                   u32 *perf_register_stride);
 124                 void (*get_sm_dsm_perf_ctrl_regs)(struct gk20a *g,
 125                                                   u32 *num_sm_dsm_perf_regs,
 126                                                   u32 **sm_dsm_perf_regs,
 127                                                   u32 *perf_register_stride);
 128                 void (*set_hww_esr_report_mask)(struct gk20a *g);
 129                 int (*setup_alpha_beta_tables)(struct gk20a *g,
 130                                               struct gr_gk20a *gr);
 131                 int (*falcon_load_ucode)(struct gk20a *g,
 132                                 u64 addr_base,
 133                                 struct gk20a_ctxsw_ucode_segments *segments,
 134                                 u32 reg_offset);
 135                 int (*load_ctxsw_ucode)(struct gk20a *g);
 136                 u32 (*get_gpc_tpc_mask)(struct gk20a *g, u32 gpc_index);
 137                 void (*set_gpc_tpc_mask)(struct gk20a *g, u32 gpc_index);
 138                 void (*free_channel_ctx)(struct channel_gk20a *c);
 139                 int (*alloc_obj_ctx)(struct channel_gk20a  *c,
 140                                 struct nvgpu_alloc_obj_ctx_args *args);
 141                 int (*free_obj_ctx)(struct channel_gk20a  *c,
 142                                 struct nvgpu_free_obj_ctx_args *args);
 143                 int (*bind_ctxsw_zcull)(struct gk20a *g, struct gr_gk20a *gr,
 144                                 struct channel_gk20a *c, u64 zcull_va,
 145                                 u32 mode);
 146                 int (*get_zcull_info)(struct gk20a *g, struct gr_gk20a *gr,
 147                                 struct gr_zcull_info *zcull_params);
 148                 bool (*is_tpc_addr)(u32 addr);
 149                 u32 (*get_tpc_num)(u32 addr);
 150                 void (*detect_sm_arch)(struct gk20a *g);
 151                 int (*add_zbc_color)(struct gk20a *g, struct gr_gk20a *gr,
 152                                   struct zbc_entry *color_val, u32 index);
 153                 int (*add_zbc_depth)(struct gk20a *g, struct gr_gk20a *gr,
 154                                   struct zbc_entry *depth_val, u32 index);
 155                 int (*zbc_set_table)(struct gk20a *g, struct gr_gk20a *gr,
 156                                 struct zbc_entry *zbc_val);
 157                 int (*zbc_query_table)(struct gk20a *g, struct gr_gk20a *gr,
 158                                 struct zbc_query_params *query_params);
 159                 u32 (*pagepool_default_size)(struct gk20a *g);
 160                 int (*init_ctx_state)(struct gk20a *g);
 161                 int (*alloc_gr_ctx)(struct gk20a *g,
 162                           struct gr_ctx_desc **__gr_ctx, struct vm_gk20a *vm,
 163                           u32 class, u32 padding);
 164                 void (*free_gr_ctx)(struct gk20a *g,
 165                           struct vm_gk20a *vm,
 166                           struct gr_ctx_desc *gr_ctx);
 167                 void (*update_ctxsw_preemption_mode)(struct gk20a *g,
 168                                 struct channel_ctx_gk20a *ch_ctx,
 169                                 void *ctx_ptr);
 170                 int (*dump_gr_regs)(struct gk20a *g,
 171                                 struct gk20a_debug_output *o);
 172                 int (*update_pc_sampling)(struct channel_gk20a *ch,
 173                                            bool enable);
 174                 u32 (*get_max_fbps_count)(struct gk20a *g);
 175                 u32 (*get_fbp_en_mask)(struct gk20a *g);
 176                 u32 (*get_max_ltc_per_fbp)(struct gk20a *g);
 177                 u32 (*get_max_lts_per_ltc)(struct gk20a *g);
 178                 u32* (*get_rop_l2_en_mask)(struct gk20a *g);
 179                 void (*init_sm_dsm_reg_info)(void);
 180                 int (*wait_empty)(struct gk20a *g, unsigned long end_jiffies,
 181                        u32 expect_delay);
 182                 void (*init_cyclestats)(struct gk20a *g);
 183                 void (*enable_cde_in_fecs)(void *ctx_ptr);
 184         } gr;
 185         const char *name;
 186         struct {
 187                 void (*init_fs_state)(struct gk20a *g);
 188                 void (*reset)(struct gk20a *g);
 189                 void (*init_uncompressed_kind_map)(struct gk20a *g);
 190                 void (*init_kind_attr)(struct gk20a *g);
 191                 void (*set_mmu_page_size)(struct gk20a *g);
 192                 bool (*set_use_full_comp_tag_line)(struct gk20a *g);
 193                 int (*compression_page_size)(struct gk20a *g);
 194                 int (*compressible_page_size)(struct gk20a *g);
 195                 void (*dump_vpr_wpr_info)(struct gk20a *g);
 196         } fb;
 197         struct {
 198                 void (*slcg_bus_load_gating_prod)(struct gk20a *g, bool prod);
 199                 void (*slcg_ce2_load_gating_prod)(struct gk20a *g, bool prod);
 200                 void (*slcg_chiplet_load_gating_prod)(struct gk20a *g, bool prod);
 201                 void (*slcg_ctxsw_firmware_load_gating_prod)(struct gk20a *g, bool prod);
 202                 void (*slcg_fb_load_gating_prod)(struct gk20a *g, bool prod);
 203                 void (*slcg_fifo_load_gating_prod)(struct gk20a *g, bool prod);
 204                 void (*slcg_gr_load_gating_prod)(struct gk20a *g, bool prod);
 205                 void (*slcg_ltc_load_gating_prod)(struct gk20a *g, bool prod);
 206                 void (*slcg_perf_load_gating_prod)(struct gk20a *g, bool prod);
 207                 void (*slcg_priring_load_gating_prod)(struct gk20a *g, bool prod);
 208                 void (*slcg_pmu_load_gating_prod)(struct gk20a *g, bool prod);
 209                 void (*slcg_therm_load_gating_prod)(struct gk20a *g, bool prod);
 210                 void (*slcg_xbar_load_gating_prod)(struct gk20a *g, bool prod);
 211                 void (*blcg_bus_load_gating_prod)(struct gk20a *g, bool prod);
 212                 void (*blcg_ctxsw_firmware_load_gating_prod)(struct gk20a *g, bool prod);
 213                 void (*blcg_fb_load_gating_prod)(struct gk20a *g, bool prod);
 214                 void (*blcg_fifo_load_gating_prod)(struct gk20a *g, bool prod);
 215                 void (*blcg_gr_load_gating_prod)(struct gk20a *g, bool prod);
 216                 void (*blcg_ltc_load_gating_prod)(struct gk20a *g, bool prod);
 217                 void (*blcg_pwr_csb_load_gating_prod)(struct gk20a *g, bool prod);
 218                 void (*blcg_pmu_load_gating_prod)(struct gk20a *g, bool prod);
 219                 void (*pg_gr_load_gating_prod)(struct gk20a *g, bool prod);
 220         } clock_gating;
 221         struct {
 222                 void (*bind_channel)(struct channel_gk20a *ch_gk20a);
 223                 void (*unbind_channel)(struct channel_gk20a *ch_gk20a);
 224                 void (*disable_channel)(struct channel_gk20a *ch);
 225                 int (*alloc_inst)(struct gk20a *g, struct channel_gk20a *ch);
 226                 void (*free_inst)(struct gk20a *g, struct channel_gk20a *ch);
 227                 int (*setup_ramfc)(struct channel_gk20a *c, u64 gpfifo_base,
 228                                 u32 gpfifo_entries, u32 flags);
 229                 int (*resetup_ramfc)(struct channel_gk20a *c);
 230                 int (*preempt_channel)(struct gk20a *g, u32 hw_chid);
 231                 int (*update_runlist)(struct gk20a *g, u32 runlist_id,
 232                                 u32 hw_chid, bool add,
 233                                 bool wait_for_finish);
 234                 void (*trigger_mmu_fault)(struct gk20a *g,
 235                                 unsigned long engine_ids);
 236                 void (*apply_pb_timeout)(struct gk20a *g);
 237                 int (*wait_engine_idle)(struct gk20a *g);
 238                 u32 (*get_num_fifos)(struct gk20a *g);
 239                 u32 (*get_pbdma_signature)(struct gk20a *g);
 240         } fifo;
 241         struct pmu_v {
 242                 /*used for change of enum zbc update cmd id from ver 0 to ver1*/
 243                 u32 cmd_id_zbc_table_update;
 244                 u32 (*get_pmu_cmdline_args_size)(struct pmu_gk20a *pmu);
 245                 void (*set_pmu_cmdline_args_cpu_freq)(struct pmu_gk20a *pmu,
 246                         u32 freq);
 247                 void (*set_pmu_cmdline_args_trace_size)(struct pmu_gk20a *pmu,
 248                         u32 size);
 249                 void (*set_pmu_cmdline_args_trace_dma_base)(
 250                                 struct pmu_gk20a *pmu);
 251                 void (*set_pmu_cmdline_args_trace_dma_idx)(
 252                         struct pmu_gk20a *pmu, u32 idx);
 253                 void * (*get_pmu_cmdline_args_ptr)(struct pmu_gk20a *pmu);
 254                 u32 (*get_pmu_allocation_struct_size)(struct pmu_gk20a *pmu);
 255                 void (*set_pmu_allocation_ptr)(struct pmu_gk20a *pmu,
 256                                 void **pmu_alloc_ptr, void *assign_ptr);
 257                 void (*pmu_allocation_set_dmem_size)(struct pmu_gk20a *pmu,
 258                                 void *pmu_alloc_ptr, u16 size);
 259                 u16 (*pmu_allocation_get_dmem_size)(struct pmu_gk20a *pmu,
 260                                 void *pmu_alloc_ptr);
 261                 u32 (*pmu_allocation_get_dmem_offset)(struct pmu_gk20a *pmu,
 262                                 void *pmu_alloc_ptr);
 263                 u32 * (*pmu_allocation_get_dmem_offset_addr)(
 264                                 struct pmu_gk20a *pmu, void *pmu_alloc_ptr);
 265                 void (*pmu_allocation_set_dmem_offset)(struct pmu_gk20a *pmu,
 266                                 void *pmu_alloc_ptr, u32 offset);
 267                 void (*get_pmu_init_msg_pmu_queue_params)(
 268                                 struct pmu_queue *queue, u32 id,
 269                                 void *pmu_init_msg);
 270                 void *(*get_pmu_msg_pmu_init_msg_ptr)(
 271                                 struct pmu_init_msg *init);
 272                 u16 (*get_pmu_init_msg_pmu_sw_mg_off)(
 273                         union pmu_init_msg_pmu *init_msg);
 274                 u16 (*get_pmu_init_msg_pmu_sw_mg_size)(
 275                         union pmu_init_msg_pmu *init_msg);
 276                 u32 (*get_pmu_perfmon_cmd_start_size)(void);
 277                 int (*get_perfmon_cmd_start_offsetofvar)(
 278                                 enum pmu_perfmon_cmd_start_fields field);
 279                 void (*perfmon_start_set_cmd_type)(struct pmu_perfmon_cmd *pc,
 280                                 u8 value);
 281                 void (*perfmon_start_set_group_id)(struct pmu_perfmon_cmd *pc,
 282                                 u8 value);
 283                 void (*perfmon_start_set_state_id)(struct pmu_perfmon_cmd *pc,
 284                                 u8 value);
 285                 void (*perfmon_start_set_flags)(struct pmu_perfmon_cmd *pc,
 286                                 u8 value);
 287                 u8 (*perfmon_start_get_flags)(struct pmu_perfmon_cmd *pc);
 288                 u32 (*get_pmu_perfmon_cmd_init_size)(void);
 289                 int (*get_perfmon_cmd_init_offsetofvar)(
 290                                 enum pmu_perfmon_cmd_start_fields field);
 291                 void (*perfmon_cmd_init_set_sample_buffer)(
 292                                 struct pmu_perfmon_cmd *pc, u16 value);
 293                 void (*perfmon_cmd_init_set_dec_cnt)(
 294                                 struct pmu_perfmon_cmd *pc, u8 value);
 295                 void (*perfmon_cmd_init_set_base_cnt_id)(
 296                                 struct pmu_perfmon_cmd *pc, u8 value);
 297                 void (*perfmon_cmd_init_set_samp_period_us)(
 298                                 struct pmu_perfmon_cmd *pc, u32 value);
 299                 void (*perfmon_cmd_init_set_num_cnt)(struct pmu_perfmon_cmd *pc,
 300                                 u8 value);
 301                 void (*perfmon_cmd_init_set_mov_avg)(struct pmu_perfmon_cmd *pc,
 302                                 u8 value);
 303                 void *(*get_pmu_seq_in_a_ptr)(
 304                                 struct pmu_sequence *seq);
 305                 void *(*get_pmu_seq_out_a_ptr)(
 306                                 struct pmu_sequence *seq);
 307                 void (*set_pmu_cmdline_args_secure_mode)(struct pmu_gk20a *pmu,
 308                         u32 val);
 309                 u32 (*get_perfmon_cntr_sz)(struct pmu_gk20a *pmu);
 310                 void * (*get_perfmon_cntr_ptr)(struct pmu_gk20a *pmu);
 311                 void (*set_perfmon_cntr_ut)(struct pmu_gk20a *pmu, u16 ut);
 312                 void (*set_perfmon_cntr_lt)(struct pmu_gk20a *pmu, u16 lt);
 313                 void (*set_perfmon_cntr_valid)(struct pmu_gk20a *pmu, u8 val);
 314                 void (*set_perfmon_cntr_index)(struct pmu_gk20a *pmu, u8 val);
 315                 void (*set_perfmon_cntr_group_id)(struct pmu_gk20a *pmu,
 316                                 u8 gid);
 317
 318                 u8 (*pg_cmd_eng_buf_load_size)(struct pmu_pg_cmd *pg);
 319                 void (*pg_cmd_eng_buf_load_set_cmd_type)(struct pmu_pg_cmd *pg,
 320                                 u8 value);
 321                 void (*pg_cmd_eng_buf_load_set_engine_id)(struct pmu_pg_cmd *pg,
 322                                 u8 value);
 323                 void (*pg_cmd_eng_buf_load_set_buf_idx)(struct pmu_pg_cmd *pg,
 324                                 u8 value);
 325                 void (*pg_cmd_eng_buf_load_set_pad)(struct pmu_pg_cmd *pg,
 326                                 u8 value);
 327                 void (*pg_cmd_eng_buf_load_set_buf_size)(struct pmu_pg_cmd *pg,
 328                                 u16 value);
 329                 void (*pg_cmd_eng_buf_load_set_dma_base)(struct pmu_pg_cmd *pg,
 330                                 u32 value);
 331                 void (*pg_cmd_eng_buf_load_set_dma_offset)(struct pmu_pg_cmd *pg,
 332                                 u8 value);
 333                 void (*pg_cmd_eng_buf_load_set_dma_idx)(struct pmu_pg_cmd *pg,
 334                                 u8 value);
 335         } pmu_ver;
 336         struct {
 337                 int (*get_netlist_name)(int index, char *name);
 338                 bool (*is_fw_defined)(void);
 339                 bool use_dma_for_fw_bootstrap;
 340         } gr_ctx;
 341         struct {
 342                 bool (*support_sparse)(struct gk20a *g);
 343                 bool (*is_debug_mode_enabled)(struct gk20a *g);
 344                 u64 (*gmmu_map)(struct vm_gk20a *vm,
 345                                 u64 map_offset,
 346                                 struct sg_table *sgt,
 347                                 u64 buffer_offset,
 348                                 u64 size,
 349                                 int pgsz_idx,
 350                                 u8 kind_v,
 351                                 u32 ctag_offset,
 352                                 u32 flags,
 353                                 int rw_flag,
 354                                 bool clear_ctags,
 355                                 bool sparse,
 356                                 bool priv,
 357                                 struct vm_gk20a_mapping_batch *batch);
 358                 void (*gmmu_unmap)(struct vm_gk20a *vm,
 359                                 u64 vaddr,
 360                                 u64 size,
 361                                 int pgsz_idx,
 362                                 bool va_allocated,
 363                                 int rw_flag,
 364                                 bool sparse,
 365                                 struct vm_gk20a_mapping_batch *batch);
 366                 void (*vm_remove)(struct vm_gk20a *vm);
 367                 int (*vm_alloc_share)(struct gk20a_as_share *as_share,
 368                                       u32 big_page_size, u32 flags);
 369                 int (*vm_bind_channel)(struct gk20a_as_share *as_share,
 370                                 struct channel_gk20a *ch);
 371                 int (*fb_flush)(struct gk20a *g);
 372                 void (*l2_invalidate)(struct gk20a *g);
 373                 void (*l2_flush)(struct gk20a *g, bool invalidate);
 374                 void (*tlb_invalidate)(struct vm_gk20a *vm);
 375                 void (*set_big_page_size)(struct gk20a *g,
 376                                           void *inst_ptr, int size);
 377                 u32 (*get_big_page_sizes)(void);
 378                 u32 (*get_physical_addr_bits)(struct gk20a *g);
 379                 int (*init_mm_setup_hw)(struct gk20a *g);
 380                 int (*init_bar2_vm)(struct gk20a *g);
 381                 int (*init_bar2_mm_hw_setup)(struct gk20a *g);
 382                 const struct gk20a_mmu_level *
 383                         (*get_mmu_levels)(struct gk20a *g, u32 big_page_size);
 384                 void (*init_pdb)(struct gk20a *g, void *inst_ptr, u64 pdb_addr);
 385                 u64 (*get_iova_addr)(struct gk20a *g, struct scatterlist *sgl,
 386                                          u32 flags);
 387         } mm;
 388         struct {
 389                 int (*prepare_ucode)(struct gk20a *g);
 390                 int (*pmu_setup_hw_and_bootstrap)(struct gk20a *g);
 391                 int (*pmu_setup_elpg)(struct gk20a *g);
 392                 int (*init_wpr_region)(struct gk20a *g);
 393                 int (*load_lsfalcon_ucode)(struct gk20a *g, u32 falconidmask);
 394                 u32  lspmuwprinitdone;
 395                 u32  lsfloadedfalconid;
 396                 bool fecsbootstrapdone;
 397         } pmu;
 398         struct {
 399                 void (*disable_slowboot)(struct gk20a *g);
 400                 int (*init_clk_support)(struct gk20a *g);
 401                 int (*suspend_clk_support)(struct gk20a *g);
 402         } clk;
 403         bool privsecurity;
 404         bool securegpccs;
 405         struct {
 406                 const struct regop_offset_range* (
 407                                 *get_global_whitelist_ranges)(void);
 408                 int (*get_global_whitelist_ranges_count)(void);
 409                 const struct regop_offset_range* (
 410                                 *get_context_whitelist_ranges)(void);
 411                 int (*get_context_whitelist_ranges_count)(void);
 412                 const u32* (*get_runcontrol_whitelist)(void);
 413                 int (*get_runcontrol_whitelist_count)(void);
 414                 const struct regop_offset_range* (
 415                                 *get_runcontrol_whitelist_ranges)(void);
 416                 int (*get_runcontrol_whitelist_ranges_count)(void);
 417                 const u32* (*get_qctl_whitelist)(void);
 418                 int (*get_qctl_whitelist_count)(void);
 419                 const struct regop_offset_range* (
 420                                 *get_qctl_whitelist_ranges)(void);
 421                 int (*get_qctl_whitelist_ranges_count)(void);
 422                 int (*apply_smpc_war)(struct dbg_session_gk20a *dbg_s);
 423         } regops;
 424         struct {
 425                 void (*intr_enable)(struct gk20a *g);
 426                 void (*intr_unit_config)(struct gk20a *g,
 427                                 bool enable, bool is_stalling, u32 unit);
 428                 irqreturn_t (*isr_stall)(struct gk20a *g);
 429                 irqreturn_t (*isr_nonstall)(struct gk20a *g);
 430                 irqreturn_t (*isr_thread_stall)(struct gk20a *g);
 431                 irqreturn_t (*isr_thread_nonstall)(struct gk20a *g);
 432                 u32 intr_mask_restore[4];
 433         } mc;
 434         struct {
 435                 void (*show_dump)(struct gk20a *g,
 436                                 struct gk20a_debug_output *o);
 437         } debug;
 438         struct {
 439                 void (*get_program_numbers)(struct gk20a *g,
 440                                             u32 block_height_log2,
 441                                             int *hprog, int *vprog);
 442         } cde;
 443 };
 444
 445 struct gk20a {
 446         struct platform_device *dev;
 447         struct platform_device *host1x_dev;
 448
 449         struct resource *reg_mem;
 450         void __iomem *regs;
 451         void __iomem *regs_saved;
 452
 453         struct resource *bar1_mem;
 454         void __iomem *bar1;
 455         void __iomem *bar1_saved;
 456
 457         bool power_on;
 458
 459         struct rw_semaphore busy_lock;
 460
 461         struct clk_gk20a clk;
 462         struct fifo_gk20a fifo;
 463         struct gr_gk20a gr;
 464         struct sim_gk20a sim;
 465         struct mm_gk20a mm;
 466         struct pmu_gk20a pmu;
 467         struct acr_gm20b acr;
 468         struct cooling_device_gk20a gk20a_cdev;
 469
 470         /* Save pmu fw here so that it lives cross suspend/resume.
 471            pmu suspend destroys all pmu sw/hw states. Loading pmu
 472            fw in resume crashes when the resume is from sys_exit. */
 473         const struct firmware *pmu_fw;
 474
 475         u32 gr_idle_timeout_default;
 476         u32 timeouts_enabled;
 477
 478         bool slcg_enabled;
 479         bool blcg_enabled;
 480         bool elcg_enabled;
 481         bool elpg_enabled;
 482         bool aelpg_enabled;
 483         bool forced_idle;
 484         bool forced_reset;
 485         bool allow_all;
 486
 487         u32 emc3d_ratio;
 488
 489 #ifdef CONFIG_DEBUG_FS
 490         spinlock_t debugfs_lock;
 491         struct dentry *debugfs_ltc_enabled;
 492         struct dentry *debugfs_timeouts_enabled;
 493         struct dentry *debugfs_gr_idle_timeout_default;
 494         struct dentry *debugfs_bypass_smmu;
 495         struct dentry *debugfs_disable_bigpage;
 496         struct dentry *debugfs_gr_default_attrib_cb_size;
 497 #endif
 498         struct gk20a_ctxsw_ucode_info ctxsw_ucode_info;
 499
 500         /* held while manipulating # of debug/profiler sessions present */
 501         /* also prevents debug sessions from attaching until released */
 502         struct mutex dbg_sessions_lock;
 503         int dbg_sessions; /* number attached */
 504         int dbg_powergating_disabled_refcount; /*refcount for pg disable */
 505
 506         void (*remove_support)(struct platform_device *);
 507
 508         u64 pg_ingating_time_us;
 509         u64 pg_ungating_time_us;
 510         u32 pg_gating_cnt;
 511
 512         spinlock_t mc_enable_lock;
 513
 514         struct nvgpu_gpu_characteristics gpu_characteristics;
 515
 516         struct {
 517                 struct cdev cdev;
 518                 struct device *node;
 519         } channel;
 520
 521         struct gk20a_as as;
 522
 523         struct {
 524                 struct cdev cdev;
 525                 struct device *node;
 526         } ctrl;
 527
 528         struct {
 529                 struct cdev cdev;
 530                 struct device *node;
 531         } dbg;
 532
 533         struct {
 534                 struct cdev cdev;
 535                 struct device *node;
 536         } prof;
 537
 538         struct {
 539                 struct cdev cdev;
 540                 struct device *node;
 541         } tsg;
 542
 543         struct mutex client_lock;
 544         int client_refcount; /* open channels and ctrl nodes */
 545
 546         dev_t cdev_region;
 547         struct class *class;
 548
 549         struct gpu_ops ops;
 550
 551         int irq_stall;
 552         int irq_nonstall;
 553         u32 max_ltc_count;
 554         u32 ltc_count;
 555
 556         atomic_t hw_irq_stall_count;
 557         atomic_t hw_irq_nonstall_count;
 558
 559         atomic_t sw_irq_stall_last_handled;
 560         wait_queue_head_t sw_irq_stall_last_handled_wq;
 561
 562         atomic_t sw_irq_nonstall_last_handled;
 563         wait_queue_head_t sw_irq_nonstall_last_handled_wq;
 564
 565         struct devfreq *devfreq;
 566
 567         struct gk20a_scale_profile *scale_profile;
 568
 569         struct device_dma_parameters dma_parms;
 570
 571         struct gk20a_cde_app cde_app;
 572         bool mmu_debug_ctrl;
 573 };
 574
 575 static inline unsigned long gk20a_get_gr_idle_timeout(struct gk20a *g)
 576 {
 577         return g->timeouts_enabled ?
 578                 g->gr_idle_timeout_default : MAX_SCHEDULE_TIMEOUT;
 579 }
 580
 581 static inline struct gk20a *get_gk20a(struct platform_device *dev)
 582 {
 583         return gk20a_get_platform(dev)->g;
 584 }
 585
 586 enum BAR0_DEBUG_OPERATION {
 587         BARO_ZERO_NOP = 0,
 588         OP_END = 'DONE',
 589         BAR0_READ32 = '0R32',
 590         BAR0_WRITE32 = '0W32',
 591 };
 592
 593 struct share_buffer_head {
 594         enum BAR0_DEBUG_OPERATION operation;
 595 /* size of the operation item */
 596         u32 size;
 597         u32 completed;
 598         u32 failed;
 599         u64 context;
 600         u64 completion_callback;
 601 };
 602
 603 struct gk20a_cyclestate_buffer_elem {
 604         struct share_buffer_head        head;
 605 /* in */
 606         u64 p_data;
 607         u64 p_done;
 608         u32 offset_bar0;
 609         u16 first_bit;
 610         u16 last_bit;
 611 /* out */
 612 /* keep 64 bits to be consistent */
 613         u64 data;
 614 };
 615
 616 struct gk20a_domain_data {
 617         struct generic_pm_domain gpd;
 618         struct gk20a *gk20a;
 619 };
 620
 621 /* debug accessories */
 622
 623 #ifdef CONFIG_DEBUG_FS
 624     /* debug info, default is compiled-in but effectively disabled (0 mask) */
 625     #define GK20A_DEBUG
 626     /*e.g: echo 1 > /d/gk20a.0/dbg_mask */
 627     #define GK20A_DEFAULT_DBG_MASK 0
 628 #else
 629     /* manually enable and turn it on the mask */
 630     /*#define NVGPU_DEBUG*/
 631     #define GK20A_DEFAULT_DBG_MASK (dbg_info)
 632 #endif
 633
 634 enum gk20a_dbg_categories {
 635         gpu_dbg_info    = BIT(0),  /* lightly verbose info */
 636         gpu_dbg_fn      = BIT(2),  /* fn name tracing */
 637         gpu_dbg_reg     = BIT(3),  /* register accesses, very verbose */
 638         gpu_dbg_pte     = BIT(4),  /* gmmu ptes */
 639         gpu_dbg_intr    = BIT(5),  /* interrupts */
 640         gpu_dbg_pmu     = BIT(6),  /* gk20a pmu */
 641         gpu_dbg_clk     = BIT(7),  /* gk20a clk */
 642         gpu_dbg_map     = BIT(8),  /* mem mappings */
 643         gpu_dbg_gpu_dbg = BIT(9),  /* gpu debugger/profiler */
 644         gpu_dbg_cde     = BIT(10), /* cde info messages */
 645         gpu_dbg_cde_ctx = BIT(11), /* cde context usage messages */
 646         gpu_dbg_mem     = BIT(31), /* memory accesses, very verbose */
 647 };
 648
 649 #if defined(GK20A_DEBUG)
 650 extern u32 gk20a_dbg_mask;
 651 extern u32 gk20a_dbg_ftrace;
 652 #define gk20a_dbg(dbg_mask, format, arg...)                             \
 653 do {                                                                    \
 654         if (unlikely((dbg_mask) & gk20a_dbg_mask)) {            \
 655                 if (gk20a_dbg_ftrace)                                   \
 656                         trace_printk(format "\n", ##arg);               \
 657                 else                                                    \
 658                         pr_info("gk20a %s: " format "\n",               \
 659                                         __func__, ##arg);               \
 660         }                                                               \
 661 } while (0)
 662
 663 #else /* GK20A_DEBUG */
 664 #define gk20a_dbg(dbg_mask, format, arg...)                             \
 665 do {                                                                    \
 666         if (0)                                                          \
 667                 pr_info("gk20a %s: " format "\n", __func__, ##arg);\
 668 } while (0)
 669
 670 #endif
 671
 672 #define gk20a_err(d, fmt, arg...) \
 673         dev_err(d, "%s: " fmt "\n", __func__, ##arg)
 674
 675 #define gk20a_warn(d, fmt, arg...) \
 676         dev_warn(d, "%s: " fmt "\n", __func__, ##arg)
 677
 678 #define gk20a_dbg_fn(fmt, arg...) \
 679         gk20a_dbg(gpu_dbg_fn, fmt, ##arg)
 680
 681 #define gk20a_dbg_info(fmt, arg...) \
 682         gk20a_dbg(gpu_dbg_info, fmt, ##arg)
 683
 684 /* mem access with dbg_mem logging */
 685 static inline u8 gk20a_mem_rd08(void *ptr, int b)
 686 {
 687         u8 _b = ((const u8 *)ptr)[b];
 688 #ifdef CONFIG_TEGRA_SIMULATION_PLATFORM
 689         gk20a_dbg(gpu_dbg_mem, " %p = 0x%x", ptr+sizeof(u8)*b, _b);
 690 #endif
 691         return _b;
 692 }
 693 static inline u16 gk20a_mem_rd16(void *ptr, int s)
 694 {
 695         u16 _s = ((const u16 *)ptr)[s];
 696 #ifdef CONFIG_TEGRA_SIMULATION_PLATFORM
 697         gk20a_dbg(gpu_dbg_mem, " %p = 0x%x", ptr+sizeof(u16)*s, _s);
 698 #endif
 699         return _s;
 700 }
 701 static inline u32 gk20a_mem_rd32(void *ptr, int w)
 702 {
 703         u32 _w = ((const u32 *)ptr)[w];
 704 #ifdef CONFIG_TEGRA_SIMULATION_PLATFORM
 705         gk20a_dbg(gpu_dbg_mem, " %p = 0x%x", ptr + sizeof(u32)*w, _w);
 706 #endif
 707         return _w;
 708 }
 709 static inline void gk20a_mem_wr08(void *ptr, int b, u8 data)
 710 {
 711 #ifdef CONFIG_TEGRA_SIMULATION_PLATFORM
 712         gk20a_dbg(gpu_dbg_mem, " %p = 0x%x", ptr+sizeof(u8)*b, data);
 713 #endif
 714         ((u8 *)ptr)[b] = data;
 715 }
 716 static inline void gk20a_mem_wr16(void *ptr, int s, u16 data)
 717 {
 718 #ifdef CONFIG_TEGRA_SIMULATION_PLATFORM
 719         gk20a_dbg(gpu_dbg_mem, " %p = 0x%x", ptr+sizeof(u16)*s, data);
 720 #endif
 721         ((u16 *)ptr)[s] = data;
 722 }
 723 static inline void gk20a_mem_wr32(void *ptr, int w, u32 data)
 724 {
 725 #ifdef CONFIG_TEGRA_SIMULATION_PLATFORM
 726         gk20a_dbg(gpu_dbg_mem, " %p = 0x%x", ptr+sizeof(u32)*w, data);
 727 #endif
 728         ((u32 *)ptr)[w] = data;
 729 }
 730
 731 void gk20a_init_clk_ops(struct gpu_ops *gops);
 732
 733 /* register accessors */
 734 int gk20a_lockout_registers(struct gk20a *g);
 735 int gk20a_restore_registers(struct gk20a *g);
 736
 737 static inline void gk20a_writel(struct gk20a *g, u32 r, u32 v)
 738 {
 739         gk20a_dbg(gpu_dbg_reg, " r=0x%x v=0x%x", r, v);
 740         wmb();
 741         writel_relaxed(v, g->regs + r);
 742 }
 743 static inline u32 gk20a_readl(struct gk20a *g, u32 r)
 744 {
 745         u32 v = readl(g->regs + r);
 746         gk20a_dbg(gpu_dbg_reg, " r=0x%x v=0x%x", r, v);
 747         return v;
 748 }
 749 static inline void gk20a_writel_check(struct gk20a *g, u32 r, u32 v)
 750 {
 751         gk20a_dbg(gpu_dbg_reg, " r=0x%x v=0x%x", r, v);
 752         wmb();
 753         do {
 754                 writel_relaxed(v, g->regs + r);
 755         } while (readl(g->regs + r) != v);
 756 }
 757
 758 static inline void gk20a_bar1_writel(struct gk20a *g, u32 b, u32 v)
 759 {
 760         gk20a_dbg(gpu_dbg_reg, " b=0x%x v=0x%x", b, v);
 761         wmb();
 762         writel_relaxed(v, g->bar1 + b);
 763 }
 764
 765 static inline u32 gk20a_bar1_readl(struct gk20a *g, u32 b)
 766 {
 767         u32 v = readl(g->bar1 + b);
 768         gk20a_dbg(gpu_dbg_reg, " b=0x%x v=0x%x", b, v);
 769         return v;
 770 }
 771
 772 /* convenience */
 773 static inline struct device *dev_from_gk20a(struct gk20a *g)
 774 {
 775         return &g->dev->dev;
 776 }
 777 static inline struct gk20a *gk20a_from_as(struct gk20a_as *as)
 778 {
 779         return container_of(as, struct gk20a, as);
 780 }
 781 static inline struct gk20a *gk20a_from_pmu(struct pmu_gk20a *pmu)
 782 {
 783         return container_of(pmu, struct gk20a, pmu);
 784 }
 785
 786 static inline u32 u64_hi32(u64 n)
 787 {
 788         return (u32)((n >> 32) & ~(u32)0);
 789 }
 790
 791 static inline u32 u64_lo32(u64 n)
 792 {
 793         return (u32)(n & ~(u32)0);
 794 }
 795
 796 static inline u32 set_field(u32 val, u32 mask, u32 field)
 797 {
 798         return ((val & ~mask) | field);
 799 }
 800
 801 /* invalidate channel lookup tlb */
 802 static inline void gk20a_gr_flush_channel_tlb(struct gr_gk20a *gr)
 803 {
 804         spin_lock(&gr->ch_tlb_lock);
 805         memset(gr->chid_tlb, 0,
 806                 sizeof(struct gr_channel_map_tlb_entry) *
 807                 GR_CHANNEL_MAP_TLB_SIZE);
 808         spin_unlock(&gr->ch_tlb_lock);
 809 }
 810
 811 /* classes that the device supports */
 812 /* TBD: get these from an open-sourced SDK? */
 813 enum {
 814         KEPLER_C                  = 0xA297,
 815         FERMI_TWOD_A              = 0x902D,
 816         KEPLER_COMPUTE_A          = 0xA0C0,
 817         KEPLER_INLINE_TO_MEMORY_A = 0xA040,
 818         KEPLER_DMA_COPY_A         = 0xA0B5,
 819         KEPLER_CHANNEL_GPFIFO_C   = 0xA26F,
 820 };
 821
 822 static inline bool gk20a_gpu_is_virtual(struct platform_device *dev)
 823 {
 824         struct gk20a_platform *platform = gk20a_get_platform(dev);
 825
 826         return platform->virtual_dev;
 827 }
 828
 829 static inline int support_gk20a_pmu(struct platform_device *dev)
 830 {
 831         if (IS_ENABLED(CONFIG_GK20A_PMU)) {
 832                 /* gPMU is not supported for vgpu */
 833                 return !gk20a_gpu_is_virtual(dev);
 834         }
 835
 836         return 0;
 837 }
 838
 839 void gk20a_create_sysfs(struct platform_device *dev);
 840 void gk20a_remove_sysfs(struct device *dev);
 841
 842 #define GK20A_BAR0_IORESOURCE_MEM 0
 843 #define GK20A_BAR1_IORESOURCE_MEM 1
 844 #define GK20A_SIM_IORESOURCE_MEM 2
 845
 846 void gk20a_busy_noresume(struct platform_device *pdev);
 847 int __must_check gk20a_busy(struct platform_device *pdev);
 848 void gk20a_idle(struct platform_device *pdev);
 849 void gk20a_disable(struct gk20a *g, u32 units);
 850 void gk20a_enable(struct gk20a *g, u32 units);
 851 void gk20a_reset(struct gk20a *g, u32 units);
 852 int __gk20a_do_idle(struct platform_device *pdev, bool force_reset);
 853 int __gk20a_do_unidle(struct platform_device *pdev);
 854
 855 const struct firmware *
 856 gk20a_request_firmware(struct gk20a *g, const char *fw_name);
 857
 858 #define NVGPU_GPU_ARCHITECTURE_SHIFT 4
 859
 860 /* constructs unique and compact GPUID from nvgpu_gpu_characteristics
 861  * arch/impl fields */
 862 #define GK20A_GPUID(arch, impl) ((u32) ((arch) | (impl)))
 863
 864 #define GK20A_GPUID_GK20A \
 865         GK20A_GPUID(NVGPU_GPU_ARCH_GK100, NVGPU_GPU_IMPL_GK20A)
 866
 867 #define GK20A_GPUID_GM20B \
 868         GK20A_GPUID(NVGPU_GPU_ARCH_GM200, NVGPU_GPU_IMPL_GM20B)
 869
 870 int gk20a_init_gpu_characteristics(struct gk20a *g);
 871
 872 void gk20a_pbus_isr(struct gk20a *g);
 873
 874 int gk20a_user_init(struct platform_device *dev);
 875 void gk20a_user_deinit(struct platform_device *dev);
 876
 877 #endif /* GK20A_H */