From b69020bff5dfa69cad926c9374cdbe9a62509ffd Mon Sep 17 00:00:00 2001 From: Alex Waterman Date: Wed, 15 Mar 2017 16:42:12 -0700 Subject: gpu: nvgpu: Rename gk20a_mem_* functions Rename the functions used for mem_desc access to nvgpu_mem_*. JIRA NVGPU-12 Change-Id: Ibfdc1112d43f0a125e4487c250e3f977ffd2cd75 Signed-off-by: Alex Waterman Reviewed-on: http://git-master/r/1323325 Reviewed-by: mobile promotions Tested-by: mobile promotions --- drivers/gpu/nvgpu/gk20a/bus_gk20a.c | 2 +- drivers/gpu/nvgpu/gk20a/channel_gk20a.c | 8 +- drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c | 54 ++++---- drivers/gpu/nvgpu/gk20a/debug_gk20a.c | 2 +- drivers/gpu/nvgpu/gk20a/fb_gk20a.c | 2 +- drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c | 12 +- drivers/gpu/nvgpu/gk20a/fifo_gk20a.c | 58 ++++---- drivers/gpu/nvgpu/gk20a/gk20a.h | 2 +- drivers/gpu/nvgpu/gk20a/gr_gk20a.c | 190 +++++++++++++-------------- drivers/gpu/nvgpu/gk20a/mm_gk20a.c | 57 ++++---- drivers/gpu/nvgpu/gk20a/mm_gk20a.h | 12 +- drivers/gpu/nvgpu/gk20a/pmu_gk20a.c | 8 +- drivers/gpu/nvgpu/gk20a/pramin_gk20a.c | 2 +- 13 files changed, 205 insertions(+), 204 deletions(-) (limited to 'drivers/gpu/nvgpu/gk20a') diff --git a/drivers/gpu/nvgpu/gk20a/bus_gk20a.c b/drivers/gpu/nvgpu/gk20a/bus_gk20a.c index fda1f80e..d161a29c 100644 --- a/drivers/gpu/nvgpu/gk20a/bus_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/bus_gk20a.c @@ -138,7 +138,7 @@ static int gk20a_bus_bar1_bind(struct gk20a *g, struct mem_desc *bar1_inst) gk20a_dbg_info("bar1 inst block ptr: 0x%08x", ptr_v); gk20a_writel(g, bus_bar1_block_r(), - gk20a_aperture_mask(g, bar1_inst, + nvgpu_aperture_mask(g, bar1_inst, bus_bar1_block_target_sys_mem_ncoh_f(), bus_bar1_block_target_vid_mem_f()) | bus_bar1_block_mode_virtual_f() | diff --git a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c index b7306369..e13a903f 100644 --- a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c @@ -2124,7 +2124,7 @@ static void gk20a_submit_append_priv_cmdbuf(struct channel_gk20a *c, pbdma_gp_entry1_length_f(cmd->size) }; - gk20a_mem_wr_n(g, gpfifo_mem, c->gpfifo.put * sizeof(x), + nvgpu_mem_wr_n(g, gpfifo_mem, c->gpfifo.put * sizeof(x), &x, sizeof(x)); if (cmd->mem->aperture == APERTURE_SYSMEM) @@ -2207,10 +2207,10 @@ static int gk20a_submit_append_gpfifo(struct channel_gk20a *c, int length1 = len - length0; void *src2 = (u8 *)cpu_src + length0; - gk20a_mem_wr_n(c->g, gpfifo_mem, start, cpu_src, length0); - gk20a_mem_wr_n(c->g, gpfifo_mem, 0, src2, length1); + nvgpu_mem_wr_n(c->g, gpfifo_mem, start, cpu_src, length0); + nvgpu_mem_wr_n(c->g, gpfifo_mem, 0, src2, length1); } else { - gk20a_mem_wr_n(c->g, gpfifo_mem, start, cpu_src, len); + nvgpu_mem_wr_n(c->g, gpfifo_mem, start, cpu_src, len); } diff --git a/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c b/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c index 8baf60dd..d9dfb133 100644 --- a/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/channel_sync_gk20a.c @@ -46,13 +46,13 @@ static void add_wait_cmd(struct gk20a *g, struct priv_cmd_entry *cmd, u32 off, { off = cmd->off + off; /* syncpoint_a */ - gk20a_mem_wr32(g, cmd->mem, off++, 0x2001001C); + nvgpu_mem_wr32(g, cmd->mem, off++, 0x2001001C); /* payload */ - gk20a_mem_wr32(g, cmd->mem, off++, thresh); + nvgpu_mem_wr32(g, cmd->mem, off++, thresh); /* syncpoint_b */ - gk20a_mem_wr32(g, cmd->mem, off++, 0x2001001D); + nvgpu_mem_wr32(g, cmd->mem, off++, 0x2001001D); /* syncpt_id, switch_en, wait */ - gk20a_mem_wr32(g, cmd->mem, off++, (id << 8) | 0x10); + nvgpu_mem_wr32(g, cmd->mem, off++, (id << 8) | 0x10); } static int gk20a_channel_syncpt_wait_syncpt(struct gk20a_channel_sync *s, @@ -151,7 +151,7 @@ static int gk20a_channel_syncpt_wait_fd(struct gk20a_channel_sync *s, int fd, if (nvhost_syncpt_is_expired_ext(sp->host1x_pdev, wait_id, wait_value)) { /* each wait_cmd is 4 u32s */ - gk20a_memset(c->g, wait_cmd->mem, + nvgpu_memset(c->g, wait_cmd->mem, (wait_cmd->off + i * 4) * sizeof(u32), 0, 4 * sizeof(u32)); } else @@ -212,22 +212,22 @@ static int __gk20a_channel_syncpt_incr(struct gk20a_channel_sync *s, if (wfi_cmd) { /* wfi */ - gk20a_mem_wr32(c->g, incr_cmd->mem, off++, 0x2001001E); + nvgpu_mem_wr32(c->g, incr_cmd->mem, off++, 0x2001001E); /* handle, ignored */ - gk20a_mem_wr32(c->g, incr_cmd->mem, off++, 0x00000000); + nvgpu_mem_wr32(c->g, incr_cmd->mem, off++, 0x00000000); } /* syncpoint_a */ - gk20a_mem_wr32(c->g, incr_cmd->mem, off++, 0x2001001C); + nvgpu_mem_wr32(c->g, incr_cmd->mem, off++, 0x2001001C); /* payload, ignored */ - gk20a_mem_wr32(c->g, incr_cmd->mem, off++, 0); + nvgpu_mem_wr32(c->g, incr_cmd->mem, off++, 0); /* syncpoint_b */ - gk20a_mem_wr32(c->g, incr_cmd->mem, off++, 0x2001001D); + nvgpu_mem_wr32(c->g, incr_cmd->mem, off++, 0x2001001D); /* syncpt_id, incr */ - gk20a_mem_wr32(c->g, incr_cmd->mem, off++, (sp->id << 8) | 0x1); + nvgpu_mem_wr32(c->g, incr_cmd->mem, off++, (sp->id << 8) | 0x1); /* syncpoint_b */ - gk20a_mem_wr32(c->g, incr_cmd->mem, off++, 0x2001001D); + nvgpu_mem_wr32(c->g, incr_cmd->mem, off++, 0x2001001D); /* syncpt_id, incr */ - gk20a_mem_wr32(c->g, incr_cmd->mem, off++, (sp->id << 8) | 0x1); + nvgpu_mem_wr32(c->g, incr_cmd->mem, off++, (sp->id << 8) | 0x1); WARN_ON(off - incr_cmd->off != incr_cmd_size); @@ -531,39 +531,39 @@ static void add_sema_cmd(struct gk20a *g, struct channel_gk20a *c, nvgpu_semaphore_incr(s); /* semaphore_a */ - gk20a_mem_wr32(g, cmd->mem, off++, 0x20010004); + nvgpu_mem_wr32(g, cmd->mem, off++, 0x20010004); /* offset_upper */ - gk20a_mem_wr32(g, cmd->mem, off++, (va >> 32) & 0xff); + nvgpu_mem_wr32(g, cmd->mem, off++, (va >> 32) & 0xff); /* semaphore_b */ - gk20a_mem_wr32(g, cmd->mem, off++, 0x20010005); + nvgpu_mem_wr32(g, cmd->mem, off++, 0x20010005); /* offset */ - gk20a_mem_wr32(g, cmd->mem, off++, va & 0xffffffff); + nvgpu_mem_wr32(g, cmd->mem, off++, va & 0xffffffff); if (acquire) { /* semaphore_c */ - gk20a_mem_wr32(g, cmd->mem, off++, 0x20010006); + nvgpu_mem_wr32(g, cmd->mem, off++, 0x20010006); /* payload */ - gk20a_mem_wr32(g, cmd->mem, off++, + nvgpu_mem_wr32(g, cmd->mem, off++, nvgpu_semaphore_get_value(s)); /* semaphore_d */ - gk20a_mem_wr32(g, cmd->mem, off++, 0x20010007); + nvgpu_mem_wr32(g, cmd->mem, off++, 0x20010007); /* operation: acq_geq, switch_en */ - gk20a_mem_wr32(g, cmd->mem, off++, 0x4 | (0x1 << 12)); + nvgpu_mem_wr32(g, cmd->mem, off++, 0x4 | (0x1 << 12)); } else { /* semaphore_c */ - gk20a_mem_wr32(g, cmd->mem, off++, 0x20010006); + nvgpu_mem_wr32(g, cmd->mem, off++, 0x20010006); /* payload */ - gk20a_mem_wr32(g, cmd->mem, off++, + nvgpu_mem_wr32(g, cmd->mem, off++, nvgpu_semaphore_get_value(s)); /* semaphore_d */ - gk20a_mem_wr32(g, cmd->mem, off++, 0x20010007); + nvgpu_mem_wr32(g, cmd->mem, off++, 0x20010007); /* operation: release, wfi */ - gk20a_mem_wr32(g, cmd->mem, off++, + nvgpu_mem_wr32(g, cmd->mem, off++, 0x2 | ((wfi ? 0x0 : 0x1) << 20)); /* non_stall_int */ - gk20a_mem_wr32(g, cmd->mem, off++, 0x20010008); + nvgpu_mem_wr32(g, cmd->mem, off++, 0x20010008); /* ignored */ - gk20a_mem_wr32(g, cmd->mem, off++, 0); + nvgpu_mem_wr32(g, cmd->mem, off++, 0); } if (acquire) diff --git a/drivers/gpu/nvgpu/gk20a/debug_gk20a.c b/drivers/gpu/nvgpu/gk20a/debug_gk20a.c index 7e7c9cb8..5724be72 100644 --- a/drivers/gpu/nvgpu/gk20a/debug_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/debug_gk20a.c @@ -87,7 +87,7 @@ static void gk20a_debug_dump_all_channel_status_ramfc(struct gk20a *g, ch_state[chid]->pid = ch->pid; ch_state[chid]->refs = atomic_read(&ch->ref_count); - gk20a_mem_rd_n(g, &ch->inst_block, 0, + nvgpu_mem_rd_n(g, &ch->inst_block, 0, &ch_state[chid]->inst_block[0], ram_in_alloc_size_v()); gk20a_channel_put(ch); diff --git a/drivers/gpu/nvgpu/gk20a/fb_gk20a.c b/drivers/gpu/nvgpu/gk20a/fb_gk20a.c index 44f0ac4c..2e0809ee 100644 --- a/drivers/gpu/nvgpu/gk20a/fb_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/fb_gk20a.c @@ -135,7 +135,7 @@ void gk20a_fb_tlb_invalidate(struct gk20a *g, struct mem_desc *pdb) gk20a_writel(g, fb_mmu_invalidate_pdb_r(), fb_mmu_invalidate_pdb_addr_f(addr_lo) | - gk20a_aperture_mask(g, pdb, + nvgpu_aperture_mask(g, pdb, fb_mmu_invalidate_pdb_aperture_sys_mem_f(), fb_mmu_invalidate_pdb_aperture_vid_mem_f())); diff --git a/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c b/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c index 4fa71797..b4e3bad1 100644 --- a/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/fecs_trace_gk20a.c @@ -636,11 +636,11 @@ static int gk20a_fecs_trace_bind_channel(struct gk20a *g, pa = gk20a_mm_inst_block_addr(g, &trace->trace_buf); if (!pa) return -ENOMEM; - aperture = gk20a_aperture_mask(g, &trace->trace_buf, + aperture = nvgpu_aperture_mask(g, &trace->trace_buf, ctxsw_prog_main_image_context_timestamp_buffer_ptr_hi_target_sys_mem_noncoherent_f(), ctxsw_prog_main_image_context_timestamp_buffer_ptr_hi_target_vid_mem_f()); - if (gk20a_mem_begin(g, mem)) + if (nvgpu_mem_begin(g, mem)) return -ENOMEM; lo = u64_lo32(pa); @@ -649,19 +649,19 @@ static int gk20a_fecs_trace_bind_channel(struct gk20a *g, gk20a_dbg(gpu_dbg_ctxsw, "addr_hi=%x addr_lo=%x count=%d", hi, lo, GK20A_FECS_TRACE_NUM_RECORDS); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_context_timestamp_buffer_ptr_o(), lo); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_context_timestamp_buffer_ptr_hi_o(), ctxsw_prog_main_image_context_timestamp_buffer_ptr_v_f(hi) | aperture); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_context_timestamp_buffer_control_o(), ctxsw_prog_main_image_context_timestamp_buffer_control_num_records_f( GK20A_FECS_TRACE_NUM_RECORDS)); - gk20a_mem_end(g, mem); + nvgpu_mem_end(g, mem); /* pid (process identifier) in user space, corresponds to tgid (thread * group id) in kernel space. diff --git a/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c b/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c index b2a6b1a0..b8b0c9b0 100644 --- a/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c @@ -3141,7 +3141,7 @@ static int gk20a_fifo_update_runlist_locked(struct gk20a *g, u32 runlist_id, if (count != 0) { gk20a_writel(g, fifo_runlist_base_r(), fifo_runlist_base_ptr_f(u64_lo32(runlist_iova >> 12)) | - gk20a_aperture_mask(g, &runlist->mem[new_buf], + nvgpu_aperture_mask(g, &runlist->mem[new_buf], fifo_runlist_base_target_sys_mem_ncoh_f(), fifo_runlist_base_target_vid_mem_f())); } @@ -3901,7 +3901,7 @@ static void gk20a_fifo_channel_bind(struct channel_gk20a *c) gk20a_writel(g, ccsr_channel_inst_r(c->hw_chid), ccsr_channel_inst_ptr_f(inst_ptr) | - gk20a_aperture_mask(g, &c->inst_block, + nvgpu_aperture_mask(g, &c->inst_block, ccsr_channel_inst_target_sys_mem_ncoh_f(), ccsr_channel_inst_target_vid_mem_f()) | ccsr_channel_inst_bind_true_f()); @@ -3943,14 +3943,14 @@ static int gk20a_fifo_commit_userd(struct channel_gk20a *c) gk20a_dbg_info("channel %d : set ramfc userd 0x%16llx", c->hw_chid, (u64)c->userd_iova); - gk20a_mem_wr32(g, &c->inst_block, + nvgpu_mem_wr32(g, &c->inst_block, ram_in_ramfc_w() + ram_fc_userd_w(), - gk20a_aperture_mask(g, &g->fifo.userd, + nvgpu_aperture_mask(g, &g->fifo.userd, pbdma_userd_target_sys_mem_ncoh_f(), pbdma_userd_target_vid_mem_f()) | pbdma_userd_addr_f(addr_lo)); - gk20a_mem_wr32(g, &c->inst_block, + nvgpu_mem_wr32(g, &c->inst_block, ram_in_ramfc_w() + ram_fc_userd_hi_w(), pbdma_userd_hi_addr_f(addr_hi)); @@ -3967,25 +3967,25 @@ int gk20a_fifo_setup_ramfc(struct channel_gk20a *c, gk20a_dbg_fn(""); - gk20a_memset(g, mem, 0, 0, ram_fc_size_val_v()); + nvgpu_memset(g, mem, 0, 0, ram_fc_size_val_v()); - gk20a_mem_wr32(g, mem, ram_fc_gp_base_w(), + nvgpu_mem_wr32(g, mem, ram_fc_gp_base_w(), pbdma_gp_base_offset_f( u64_lo32(gpfifo_base >> pbdma_gp_base_rsvd_s()))); - gk20a_mem_wr32(g, mem, ram_fc_gp_base_hi_w(), + nvgpu_mem_wr32(g, mem, ram_fc_gp_base_hi_w(), pbdma_gp_base_hi_offset_f(u64_hi32(gpfifo_base)) | pbdma_gp_base_hi_limit2_f(ilog2(gpfifo_entries))); - gk20a_mem_wr32(g, mem, ram_fc_signature_w(), + nvgpu_mem_wr32(g, mem, ram_fc_signature_w(), c->g->ops.fifo.get_pbdma_signature(c->g)); - gk20a_mem_wr32(g, mem, ram_fc_formats_w(), + nvgpu_mem_wr32(g, mem, ram_fc_formats_w(), pbdma_formats_gp_fermi0_f() | pbdma_formats_pb_fermi1_f() | pbdma_formats_mp_fermi0_f()); - gk20a_mem_wr32(g, mem, ram_fc_pb_header_w(), + nvgpu_mem_wr32(g, mem, ram_fc_pb_header_w(), pbdma_pb_header_priv_user_f() | pbdma_pb_header_method_zero_f() | pbdma_pb_header_subchannel_zero_f() | @@ -3993,27 +3993,27 @@ int gk20a_fifo_setup_ramfc(struct channel_gk20a *c, pbdma_pb_header_first_true_f() | pbdma_pb_header_type_inc_f()); - gk20a_mem_wr32(g, mem, ram_fc_subdevice_w(), + nvgpu_mem_wr32(g, mem, ram_fc_subdevice_w(), pbdma_subdevice_id_f(1) | pbdma_subdevice_status_active_f() | pbdma_subdevice_channel_dma_enable_f()); - gk20a_mem_wr32(g, mem, ram_fc_target_w(), pbdma_target_engine_sw_f()); + nvgpu_mem_wr32(g, mem, ram_fc_target_w(), pbdma_target_engine_sw_f()); - gk20a_mem_wr32(g, mem, ram_fc_acquire_w(), + nvgpu_mem_wr32(g, mem, ram_fc_acquire_w(), g->ops.fifo.pbdma_acquire_val(timeout)); - gk20a_mem_wr32(g, mem, ram_fc_runlist_timeslice_w(), + nvgpu_mem_wr32(g, mem, ram_fc_runlist_timeslice_w(), fifo_runlist_timeslice_timeout_128_f() | fifo_runlist_timeslice_timescale_3_f() | fifo_runlist_timeslice_enable_true_f()); - gk20a_mem_wr32(g, mem, ram_fc_pb_timeslice_w(), + nvgpu_mem_wr32(g, mem, ram_fc_pb_timeslice_w(), fifo_pb_timeslice_timeout_16_f() | fifo_pb_timeslice_timescale_0_f() | fifo_pb_timeslice_enable_true_f()); - gk20a_mem_wr32(g, mem, ram_fc_chid_w(), ram_fc_chid_id_f(c->hw_chid)); + nvgpu_mem_wr32(g, mem, ram_fc_chid_w(), ram_fc_chid_id_f(c->hw_chid)); if (c->is_privileged_channel) gk20a_fifo_setup_ramfc_for_privileged_channel(c); @@ -4035,7 +4035,7 @@ static int channel_gk20a_set_schedule_params(struct channel_gk20a *c) WARN_ON(c->g->ops.fifo.preempt_channel(c->g, c->hw_chid)); /* set new timeslice */ - gk20a_mem_wr32(c->g, &c->inst_block, ram_fc_runlist_timeslice_w(), + nvgpu_mem_wr32(c->g, &c->inst_block, ram_fc_runlist_timeslice_w(), value | (shift << 12) | fifo_runlist_timeslice_enable_true_f()); @@ -4102,7 +4102,7 @@ void gk20a_fifo_setup_ramfc_for_privileged_channel(struct channel_gk20a *c) gk20a_dbg_info("channel %d : set ramfc privileged_channel", c->hw_chid); /* Enable HCE priv mode for phys mode transfer */ - gk20a_mem_wr32(g, mem, ram_fc_hce_ctrl_w(), + nvgpu_mem_wr32(g, mem, ram_fc_hce_ctrl_w(), pbdma_hce_ctrl_hce_priv_mode_yes_f()); } @@ -4114,16 +4114,16 @@ int gk20a_fifo_setup_userd(struct channel_gk20a *c) gk20a_dbg_fn(""); - gk20a_mem_wr32(g, mem, offset + ram_userd_put_w(), 0); - gk20a_mem_wr32(g, mem, offset + ram_userd_get_w(), 0); - gk20a_mem_wr32(g, mem, offset + ram_userd_ref_w(), 0); - gk20a_mem_wr32(g, mem, offset + ram_userd_put_hi_w(), 0); - gk20a_mem_wr32(g, mem, offset + ram_userd_ref_threshold_w(), 0); - gk20a_mem_wr32(g, mem, offset + ram_userd_gp_top_level_get_w(), 0); - gk20a_mem_wr32(g, mem, offset + ram_userd_gp_top_level_get_hi_w(), 0); - gk20a_mem_wr32(g, mem, offset + ram_userd_get_hi_w(), 0); - gk20a_mem_wr32(g, mem, offset + ram_userd_gp_get_w(), 0); - gk20a_mem_wr32(g, mem, offset + ram_userd_gp_put_w(), 0); + nvgpu_mem_wr32(g, mem, offset + ram_userd_put_w(), 0); + nvgpu_mem_wr32(g, mem, offset + ram_userd_get_w(), 0); + nvgpu_mem_wr32(g, mem, offset + ram_userd_ref_w(), 0); + nvgpu_mem_wr32(g, mem, offset + ram_userd_put_hi_w(), 0); + nvgpu_mem_wr32(g, mem, offset + ram_userd_ref_threshold_w(), 0); + nvgpu_mem_wr32(g, mem, offset + ram_userd_gp_top_level_get_w(), 0); + nvgpu_mem_wr32(g, mem, offset + ram_userd_gp_top_level_get_hi_w(), 0); + nvgpu_mem_wr32(g, mem, offset + ram_userd_get_hi_w(), 0); + nvgpu_mem_wr32(g, mem, offset + ram_userd_gp_get_w(), 0); + nvgpu_mem_wr32(g, mem, offset + ram_userd_gp_put_w(), 0); return 0; } diff --git a/drivers/gpu/nvgpu/gk20a/gk20a.h b/drivers/gpu/nvgpu/gk20a/gk20a.h index 2a9f8a06..db7b3c5d 100644 --- a/drivers/gpu/nvgpu/gk20a/gk20a.h +++ b/drivers/gpu/nvgpu/gk20a/gk20a.h @@ -617,7 +617,7 @@ struct gpu_ops { bool sparse, bool priv, struct vm_gk20a_mapping_batch *batch, - enum gk20a_aperture aperture); + enum nvgpu_aperture aperture); void (*gmmu_unmap)(struct vm_gk20a *vm, u64 vaddr, u64 size, diff --git a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c index 3e9a388b..360b8c97 100644 --- a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c @@ -110,13 +110,13 @@ int gr_gk20a_get_ctx_id(struct gk20a *g, Flush and invalidate before cpu update. */ g->ops.mm.l2_flush(g, true); - if (gk20a_mem_begin(g, &ch_ctx->gr_ctx->mem)) + if (nvgpu_mem_begin(g, &ch_ctx->gr_ctx->mem)) return -ENOMEM; - *ctx_id = gk20a_mem_rd(g, &ch_ctx->gr_ctx->mem, + *ctx_id = nvgpu_mem_rd(g, &ch_ctx->gr_ctx->mem, ctxsw_prog_main_image_context_id_o()); - gk20a_mem_end(g, &ch_ctx->gr_ctx->mem); + nvgpu_mem_end(g, &ch_ctx->gr_ctx->mem); return 0; } @@ -649,11 +649,11 @@ int gr_gk20a_commit_inst(struct channel_gk20a *c, u64 gpu_va) addr_lo = u64_lo32(gpu_va) >> 12; addr_hi = u64_hi32(gpu_va); - gk20a_mem_wr32(c->g, &c->inst_block, ram_in_gr_wfi_target_w(), + nvgpu_mem_wr32(c->g, &c->inst_block, ram_in_gr_wfi_target_w(), ram_in_gr_cs_wfi_f() | ram_in_gr_wfi_mode_virtual_f() | ram_in_gr_wfi_ptr_lo_f(addr_lo)); - gk20a_mem_wr32(c->g, &c->inst_block, ram_in_gr_wfi_ptr_hi_w(), + nvgpu_mem_wr32(c->g, &c->inst_block, ram_in_gr_wfi_ptr_hi_w(), ram_in_gr_wfi_ptr_hi_f(addr_hi)); return 0; @@ -670,16 +670,16 @@ int gr_gk20a_commit_inst(struct channel_gk20a *c, u64 gpu_va) int gr_gk20a_ctx_patch_write_begin(struct gk20a *g, struct channel_ctx_gk20a *ch_ctx) { - return gk20a_mem_begin(g, &ch_ctx->patch_ctx.mem); + return nvgpu_mem_begin(g, &ch_ctx->patch_ctx.mem); } void gr_gk20a_ctx_patch_write_end(struct gk20a *g, struct channel_ctx_gk20a *ch_ctx) { - gk20a_mem_end(g, &ch_ctx->patch_ctx.mem); + nvgpu_mem_end(g, &ch_ctx->patch_ctx.mem); /* Write context count to context image if it is mapped */ if (ch_ctx->gr_ctx->mem.cpu_va) { - gk20a_mem_wr(g, &ch_ctx->gr_ctx->mem, + nvgpu_mem_wr(g, &ch_ctx->gr_ctx->mem, ctxsw_prog_main_image_patch_count_o(), ch_ctx->patch_ctx.data_count); } @@ -691,8 +691,8 @@ void gr_gk20a_ctx_patch_write(struct gk20a *g, { if (patch) { u32 patch_slot = ch_ctx->patch_ctx.data_count * 2; - gk20a_mem_wr32(g, &ch_ctx->patch_ctx.mem, patch_slot, addr); - gk20a_mem_wr32(g, &ch_ctx->patch_ctx.mem, patch_slot + 1, data); + nvgpu_mem_wr32(g, &ch_ctx->patch_ctx.mem, patch_slot, addr); + nvgpu_mem_wr32(g, &ch_ctx->patch_ctx.mem, patch_slot + 1, data); ch_ctx->patch_ctx.data_count++; } else { gk20a_writel(g, addr, data); @@ -703,7 +703,7 @@ static u32 fecs_current_ctx_data(struct gk20a *g, struct mem_desc *inst_block) { u32 ptr = u64_lo32(gk20a_mm_inst_block_addr(g, inst_block) >> ram_in_base_shift_v()); - u32 aperture = gk20a_aperture_mask(g, inst_block, + u32 aperture = nvgpu_aperture_mask(g, inst_block, gr_fecs_current_ctx_target_sys_mem_ncoh_f(), gr_fecs_current_ctx_target_vid_mem_f()); @@ -745,7 +745,7 @@ void gr_gk20a_write_zcull_ptr(struct gk20a *g, { u32 va = u64_lo32(gpu_va >> 8); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_zcull_ptr_o(), va); } @@ -754,7 +754,7 @@ void gr_gk20a_write_pm_ptr(struct gk20a *g, { u32 va = u64_lo32(gpu_va >> 8); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_pm_ptr_o(), va); } @@ -768,10 +768,10 @@ static int gr_gk20a_ctx_zcull_setup(struct gk20a *g, struct channel_gk20a *c) gk20a_dbg_fn(""); - if (gk20a_mem_begin(g, mem)) + if (nvgpu_mem_begin(g, mem)) return -ENOMEM; - if (gk20a_mem_begin(g, ctxheader)) { + if (nvgpu_mem_begin(g, ctxheader)) { ret = -ENOMEM; goto clean_up_mem; } @@ -795,7 +795,7 @@ static int gr_gk20a_ctx_zcull_setup(struct gk20a *g, struct channel_gk20a *c) goto clean_up; } - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_zcull_o(), ch_ctx->zcull_ctx.ctx_sw_mode); @@ -808,9 +808,9 @@ static int gr_gk20a_ctx_zcull_setup(struct gk20a *g, struct channel_gk20a *c) gk20a_enable_channel_tsg(g, c); clean_up: - gk20a_mem_end(g, ctxheader); + nvgpu_mem_end(g, ctxheader); clean_up_mem: - gk20a_mem_end(g, mem); + nvgpu_mem_end(g, mem); return ret; } @@ -1756,10 +1756,10 @@ restore_fe_go_idle: goto restore_fe_go_idle; } - if (gk20a_mem_begin(g, gold_mem)) + if (nvgpu_mem_begin(g, gold_mem)) goto clean_up; - if (gk20a_mem_begin(g, gr_mem)) + if (nvgpu_mem_begin(g, gr_mem)) goto clean_up; ctx_header_words = roundup(ctx_header_bytes, sizeof(u32)); @@ -1768,26 +1768,26 @@ restore_fe_go_idle: g->ops.mm.l2_flush(g, true); for (i = 0; i < ctx_header_words; i++) { - data = gk20a_mem_rd32(g, gr_mem, i); - gk20a_mem_wr32(g, gold_mem, i, data); + data = nvgpu_mem_rd32(g, gr_mem, i); + nvgpu_mem_wr32(g, gold_mem, i, data); } - gk20a_mem_wr(g, gold_mem, ctxsw_prog_main_image_zcull_o(), + nvgpu_mem_wr(g, gold_mem, ctxsw_prog_main_image_zcull_o(), ctxsw_prog_main_image_zcull_mode_no_ctxsw_v()); - if (gk20a_mem_begin(g, ctxheader)) + if (nvgpu_mem_begin(g, ctxheader)) goto clean_up; if (ctxheader->gpu_va) g->ops.gr.write_zcull_ptr(g, ctxheader, 0); else g->ops.gr.write_zcull_ptr(g, gold_mem, 0); - gk20a_mem_end(g, ctxheader); + nvgpu_mem_end(g, ctxheader); g->ops.gr.commit_inst(c, ch_ctx->global_ctx_buffer_va[GOLDEN_CTX_VA]); gr_gk20a_fecs_ctx_image_save(c, gr_fecs_method_push_adr_wfi_golden_save_v()); - if (gk20a_mem_begin(g, ctxheader)) + if (nvgpu_mem_begin(g, ctxheader)) goto clean_up; if (gr->ctx_vars.local_golden_image == NULL) { @@ -1801,15 +1801,15 @@ restore_fe_go_idle: } if (ctxheader->gpu_va) - gk20a_mem_rd_n(g, ctxheader, 0, + nvgpu_mem_rd_n(g, ctxheader, 0, gr->ctx_vars.local_golden_image, gr->ctx_vars.golden_image_size); else - gk20a_mem_rd_n(g, gold_mem, 0, + nvgpu_mem_rd_n(g, gold_mem, 0, gr->ctx_vars.local_golden_image, gr->ctx_vars.golden_image_size); } - gk20a_mem_end(g, ctxheader); + nvgpu_mem_end(g, ctxheader); g->ops.gr.commit_inst(c, gr_mem->gpu_va); @@ -1824,8 +1824,8 @@ clean_up: else gk20a_dbg_fn("done"); - gk20a_mem_end(g, gold_mem); - gk20a_mem_end(g, gr_mem); + nvgpu_mem_end(g, gold_mem); + nvgpu_mem_end(g, gr_mem); nvgpu_mutex_release(&gr->ctx_mutex); return err; @@ -1865,22 +1865,22 @@ int gr_gk20a_update_smpc_ctxsw_mode(struct gk20a *g, Flush and invalidate before cpu update. */ g->ops.mm.l2_flush(g, true); - if (gk20a_mem_begin(g, mem)) { + if (nvgpu_mem_begin(g, mem)) { ret = -ENOMEM; goto out; } - data = gk20a_mem_rd(g, mem, + data = nvgpu_mem_rd(g, mem, ctxsw_prog_main_image_pm_o()); data = data & ~ctxsw_prog_main_image_pm_smpc_mode_m(); data |= enable_smpc_ctxsw ? ctxsw_prog_main_image_pm_smpc_mode_ctxsw_f() : ctxsw_prog_main_image_pm_smpc_mode_no_ctxsw_f(); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_pm_o(), data); - gk20a_mem_end(g, mem); + nvgpu_mem_end(g, mem); out: gk20a_enable_channel_tsg(g, c); @@ -1964,27 +1964,27 @@ int gr_gk20a_update_hwpm_ctxsw_mode(struct gk20a *g, } /* Now clear the buffer */ - if (gk20a_mem_begin(g, &pm_ctx->mem)) { + if (nvgpu_mem_begin(g, &pm_ctx->mem)) { ret = -ENOMEM; goto cleanup_pm_buf; } - gk20a_memset(g, &pm_ctx->mem, 0, 0, pm_ctx->mem.size); + nvgpu_memset(g, &pm_ctx->mem, 0, 0, pm_ctx->mem.size); - gk20a_mem_end(g, &pm_ctx->mem); + nvgpu_mem_end(g, &pm_ctx->mem); } - if (gk20a_mem_begin(g, gr_mem)) { + if (nvgpu_mem_begin(g, gr_mem)) { ret = -ENOMEM; goto cleanup_pm_buf; } - if (gk20a_mem_begin(g, ctxheader)) { + if (nvgpu_mem_begin(g, ctxheader)) { ret = -ENOMEM; goto clean_up_mem; } - data = gk20a_mem_rd(g, gr_mem, ctxsw_prog_main_image_pm_o()); + data = nvgpu_mem_rd(g, gr_mem, ctxsw_prog_main_image_pm_o()); data = data & ~ctxsw_prog_main_image_pm_mode_m(); if (enable_hwpm_ctxsw) { @@ -1998,22 +1998,22 @@ int gr_gk20a_update_hwpm_ctxsw_mode(struct gk20a *g, data |= pm_ctx->pm_mode; - gk20a_mem_wr(g, gr_mem, ctxsw_prog_main_image_pm_o(), data); + nvgpu_mem_wr(g, gr_mem, ctxsw_prog_main_image_pm_o(), data); if (ctxheader->gpu_va) g->ops.gr.write_pm_ptr(g, ctxheader, virt_addr); else g->ops.gr.write_pm_ptr(g, gr_mem, virt_addr); - gk20a_mem_end(g, ctxheader); - gk20a_mem_end(g, gr_mem); + nvgpu_mem_end(g, ctxheader); + nvgpu_mem_end(g, gr_mem); /* enable channel */ gk20a_enable_channel_tsg(g, c); return 0; clean_up_mem: - gk20a_mem_end(g, gr_mem); + nvgpu_mem_end(g, gr_mem); cleanup_pm_buf: gk20a_gmmu_unmap(c->vm, pm_ctx->mem.gpu_va, pm_ctx->mem.size, gk20a_mem_flag_none); @@ -2048,10 +2048,10 @@ int gr_gk20a_load_golden_ctx_image(struct gk20a *g, Flush and invalidate before cpu update. */ g->ops.mm.l2_flush(g, true); - if (gk20a_mem_begin(g, mem)) + if (nvgpu_mem_begin(g, mem)) return -ENOMEM; - if (gk20a_mem_begin(g, ctxheader)) { + if (nvgpu_mem_begin(g, ctxheader)) { ret = -ENOMEM; goto clean_up_mem; } @@ -2060,12 +2060,12 @@ int gr_gk20a_load_golden_ctx_image(struct gk20a *g, if (g->ops.gr.restore_context_header) g->ops.gr.restore_context_header(g, ctxheader); } else { - gk20a_mem_wr_n(g, mem, 0, + nvgpu_mem_wr_n(g, mem, 0, gr->ctx_vars.local_golden_image, gr->ctx_vars.golden_image_size); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_num_save_ops_o(), 0); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_num_restore_ops_o(), 0); } @@ -2083,29 +2083,29 @@ int gr_gk20a_load_golden_ctx_image(struct gk20a *g, else data = ctxsw_prog_main_image_priv_access_map_config_mode_use_map_f(); - gk20a_mem_wr(g, mem, ctxsw_prog_main_image_priv_access_map_config_o(), + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_priv_access_map_config_o(), data); if (ctxheader->gpu_va) { - gk20a_mem_wr(g, ctxheader, + nvgpu_mem_wr(g, ctxheader, ctxsw_prog_main_image_priv_access_map_addr_lo_o(), virt_addr_lo); - gk20a_mem_wr(g, ctxheader, + nvgpu_mem_wr(g, ctxheader, ctxsw_prog_main_image_priv_access_map_addr_hi_o(), virt_addr_hi); } else { - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_priv_access_map_addr_lo_o(), virt_addr_lo); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_priv_access_map_addr_hi_o(), virt_addr_hi); } /* disable verif features */ - v = gk20a_mem_rd(g, mem, ctxsw_prog_main_image_misc_options_o()); + v = nvgpu_mem_rd(g, mem, ctxsw_prog_main_image_misc_options_o()); v = v & ~(ctxsw_prog_main_image_misc_options_verif_features_m()); v = v | ctxsw_prog_main_image_misc_options_verif_features_disabled_f(); - gk20a_mem_wr(g, mem, ctxsw_prog_main_image_misc_options_o(), v); + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_misc_options_o(), v); if (g->ops.gr.update_ctxsw_preemption_mode) g->ops.gr.update_ctxsw_preemption_mode(g, ch_ctx, mem); @@ -2116,26 +2116,26 @@ int gr_gk20a_load_golden_ctx_image(struct gk20a *g, virt_addr_lo = u64_lo32(ch_ctx->patch_ctx.mem.gpu_va); virt_addr_hi = u64_hi32(ch_ctx->patch_ctx.mem.gpu_va); - gk20a_mem_wr(g, mem, ctxsw_prog_main_image_patch_count_o(), + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_patch_count_o(), ch_ctx->patch_ctx.data_count); - gk20a_mem_wr(g, mem, ctxsw_prog_main_image_patch_adr_lo_o(), + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_patch_adr_lo_o(), virt_addr_lo); - gk20a_mem_wr(g, mem, ctxsw_prog_main_image_patch_adr_hi_o(), + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_patch_adr_hi_o(), virt_addr_hi); if (ctxheader->gpu_va) { - gk20a_mem_wr(g, ctxheader, + nvgpu_mem_wr(g, ctxheader, ctxsw_prog_main_image_patch_count_o(), ch_ctx->patch_ctx.data_count); - gk20a_mem_wr(g, ctxheader, + nvgpu_mem_wr(g, ctxheader, ctxsw_prog_main_image_patch_adr_lo_o(), virt_addr_lo); - gk20a_mem_wr(g, ctxheader, + nvgpu_mem_wr(g, ctxheader, ctxsw_prog_main_image_patch_adr_hi_o(), virt_addr_hi); } - gk20a_mem_wr(g, mem, ctxsw_prog_main_image_zcull_o(), + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_zcull_o(), ch_ctx->zcull_ctx.ctx_sw_mode); if (ctxheader->gpu_va) @@ -2153,7 +2153,7 @@ int gr_gk20a_load_golden_ctx_image(struct gk20a *g, if (ch_ctx->pm_ctx.mem.gpu_va == 0) { gk20a_err(dev_from_gk20a(g), "context switched pm with no pm buffer!"); - gk20a_mem_end(g, mem); + nvgpu_mem_end(g, mem); return -EFAULT; } @@ -2161,11 +2161,11 @@ int gr_gk20a_load_golden_ctx_image(struct gk20a *g, } else virt_addr = 0; - data = gk20a_mem_rd(g, mem, ctxsw_prog_main_image_pm_o()); + data = nvgpu_mem_rd(g, mem, ctxsw_prog_main_image_pm_o()); data = data & ~ctxsw_prog_main_image_pm_mode_m(); data |= ch_ctx->pm_ctx.pm_mode; - gk20a_mem_wr(g, mem, ctxsw_prog_main_image_pm_o(), data); + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_pm_o(), data); if (ctxheader->gpu_va) g->ops.gr.write_pm_ptr(g, ctxheader, virt_addr); @@ -2173,9 +2173,9 @@ int gr_gk20a_load_golden_ctx_image(struct gk20a *g, g->ops.gr.write_pm_ptr(g, mem, virt_addr); - gk20a_mem_end(g, ctxheader); + nvgpu_mem_end(g, ctxheader); clean_up_mem: - gk20a_mem_end(g, mem); + nvgpu_mem_end(g, mem); return ret; } @@ -2256,11 +2256,11 @@ static int gr_gk20a_copy_ctxsw_ucode_segments( { unsigned int i; - gk20a_mem_wr_n(g, dst, segments->boot.offset, bootimage, + nvgpu_mem_wr_n(g, dst, segments->boot.offset, bootimage, segments->boot.size); - gk20a_mem_wr_n(g, dst, segments->code.offset, code, + nvgpu_mem_wr_n(g, dst, segments->code.offset, code, segments->code.size); - gk20a_mem_wr_n(g, dst, segments->data.offset, data, + nvgpu_mem_wr_n(g, dst, segments->data.offset, data, segments->data.size); /* compute a "checksum" for the boot binary to detect its version */ @@ -2382,14 +2382,14 @@ void gr_gk20a_load_falcon_bind_instblk(struct gk20a *g) inst_ptr = gk20a_mm_inst_block_addr(g, &ucode_info->inst_blk_desc); gk20a_writel(g, gr_fecs_new_ctx_r(), gr_fecs_new_ctx_ptr_f(inst_ptr >> 12) | - gk20a_aperture_mask(g, &ucode_info->inst_blk_desc, + nvgpu_aperture_mask(g, &ucode_info->inst_blk_desc, gr_fecs_new_ctx_target_sys_mem_ncoh_f(), gr_fecs_new_ctx_target_vid_mem_f()) | gr_fecs_new_ctx_valid_m()); gk20a_writel(g, gr_fecs_arb_ctx_ptr_r(), gr_fecs_arb_ctx_ptr_ptr_f(inst_ptr >> 12) | - gk20a_aperture_mask(g, &ucode_info->inst_blk_desc, + nvgpu_aperture_mask(g, &ucode_info->inst_blk_desc, gr_fecs_arb_ctx_ptr_target_sys_mem_ncoh_f(), gr_fecs_arb_ctx_ptr_target_vid_mem_f())); @@ -4748,7 +4748,7 @@ static int gk20a_init_gr_setup_hw(struct gk20a *g) addr >>= fb_mmu_debug_wr_addr_alignment_v(); gk20a_writel(g, fb_mmu_debug_wr_r(), - gk20a_aperture_mask(g, &gr->mmu_wr_mem, + nvgpu_aperture_mask(g, &gr->mmu_wr_mem, fb_mmu_debug_wr_aperture_sys_mem_ncoh_f(), fb_mmu_debug_wr_aperture_vid_mem_f()) | fb_mmu_debug_wr_vol_false_f() | @@ -4758,7 +4758,7 @@ static int gk20a_init_gr_setup_hw(struct gk20a *g) addr >>= fb_mmu_debug_rd_addr_alignment_v(); gk20a_writel(g, fb_mmu_debug_rd_r(), - gk20a_aperture_mask(g, &gr->mmu_rd_mem, + nvgpu_aperture_mask(g, &gr->mmu_rd_mem, fb_mmu_debug_wr_aperture_sys_mem_ncoh_f(), fb_mmu_debug_rd_aperture_vid_mem_f()) | fb_mmu_debug_rd_vol_false_f() | @@ -5092,13 +5092,13 @@ static int gr_gk20a_init_access_map(struct gk20a *g) u32 *whitelist = NULL; unsigned int num_entries = 0; - if (gk20a_mem_begin(g, mem)) { + if (nvgpu_mem_begin(g, mem)) { gk20a_err(dev_from_gk20a(g), "failed to map priv access map memory"); return -ENOMEM; } - gk20a_memset(g, mem, 0, 0, PAGE_SIZE * nr_pages); + nvgpu_memset(g, mem, 0, 0, PAGE_SIZE * nr_pages); g->ops.gr.get_access_map(g, &whitelist, &num_entries); @@ -5109,14 +5109,14 @@ static int gr_gk20a_init_access_map(struct gk20a *g) map_shift = map_bit & 0x7; /* i.e. 0-7 */ gk20a_dbg_info("access map addr:0x%x byte:0x%x bit:%d", whitelist[w], map_byte, map_shift); - x = gk20a_mem_rd32(g, mem, map_byte / sizeof(u32)); + x = nvgpu_mem_rd32(g, mem, map_byte / sizeof(u32)); x |= 1 << ( (map_byte % sizeof(u32) * BITS_PER_BYTE) + map_shift); - gk20a_mem_wr32(g, mem, map_byte / sizeof(u32), x); + nvgpu_mem_wr32(g, mem, map_byte / sizeof(u32), x); } - gk20a_mem_end(g, mem); + nvgpu_mem_end(g, mem); return 0; } @@ -7160,7 +7160,7 @@ static int gr_gk20a_ctx_patch_smpc(struct gk20a *g, /* reset the patch count from previous runs,if ucode has already processed it */ - tmp = gk20a_mem_rd(g, mem, + tmp = nvgpu_mem_rd(g, mem, ctxsw_prog_main_image_patch_count_o()); if (!tmp) @@ -7172,13 +7172,13 @@ static int gr_gk20a_ctx_patch_smpc(struct gk20a *g, vaddr_lo = u64_lo32(ch_ctx->patch_ctx.mem.gpu_va); vaddr_hi = u64_hi32(ch_ctx->patch_ctx.mem.gpu_va); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_patch_count_o(), ch_ctx->patch_ctx.data_count); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_patch_adr_lo_o(), vaddr_lo); - gk20a_mem_wr(g, mem, + nvgpu_mem_wr(g, mem, ctxsw_prog_main_image_patch_adr_hi_o(), vaddr_hi); @@ -8393,7 +8393,7 @@ int gr_gk20a_exec_ctx_ops(struct channel_gk20a *ch, * gr_gk20a_apply_instmem_overrides, * recoded in-place instead. */ - if (gk20a_mem_begin(g, &ch_ctx->gr_ctx->mem)) { + if (nvgpu_mem_begin(g, &ch_ctx->gr_ctx->mem)) { err = -ENOMEM; goto cleanup; } @@ -8422,7 +8422,7 @@ int gr_gk20a_exec_ctx_ops(struct channel_gk20a *ch, err = -EINVAL; goto cleanup; } - if (gk20a_mem_begin(g, &ch_ctx->pm_ctx.mem)) { + if (nvgpu_mem_begin(g, &ch_ctx->pm_ctx.mem)) { err = -ENOMEM; goto cleanup; } @@ -8445,20 +8445,20 @@ int gr_gk20a_exec_ctx_ops(struct channel_gk20a *ch, (offsets[j] >= g->gr.ctx_vars.golden_image_size)) continue; if (pass == 0) { /* write pass */ - v = gk20a_mem_rd(g, current_mem, offsets[j]); + v = nvgpu_mem_rd(g, current_mem, offsets[j]); v &= ~ctx_ops[i].and_n_mask_lo; v |= ctx_ops[i].value_lo; - gk20a_mem_wr(g, current_mem, offsets[j], v); + nvgpu_mem_wr(g, current_mem, offsets[j], v); gk20a_dbg(gpu_dbg_gpu_dbg, "context wr: offset=0x%x v=0x%x", offsets[j], v); if (ctx_ops[i].op == REGOP(WRITE_64)) { - v = gk20a_mem_rd(g, current_mem, offsets[j] + 4); + v = nvgpu_mem_rd(g, current_mem, offsets[j] + 4); v &= ~ctx_ops[i].and_n_mask_hi; v |= ctx_ops[i].value_hi; - gk20a_mem_wr(g, current_mem, offsets[j] + 4, v); + nvgpu_mem_wr(g, current_mem, offsets[j] + 4, v); gk20a_dbg(gpu_dbg_gpu_dbg, "context wr: offset=0x%x v=0x%x", @@ -8472,14 +8472,14 @@ int gr_gk20a_exec_ctx_ops(struct channel_gk20a *ch, } else { /* read pass */ ctx_ops[i].value_lo = - gk20a_mem_rd(g, current_mem, offsets[0]); + nvgpu_mem_rd(g, current_mem, offsets[0]); gk20a_dbg(gpu_dbg_gpu_dbg, "context rd: offset=0x%x v=0x%x", offsets[0], ctx_ops[i].value_lo); if (ctx_ops[i].op == REGOP(READ_64)) { ctx_ops[i].value_hi = - gk20a_mem_rd(g, current_mem, offsets[0] + 4); + nvgpu_mem_rd(g, current_mem, offsets[0] + 4); gk20a_dbg(gpu_dbg_gpu_dbg, "context rd: offset=0x%x v=0x%x", @@ -8507,9 +8507,9 @@ int gr_gk20a_exec_ctx_ops(struct channel_gk20a *ch, if (ch_ctx->patch_ctx.mem.cpu_va) gr_gk20a_ctx_patch_write_end(g, ch_ctx); if (gr_ctx_ready) - gk20a_mem_end(g, &ch_ctx->gr_ctx->mem); + nvgpu_mem_end(g, &ch_ctx->gr_ctx->mem); if (pm_ctx_ready) - gk20a_mem_end(g, &ch_ctx->pm_ctx.mem); + nvgpu_mem_end(g, &ch_ctx->pm_ctx.mem); if (restart_gr_ctxsw) { int tmp_err = gr_gk20a_enable_ctxsw(g); diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c index e78eb941..9c9fad1b 100644 --- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c @@ -34,6 +34,7 @@ #include #include #include +#include #include #include #include @@ -139,7 +140,7 @@ static int update_gmmu_ptes_locked(struct vm_gk20a *vm, bool umapped_pte, int rw_flag, bool sparse, bool priv, - enum gk20a_aperture aperture); + enum nvgpu_aperture aperture); static int __must_check gk20a_init_system_vm(struct mm_gk20a *mm); static int __must_check gk20a_init_bar1_vm(struct mm_gk20a *mm); static int __must_check gk20a_init_hwpm(struct mm_gk20a *mm); @@ -945,7 +946,7 @@ int map_gmmu_pages(struct gk20a *g, struct gk20a_mm_entry *entry) sg_phys(entry->mem.sgt->sgl), entry->mem.size); } else { - int err = gk20a_mem_begin(g, &entry->mem); + int err = nvgpu_mem_begin(g, &entry->mem); if (err) return err; @@ -971,7 +972,7 @@ void unmap_gmmu_pages(struct gk20a *g, struct gk20a_mm_entry *entry) sg_phys(entry->mem.sgt->sgl), entry->mem.size); } else { - gk20a_mem_end(g, &entry->mem); + nvgpu_mem_end(g, &entry->mem); } } @@ -1510,7 +1511,7 @@ u64 gk20a_locked_gmmu_map(struct vm_gk20a *vm, bool sparse, bool priv, struct vm_gk20a_mapping_batch *batch, - enum gk20a_aperture aperture) + enum nvgpu_aperture aperture) { int err = 0; bool allocated = false; @@ -1543,7 +1544,7 @@ u64 gk20a_locked_gmmu_map(struct vm_gk20a *vm, sgt ? lo32((u64)sg_phys(sgt->sgl)) : 0, vm->gmmu_page_sizes[pgsz_idx] >> 10, vm_aspace_id(vm), ctag_lines, ctag_offset, - kind_v, flags, gk20a_aperture_str(aperture)); + kind_v, flags, nvgpu_aperture_str(aperture)); err = update_gmmu_ptes_locked(vm, pgsz_idx, sgt, @@ -1634,7 +1635,7 @@ void gk20a_locked_gmmu_unmap(struct vm_gk20a *vm, } } -static enum gk20a_aperture gk20a_dmabuf_aperture(struct gk20a *g, +static enum nvgpu_aperture gk20a_dmabuf_aperture(struct gk20a *g, struct dma_buf *dmabuf) { struct gk20a *buf_owner = gk20a_vidmem_buf_owner(dmabuf); @@ -1723,7 +1724,7 @@ static u64 gk20a_vm_map_duplicate_locked(struct vm_gk20a *vm, vm_aspace_id(vm), mapped_buffer->ctag_lines, mapped_buffer->ctag_offset, mapped_buffer->flags, - gk20a_aperture_str(gk20a_dmabuf_aperture(g, dmabuf))); + nvgpu_aperture_str(gk20a_dmabuf_aperture(g, dmabuf))); if (sgt) *sgt = mapped_buffer->sgt; @@ -1941,11 +1942,11 @@ int gk20a_vidbuf_access_memory(struct gk20a *g, struct dma_buf *dmabuf, switch (cmd) { case NVGPU_DBG_GPU_IOCTL_ACCESS_FB_MEMORY_CMD_READ: - gk20a_mem_rd_n(g, mem, offset, buffer, size); + nvgpu_mem_rd_n(g, mem, offset, buffer, size); break; case NVGPU_DBG_GPU_IOCTL_ACCESS_FB_MEMORY_CMD_WRITE: - gk20a_mem_wr_n(g, mem, offset, buffer, size); + nvgpu_mem_wr_n(g, mem, offset, buffer, size); break; default: @@ -1959,7 +1960,7 @@ int gk20a_vidbuf_access_memory(struct gk20a *g, struct dma_buf *dmabuf, } static u64 gk20a_mm_get_align(struct gk20a *g, struct scatterlist *sgl, - enum gk20a_aperture aperture) + enum nvgpu_aperture aperture) { u64 align = 0, chunk_align = 0; u64 buf_addr; @@ -2030,7 +2031,7 @@ u64 gk20a_vm_map(struct vm_gk20a *vm, u32 ctag_map_win_ctagline = 0; struct vm_reserved_va_node *va_node = NULL; u32 ctag_offset; - enum gk20a_aperture aperture; + enum nvgpu_aperture aperture; if (user_mapped && vm->userspace_managed && !(flags & NVGPU_AS_MAP_BUFFER_FLAGS_FIXED_OFFSET)) { @@ -2462,7 +2463,7 @@ static u64 __gk20a_gmmu_map(struct vm_gk20a *vm, u32 flags, int rw_flag, bool priv, - enum gk20a_aperture aperture) + enum nvgpu_aperture aperture) { struct gk20a *g = gk20a_from_vm(vm); u64 vaddr; @@ -2496,7 +2497,7 @@ u64 gk20a_gmmu_map(struct vm_gk20a *vm, u32 flags, int rw_flag, bool priv, - enum gk20a_aperture aperture) + enum nvgpu_aperture aperture) { return __gk20a_gmmu_map(vm, sgt, 0, size, flags, rw_flag, priv, aperture); @@ -2512,7 +2513,7 @@ u64 gk20a_gmmu_fixed_map(struct vm_gk20a *vm, u32 flags, int rw_flag, bool priv, - enum gk20a_aperture aperture) + enum nvgpu_aperture aperture) { return __gk20a_gmmu_map(vm, sgt, addr, size, flags, rw_flag, priv, aperture); @@ -2851,7 +2852,7 @@ static void gk20a_gmmu_free_vid(struct gk20a *g, struct mem_desc *mem) schedule_work(&g->mm.vidmem.clear_mem_worker); } } else { - gk20a_memset(g, mem, 0, 0, mem->size); + nvgpu_memset(g, mem, 0, 0, mem->size); nvgpu_free(mem->allocator, (u64)get_vidmem_page_alloc(mem->sgt->sgl)); gk20a_free_sgtable(g, &mem->sgt); @@ -3170,7 +3171,7 @@ u64 gk20a_mm_iova_addr(struct gk20a *g, struct scatterlist *sgl, void gk20a_pde_wr32(struct gk20a *g, struct gk20a_mm_entry *entry, size_t w, size_t data) { - gk20a_mem_wr32(g, &entry->mem, entry->woffset + w, data); + nvgpu_mem_wr32(g, &entry->mem, entry->woffset + w, data); } u64 gk20a_pde_addr(struct gk20a *g, struct gk20a_mm_entry *entry) @@ -3191,7 +3192,7 @@ static inline u32 big_valid_pde0_bits(struct gk20a *g, { u64 pte_addr = gk20a_pde_addr(g, entry); u32 pde0_bits = - gk20a_aperture_mask(g, &entry->mem, + nvgpu_aperture_mask(g, &entry->mem, gmmu_pde_aperture_big_sys_mem_ncoh_f(), gmmu_pde_aperture_big_video_memory_f()) | gmmu_pde_address_big_sys_f( @@ -3205,7 +3206,7 @@ static inline u32 small_valid_pde1_bits(struct gk20a *g, { u64 pte_addr = gk20a_pde_addr(g, entry); u32 pde1_bits = - gk20a_aperture_mask(g, &entry->mem, + nvgpu_aperture_mask(g, &entry->mem, gmmu_pde_aperture_small_sys_mem_ncoh_f(), gmmu_pde_aperture_small_video_memory_f()) | gmmu_pde_vol_small_true_f() | /* tbd: why? */ @@ -3230,7 +3231,7 @@ static int update_gmmu_pde_locked(struct vm_gk20a *vm, u32 kind_v, u64 *ctag, bool cacheable, bool unammped_pte, int rw_flag, bool sparse, bool priv, - enum gk20a_aperture aperture) + enum nvgpu_aperture aperture) { struct gk20a *g = gk20a_from_vm(vm); bool small_valid, big_valid; @@ -3275,7 +3276,7 @@ static int update_gmmu_pte_locked(struct vm_gk20a *vm, u32 kind_v, u64 *ctag, bool cacheable, bool unmapped_pte, int rw_flag, bool sparse, bool priv, - enum gk20a_aperture aperture) + enum nvgpu_aperture aperture) { struct gk20a *g = gk20a_from_vm(vm); int ctag_shift = ilog2(g->ops.fb.compression_page_size(g)); @@ -3296,7 +3297,7 @@ static int update_gmmu_pte_locked(struct vm_gk20a *vm, if (priv) pte_w[0] |= gmmu_pte_privilege_true_f(); - pte_w[1] = __gk20a_aperture_mask(g, aperture, + pte_w[1] = __nvgpu_aperture_mask(g, aperture, gmmu_pte_aperture_sys_mem_ncoh_f(), gmmu_pte_aperture_video_memory_f()) | gmmu_pte_kind_f(kind_v) | @@ -3379,7 +3380,7 @@ static int update_gmmu_level_locked(struct vm_gk20a *vm, bool sparse, int lvl, bool priv, - enum gk20a_aperture aperture) + enum nvgpu_aperture aperture) { struct gk20a *g = gk20a_from_vm(vm); const struct gk20a_mmu_level *l = &vm->mmu_levels[lvl]; @@ -3477,7 +3478,7 @@ static int update_gmmu_ptes_locked(struct vm_gk20a *vm, int rw_flag, bool sparse, bool priv, - enum gk20a_aperture aperture) + enum nvgpu_aperture aperture) { struct gk20a *g = gk20a_from_vm(vm); int ctag_granularity = g->ops.fb.compression_page_size(g); @@ -4735,14 +4736,14 @@ void gk20a_mm_init_pdb(struct gk20a *g, struct mem_desc *inst_block, gk20a_dbg_info("pde pa=0x%llx", pdb_addr); - gk20a_mem_wr32(g, inst_block, ram_in_page_dir_base_lo_w(), - gk20a_aperture_mask(g, &vm->pdb.mem, + nvgpu_mem_wr32(g, inst_block, ram_in_page_dir_base_lo_w(), + nvgpu_aperture_mask(g, &vm->pdb.mem, ram_in_page_dir_base_target_sys_mem_ncoh_f(), ram_in_page_dir_base_target_vid_mem_f()) | ram_in_page_dir_base_vol_true_f() | ram_in_page_dir_base_lo_f(pdb_addr_lo)); - gk20a_mem_wr32(g, inst_block, ram_in_page_dir_base_hi_w(), + nvgpu_mem_wr32(g, inst_block, ram_in_page_dir_base_hi_w(), ram_in_page_dir_base_hi_f(pdb_addr_hi)); } @@ -4756,10 +4757,10 @@ void gk20a_init_inst_block(struct mem_desc *inst_block, struct vm_gk20a *vm, g->ops.mm.init_pdb(g, inst_block, vm); - gk20a_mem_wr32(g, inst_block, ram_in_adr_limit_lo_w(), + nvgpu_mem_wr32(g, inst_block, ram_in_adr_limit_lo_w(), u64_lo32(vm->va_limit - 1) & ~0xfff); - gk20a_mem_wr32(g, inst_block, ram_in_adr_limit_hi_w(), + nvgpu_mem_wr32(g, inst_block, ram_in_adr_limit_hi_w(), ram_in_adr_limit_hi_f(u64_hi32(vm->va_limit - 1))); if (big_page_size && g->ops.mm.set_big_page_size) diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h index da8bbb0a..3c701907 100644 --- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h +++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h @@ -220,7 +220,7 @@ struct gk20a_mmu_level { u32 kind_v, u64 *ctag, bool cacheable, bool unmapped_pte, int rw_flag, bool sparse, bool priv, - enum gk20a_aperture aperture); + enum nvgpu_aperture aperture); size_t entry_size; }; @@ -514,7 +514,7 @@ u64 gk20a_gmmu_map(struct vm_gk20a *vm, u32 flags, int rw_flag, bool priv, - enum gk20a_aperture aperture); + enum nvgpu_aperture aperture); u64 gk20a_gmmu_fixed_map(struct vm_gk20a *vm, struct sg_table **sgt, u64 addr, @@ -522,7 +522,7 @@ u64 gk20a_gmmu_fixed_map(struct vm_gk20a *vm, u32 flags, int rw_flag, bool priv, - enum gk20a_aperture aperture); + enum nvgpu_aperture aperture); /* Flags for the below gk20a_gmmu_{alloc,alloc_map}_flags* */ @@ -589,9 +589,9 @@ static inline phys_addr_t gk20a_mem_phys(struct mem_desc *mem) return 0; } -u32 __gk20a_aperture_mask(struct gk20a *g, enum gk20a_aperture aperture, +u32 __nvgpu_aperture_mask(struct gk20a *g, enum nvgpu_aperture aperture, u32 sysmem_mask, u32 vidmem_mask); -u32 gk20a_aperture_mask(struct gk20a *g, struct mem_desc *mem, +u32 nvgpu_aperture_mask(struct gk20a *g, struct mem_desc *mem, u32 sysmem_mask, u32 vidmem_mask); void gk20a_pde_wr32(struct gk20a *g, struct gk20a_mm_entry *entry, @@ -612,7 +612,7 @@ u64 gk20a_locked_gmmu_map(struct vm_gk20a *vm, bool sparse, bool priv, struct vm_gk20a_mapping_batch *batch, - enum gk20a_aperture aperture); + enum nvgpu_aperture aperture); void gk20a_gmmu_unmap(struct vm_gk20a *vm, u64 vaddr, diff --git a/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c index 3297d376..e70e50c2 100644 --- a/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c @@ -307,7 +307,7 @@ static void printtrace(struct pmu_gk20a *pmu) return; /* read pmu traces into system memory buffer */ - gk20a_mem_rd_n(g, &pmu->trace_buf, + nvgpu_mem_rd_n(g, &pmu->trace_buf, 0, tracebuffer, GK20A_PMU_TRACE_BUFSIZE); trace = (char *)tracebuffer; @@ -3155,7 +3155,7 @@ static int gk20a_prepare_ucode(struct gk20a *g) if (err) goto err_release_fw; - gk20a_mem_wr_n(g, &pmu->ucode, 0, pmu->ucode_image, + nvgpu_mem_wr_n(g, &pmu->ucode, 0, pmu->ucode_image, pmu->desc->app_start_offset + pmu->desc->app_size); return gk20a_init_pmu(pmu); @@ -4872,7 +4872,7 @@ int gk20a_pmu_cmd_post(struct gk20a *g, struct pmu_cmd *cmd, (struct flcn_mem_desc_v0 *) pv->pmu_allocation_get_fb_addr(pmu, in)); - gk20a_mem_wr_n(g, seq->in_mem, 0, + nvgpu_mem_wr_n(g, seq->in_mem, 0, payload->in.buf, payload->in.fb_size); } else { @@ -5736,7 +5736,7 @@ static int falc_trace_show(struct seq_file *s, void *data) return -ENOMEM; /* read pmu traces into system memory buffer */ - gk20a_mem_rd_n(g, &pmu->trace_buf, + nvgpu_mem_rd_n(g, &pmu->trace_buf, 0, tracebuffer, GK20A_PMU_TRACE_BUFSIZE); trace = (char *)tracebuffer; diff --git a/drivers/gpu/nvgpu/gk20a/pramin_gk20a.c b/drivers/gpu/nvgpu/gk20a/pramin_gk20a.c index bed2e9b5..7e6005a2 100644 --- a/drivers/gpu/nvgpu/gk20a/pramin_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/pramin_gk20a.c @@ -32,7 +32,7 @@ static u32 gk20a_pramin_enter(struct gk20a *g, struct mem_desc *mem, u32 hi = (u32)((addr & ~(u64)0xfffff) >> bus_bar0_window_target_bar0_window_base_shift_v()); u32 lo = (u32)(addr & 0xfffff); - u32 win = gk20a_aperture_mask(g, mem, + u32 win = nvgpu_aperture_mask(g, mem, bus_bar0_window_target_sys_mem_noncoherent_f(), bus_bar0_window_target_vid_mem_f()) | bus_bar0_window_base_f(hi); -- cgit v1.2.2