litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Steven Whitehouse <swhiteho@redhat.com>	2006-09-04 11:41:31 -0400
committer	Steven Whitehouse <swhiteho@redhat.com>	2006-09-04 11:41:31 -0400
commit	75d3b817a0b48425da921052955cc58f20bbab52 (patch)
tree	7fb2e9bf18d794a590f43397ee56f3ce917a2233 /fs/gfs2/glops.c
parent	31e77ac55f18db0ec1c724840927562ef3093ef6 (diff)

[GFS2] Tidy up bmap/inode code

As per Jan Engelhardt's third set of comments, this make various code style changes and moves the structures from format.h into super.c, which was the only place that format.h was actually used. Cc: Jan Engelhardt <jengelh@linux01.gwdg.de> Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

Diffstat (limited to 'fs/gfs2/glops.c')

-rw-r--r--

fs/gfs2/glops.c

1 files changed, 5 insertions, 7 deletions


diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c index 8e1d8ee68e2e..d3e7b082a918 100644 --- a/fs/gfs2/glops.c +++ b/fs/gfs2/glops.c
@@ -234,7 +234,6 @@ static void inode_go_sync(struct gfs2_glock *gl, int flags)
234	if (flags & DIO_RELEASE)	234	if (flags & DIO_RELEASE)
235	gfs2_ail_empty_gl(gl);	235	gfs2_ail_empty_gl(gl);
236	}	236	}
237
238	}	237	}
239		238
240	/**	239	/**
@@ -324,12 +323,11 @@ static void inode_go_unlock(struct gfs2_holder *gh)
324	struct gfs2_glock *gl = gh->gh_gl;	323	struct gfs2_glock *gl = gh->gh_gl;
325	struct gfs2_inode *ip = gl->gl_object;	324	struct gfs2_inode *ip = gl->gl_object;
326		325
327	if (ip) {	326	if (ip == NULL)
328	if (test_bit(GLF_DIRTY, &gl->gl_flags))	327	return;
329	gfs2_inode_attr_in(ip);	328	if (test_bit(GLF_DIRTY, &gl->gl_flags))
330		329	gfs2_inode_attr_in(ip);
331	gfs2_meta_cache_flush(ip);	330	gfs2_meta_cache_flush(ip);
332	}
333	}	331	}
334		332
335	/**	333	/**

/* * Color decompression engine support * * Copyright (c) 2014-2016, NVIDIA Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, * version 2, as published by the Free Software Foundation. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <linux/dma-mapping.h> #include <linux/firmware.h> #include <linux/fs.h> #include <linux/debugfs.h> #include <linux/dma-buf.h> #include <trace/events/gk20a.h> #include "gk20a.h" #include "channel_gk20a.h" #include "mm_gk20a.h" #include "cde_gk20a.h" #include "fence_gk20a.h" #include "gr_gk20a.h" #include "debug_gk20a.h" #include "semaphore_gk20a.h" #include "hw_ccsr_gk20a.h" #include "hw_pbdma_gk20a.h" static int gk20a_cde_load(struct gk20a_cde_ctx *cde_ctx); static struct gk20a_cde_ctx *gk20a_cde_allocate_context(struct gk20a *g); #define CTX_DELETE_TIME 1000 #define MAX_CTX_USE_COUNT 42 #define MAX_CTX_RETRY_TIME 2000 static void gk20a_deinit_cde_img(struct gk20a_cde_ctx *cde_ctx) { int i; for (i = 0; i < cde_ctx->num_bufs; i++) { struct mem_desc *mem = cde_ctx->mem + i; gk20a_gmmu_unmap_free(cde_ctx->vm, mem); } kfree(cde_ctx->init_convert_cmd); cde_ctx->convert_cmd = NULL; cde_ctx->init_convert_cmd = NULL; cde_ctx->num_bufs = 0; cde_ctx->num_params = 0; cde_ctx->init_cmd_num_entries = 0; cde_ctx->convert_cmd_num_entries = 0; cde_ctx->init_cmd_executed = false; } static void gk20a_cde_remove_ctx(struct gk20a_cde_ctx *cde_ctx) __must_hold(&cde_app->mutex) { struct gk20a *g = cde_ctx->g; struct channel_gk20a *ch = cde_ctx->ch; struct vm_gk20a *vm = ch->vm; trace_gk20a_cde_remove_ctx(cde_ctx); /* release mapped memory */ gk20a_deinit_cde_img(cde_ctx); gk20a_gmmu_unmap(vm, cde_ctx->backing_store_vaddr, g->gr.compbit_store.mem.size, 1); /* free the channel */ gk20a_channel_close(ch); /* housekeeping on app */ list_del(&cde_ctx->list); cde_ctx->g->cde_app.ctx_count--; kfree(cde_ctx); } static void gk20a_cde_cancel_deleter(struct gk20a_cde_ctx *cde_ctx, bool wait_finish) __releases(&cde_app->mutex) __acquires(&cde_app->mutex) { struct gk20a_cde_app *cde_app = &cde_ctx->g->cde_app; /* permanent contexts do not have deleter works */ if (!cde_ctx->is_temporary) return; if (wait_finish) { mutex_unlock(&cde_app->mutex); cancel_delayed_work_sync(&cde_ctx->ctx_deleter_work); mutex_lock(&cde_app->mutex); } else { cancel_delayed_work(&cde_ctx->ctx_deleter_work); } } static void gk20a_cde_remove_contexts(struct gk20a *g) __must_hold(&cde_app->mutex) { struct gk20a_cde_app *cde_app = &g->cde_app; struct gk20a_cde_ctx *cde_ctx, *cde_ctx_save; /* safe to go off the mutex in cancel_deleter since app is * deinitialised; no new jobs are started. deleter works may be only at * waiting for the mutex or before, going to abort */ list_for_each_entry_safe(cde_ctx, cde_ctx_save, &cde_app->free_contexts, list) { gk20a_cde_cancel_deleter(cde_ctx, true); gk20a_cde_remove_ctx(cde_ctx); } list_for_each_entry_safe(cde_ctx, cde_ctx_save, &cde_app->used_contexts, list) { gk20a_cde_cancel_deleter(cde_ctx, true); gk20a_cde_remove_ctx(cde_ctx); } } static void gk20a_cde_stop(struct gk20a *g) __must_hold(&cde_app->mutex) { struct gk20a_cde_app *cde_app = &g->cde_app; /* prevent further conversions and delayed works from working */ cde_app->initialised = false; /* free all data, empty the list */ gk20a_cde_remove_contexts(g); } void gk20a_cde_destroy(struct gk20a *g) __acquires(&cde_app->mutex) __releases(&cde_app->mutex) { struct gk20a_cde_app *cde_app = &g->cde_app; if (!cde_app->initialised) return; mutex_lock(&cde_app->mutex); gk20a_cde_stop(g); mutex_unlock(&cde_app->mutex); } void gk20a_cde_suspend(struct gk20a *g) __acquires(&cde_app->mutex) __releases(&cde_app->mutex) { struct gk20a_cde_app *cde_app = &g->cde_app; struct gk20a_cde_ctx *cde_ctx, *cde_ctx_save; if (!cde_app->initialised) return; mutex_lock(&cde_app->mutex); list_for_each_entry_safe(cde_ctx, cde_ctx_save, &cde_app->free_contexts, list) { gk20a_cde_cancel_deleter(cde_ctx, false); } list_for_each_entry_safe(cde_ctx, cde_ctx_save, &cde_app->used_contexts, list) { gk20a_cde_cancel_deleter(cde_ctx, false); } mutex_unlock(&cde_app->mutex); } static int gk20a_cde_create_context(struct gk20a *g) __must_hold(&cde_app->mutex) { struct gk20a_cde_app *cde_app = &g->cde_app; struct gk20a_cde_ctx *cde_ctx; cde_ctx = gk20a_cde_allocate_context(g); if (IS_ERR(cde_ctx)) return PTR_ERR(cde_ctx); list_add(&cde_ctx->list, &cde_app->free_contexts); cde_app->ctx_count++; if (cde_app->ctx_count > cde_app->ctx_count_top) cde_app->ctx_count_top = cde_app->ctx_count; return 0; } static int gk20a_cde_create_contexts(struct gk20a *g) __must_hold(&g->cde_app->mutex) { int err; int i; for (i = 0; i < NUM_CDE_CONTEXTS; i++) { err = gk20a_cde_create_context(g); if (err) goto out; } return 0; out: gk20a_cde_remove_contexts(g); return err; } static int gk20a_init_cde_buf(struct gk20a_cde_ctx *cde_ctx, const struct firmware *img, struct gk20a_cde_hdr_buf *buf) { struct mem_desc *mem; int err; /* check that the file can hold the buf */ if (buf->data_byte_offset != 0 && buf->data_byte_offset + buf->num_bytes > img->size) { gk20a_warn(cde_ctx->dev, "cde: invalid data section. buffer idx = %d", cde_ctx->num_bufs); return -EINVAL; } /* check that we have enough buf elems available */ if (cde_ctx->num_bufs >= MAX_CDE_BUFS) { gk20a_warn(cde_ctx->dev, "cde: invalid data section. buffer idx = %d", cde_ctx->num_bufs); return -ENOMEM; } /* allocate buf */ mem = cde_ctx->mem + cde_ctx->num_bufs; err = gk20a_gmmu_alloc_map(cde_ctx->vm, buf->num_bytes, mem); if (err) { gk20a_warn(cde_ctx->dev, "cde: could not allocate device memory. buffer idx = %d", cde_ctx->num_bufs); return -ENOMEM; } /* copy the content */ if (buf->data_byte_offset != 0) memcpy(mem->cpu_va, img->data + buf->data_byte_offset, buf->num_bytes); cde_ctx->num_bufs++; return 0; } static int gk20a_replace_data(struct gk20a_cde_ctx *cde_ctx, void *target, int type, s32 shift, u64 mask, u64 value) { u32 *target_mem_ptr = target; u64 *target_mem_ptr_u64 = target; u64 current_value, new_value; value = (shift >= 0) ? value << shift : value >> -shift; value &= mask; /* read current data from the location */ current_value = 0; if (type == TYPE_PARAM_TYPE_U32) { if (mask != 0xfffffffful) current_value = *target_mem_ptr; } else if (type == TYPE_PARAM_TYPE_U64_LITTLE) { if (mask != ~0ul) current_value = *target_mem_ptr_u64; } else if (type == TYPE_PARAM_TYPE_U64_BIG) { current_value = *target_mem_ptr_u64; current_value = (u64)(current_value >> 32) | (u64)(current_value << 32); } else { gk20a_warn(cde_ctx->dev, "cde: unknown type. type=%d", type); return -EINVAL; } current_value &= ~mask; new_value = current_value | value; /* store the element data back */ if (type == TYPE_PARAM_TYPE_U32) *target_mem_ptr = (u32)new_value; else if (type == TYPE_PARAM_TYPE_U64_LITTLE) *target_mem_ptr_u64 = new_value; else { new_value = (u64)(new_value >> 32) | (u64)(new_value << 32); *target_mem_ptr_u64 = new_value; } return 0; } static int gk20a_init_cde_replace(struct gk20a_cde_ctx *cde_ctx, const struct firmware *img, struct gk20a_cde_hdr_replace *replace) { struct mem_desc *source_mem; struct mem_desc *target_mem; u32 *target_mem_ptr; u64 vaddr; int err; if (replace->target_buf >= cde_ctx->num_bufs || replace->source_buf >= cde_ctx->num_bufs) { gk20a_warn(cde_ctx->dev, "cde: invalid buffer. target_buf=%u, source_buf=%u, num_bufs=%d", replace->target_buf, replace->source_buf, cde_ctx->num_bufs); return -EINVAL; } source_mem = cde_ctx->mem + replace->source_buf; target_mem = cde_ctx->mem + replace->target_buf; target_mem_ptr = target_mem->cpu_va; if (source_mem->size < (replace->source_byte_offset + 3) || target_mem->size < (replace->target_byte_offset + 3)) { gk20a_warn(cde_ctx->dev, "cde: invalid buffer offsets. target_buf_offs=%lld, source_buf_offs=%lld, source_buf_size=%zu, dest_buf_size=%zu", replace->target_byte_offset, replace->source_byte_offset, source_mem->size, target_mem->size); return -EINVAL; } /* calculate the target pointer */ target_mem_ptr += (replace->target_byte_offset / sizeof(u32)); /* determine patch value */ vaddr = source_mem->gpu_va + replace->source_byte_offset; err = gk20a_replace_data(cde_ctx, target_mem_ptr, replace->type, replace->shift, replace->mask, vaddr); if (err) { gk20a_warn(cde_ctx->dev, "cde: replace failed. err=%d, target_buf=%u, target_buf_offs=%lld, source_buf=%u, source_buf_offs=%lld", err, replace->target_buf, replace->target_byte_offset, replace->source_buf, replace->source_byte_offset); } return err; } static int gk20a_cde_patch_params(struct gk20a_cde_ctx *cde_ctx) { struct gk20a *g = cde_ctx->g; struct mem_desc *target_mem; u32 *target_mem_ptr; u64 new_data; int user_id = 0, i, err; for (i = 0; i < cde_ctx->num_params; i++) { struct gk20a_cde_hdr_param *param = cde_ctx->params + i; target_mem = cde_ctx->mem + param->target_buf; target_mem_ptr = target_mem->cpu_va; target_mem_ptr += (param->target_byte_offset / sizeof(u32)); switch (param->id) { case TYPE_PARAM_COMPTAGS_PER_CACHELINE: new_data = g->gr.comptags_per_cacheline; break; case TYPE_PARAM_GPU_CONFIGURATION: new_data = g->ltc_count * g->gr.slices_per_ltc * g->gr.cacheline_size; break; case TYPE_PARAM_FIRSTPAGEOFFSET: new_data = cde_ctx->surf_param_offset; break; case TYPE_PARAM_NUMPAGES: new_data = cde_ctx->surf_param_lines; break; case TYPE_PARAM_BACKINGSTORE: new_data = cde_ctx->backing_store_vaddr; break; case TYPE_PARAM_DESTINATION: new_data = cde_ctx->compbit_vaddr; break; case TYPE_PARAM_DESTINATION_SIZE: new_data = cde_ctx->compbit_size; break; case TYPE_PARAM_BACKINGSTORE_SIZE: new_data = g->gr.compbit_store.mem.size; break; case TYPE_PARAM_SOURCE_SMMU_ADDR: new_data = gk20a_mm_gpuva_to_iova_base(cde_ctx->vm, cde_ctx->surf_vaddr); if (new_data == 0) err = -EINVAL; break; case TYPE_PARAM_BACKINGSTORE_BASE_HW: new_data = g->gr.compbit_store.base_hw; break; case TYPE_PARAM_GOBS_PER_COMPTAGLINE_PER_SLICE: new_data = g->gr.gobs_per_comptagline_per_slice; break; case TYPE_PARAM_SCATTERBUFFER: new_data = cde_ctx->scatterbuffer_vaddr; break; case TYPE_PARAM_SCATTERBUFFER_SIZE: new_data = cde_ctx->scatterbuffer_size; break; default:


context:
space:
mode: