123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685 |
- // SPDX-License-Identifier: GPL-2.0-only
- /*
- * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
- */
- #include "cam_sync_dma_fence.h"
- /**
- * struct cam_dma_fence_row - DMA fence row
- */
- struct cam_dma_fence_row {
- char name[CAM_DMA_FENCE_NAME_LEN];
- struct dma_fence *fence;
- int32_t fd;
- enum cam_dma_fence_state state;
- struct dma_fence_cb fence_cb;
- int32_t sync_obj;
- cam_sync_callback_for_dma_fence sync_cb;
- bool cb_registered_for_sync;
- bool ext_dma_fence;
- bool sync_signal_dma;
- };
- /**
- * struct cam_dma_fence_device - DMA fence device
- */
- struct cam_dma_fence_device {
- uint64_t dma_fence_context;
- struct cam_dma_fence_row rows[CAM_DMA_FENCE_MAX_FENCES];
- spinlock_t row_spinlocks[CAM_DMA_FENCE_MAX_FENCES];
- struct mutex dev_lock;
- DECLARE_BITMAP(bitmap, CAM_DMA_FENCE_MAX_FENCES);
- };
- static atomic64_t g_cam_dma_fence_seq_no;
- static struct cam_dma_fence_device *g_cam_dma_fence_dev;
- bool __cam_dma_fence_enable_signaling(
- struct dma_fence *fence)
- {
- return true;
- }
- const char *__cam_dma_fence_get_driver_name(
- struct dma_fence *fence)
- {
- return "Camera DMA fence driver";
- }
- void __cam_dma_fence_free(struct dma_fence *fence)
- {
- CAM_DBG(CAM_DMA_FENCE,
- "Free memory for dma fence seqno: %llu", fence->seqno);
- kfree(fence->lock);
- kfree(fence);
- }
- static struct dma_fence_ops cam_sync_dma_fence_ops = {
- .enable_signaling = __cam_dma_fence_enable_signaling,
- .get_driver_name = __cam_dma_fence_get_driver_name,
- .get_timeline_name = __cam_dma_fence_get_driver_name,
- .release = __cam_dma_fence_free,
- };
- static void __cam_dma_fence_print_table(void)
- {
- int i;
- struct cam_dma_fence_row *row;
- struct dma_fence *fence;
- for (i = 0; i < CAM_DMA_FENCE_MAX_FENCES; i++) {
- spin_lock_bh(&g_cam_dma_fence_dev->row_spinlocks[i]);
- row = &g_cam_dma_fence_dev->rows[i];
- fence = row->fence;
- CAM_INFO(CAM_DMA_FENCE,
- "Idx: %d seqno: %llu name: %s state: %d",
- i, fence->seqno, row->name, row->state);
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[i]);
- }
- }
- static int __cam_dma_fence_find_free_idx(uint32_t *idx)
- {
- int rc = 0;
- *idx = find_first_zero_bit(g_cam_dma_fence_dev->bitmap, CAM_DMA_FENCE_MAX_FENCES);
- if (*idx < CAM_DMA_FENCE_MAX_FENCES)
- set_bit(*idx, g_cam_dma_fence_dev->bitmap);
- else
- rc = -ENOMEM;
- if (rc) {
- CAM_ERR(CAM_DMA_FENCE, "No free idx, printing dma fence table......");
- __cam_dma_fence_print_table();
- }
- return rc;
- }
- static struct dma_fence *__cam_dma_fence_find_fence_in_table(
- int32_t fd, int32_t *idx)
- {
- int i;
- struct dma_fence *fence = NULL;
- struct cam_dma_fence_row *row = NULL;
- for (i = 0; i < CAM_DMA_FENCE_MAX_FENCES; i++) {
- spin_lock_bh(&g_cam_dma_fence_dev->row_spinlocks[i]);
- row = &g_cam_dma_fence_dev->rows[i];
- if ((row->state != CAM_DMA_FENCE_STATE_INVALID) && (row->fd == fd)) {
- *idx = i;
- fence = row->fence;
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[i]);
- break;
- }
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[i]);
- }
- return fence;
- }
- static void __cam_dma_fence_init_row(const char *name,
- struct dma_fence *dma_fence, int32_t fd, uint32_t idx,
- bool ext_dma_fence)
- {
- struct cam_dma_fence_row *row;
- spin_lock_bh(&g_cam_dma_fence_dev->row_spinlocks[idx]);
- row = &g_cam_dma_fence_dev->rows[idx];
- memset(row, 0, sizeof(*row));
- row->fence = dma_fence;
- row->fd = fd;
- row->state = CAM_DMA_FENCE_STATE_ACTIVE;
- row->ext_dma_fence = ext_dma_fence;
- strscpy(row->name, name, CAM_DMA_FENCE_NAME_LEN);
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[idx]);
- }
- void __cam_dma_fence_signal_cb(
- struct dma_fence *fence, struct dma_fence_cb *cb)
- {
- struct cam_dma_fence_signal_sync_obj signal_sync_obj;
- struct cam_dma_fence_row *dma_fence_row =
- container_of(cb, struct cam_dma_fence_row, fence_cb);
- if (dma_fence_row->state == CAM_DMA_FENCE_STATE_INVALID) {
- CAM_ERR(CAM_DMA_FENCE, "dma fence seqno: %llu is in invalid state: %d",
- fence->seqno, dma_fence_row->state);
- return;
- }
- /* If this dma fence is signaled by sync obj, skip cb */
- if (dma_fence_row->sync_signal_dma)
- return;
- CAM_DBG(CAM_DMA_FENCE, "dma fence seqno: %llu fd: %d signaled, signal sync obj: %d",
- fence->seqno, dma_fence_row->fd, dma_fence_row->sync_obj);
- if ((dma_fence_row->cb_registered_for_sync) && (dma_fence_row->sync_cb)) {
- signal_sync_obj.fd = dma_fence_row->fd;
- /*
- * Signal is invoked with the fence lock held,
- * lock not needed to query status
- */
- signal_sync_obj.status = dma_fence_get_status_locked(fence);
- dma_fence_row->state = CAM_DMA_FENCE_STATE_SIGNALED;
- dma_fence_row->sync_cb(dma_fence_row->sync_obj, &signal_sync_obj);
- }
- }
- int cam_dma_fence_get_put_ref(
- bool get_or_put, int32_t dma_fence_row_idx)
- {
- struct dma_fence *dma_fence;
- struct cam_dma_fence_row *row;
- if ((dma_fence_row_idx < 0) ||
- (dma_fence_row_idx >= CAM_DMA_FENCE_MAX_FENCES)) {
- CAM_ERR(CAM_DMA_FENCE, "dma fence idx: %d is invalid",
- dma_fence_row_idx);
- return -EINVAL;
- }
- spin_lock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_fence_row_idx]);
- row = &g_cam_dma_fence_dev->rows[dma_fence_row_idx];
- if (row->state == CAM_DMA_FENCE_STATE_INVALID) {
- CAM_ERR(CAM_DMA_FENCE,
- "dma fence at idx: %d is in invalid state: %d",
- dma_fence_row_idx, row->state);
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_fence_row_idx]);
- return -EINVAL;
- }
- dma_fence = row->fence;
- if (get_or_put)
- dma_fence_get(dma_fence);
- else
- dma_fence_put(dma_fence);
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_fence_row_idx]);
- CAM_DBG(CAM_DMA_FENCE, "Refcnt: %u after %s for dma fence with seqno: %llu",
- kref_read(&dma_fence->refcount), (get_or_put ? "getref" : "putref"),
- dma_fence->seqno);
- return 0;
- }
- static struct dma_fence *cam_dma_fence_get_fence_from_sync_file(
- int32_t fd, int32_t *dma_fence_row_idx)
- {
- uint32_t idx;
- struct dma_fence *dma_fence = NULL;
- dma_fence = sync_file_get_fence(fd);
- if (IS_ERR_OR_NULL(dma_fence)) {
- CAM_ERR(CAM_DMA_FENCE, "Invalid fd: %d no dma fence found", fd);
- return ERR_PTR(-EINVAL);
- }
- if (__cam_dma_fence_find_free_idx(&idx)) {
- CAM_ERR(CAM_DMA_FENCE, "No free idx");
- goto end;
- }
- __cam_dma_fence_init_row(dma_fence->ops->get_driver_name(dma_fence),
- dma_fence, fd, idx, true);
- *dma_fence_row_idx = idx;
- CAM_DBG(CAM_DMA_FENCE,
- "External dma fence with fd: %d seqno: %llu ref_cnt: %u updated in tbl",
- fd, dma_fence->seqno, kref_read(&dma_fence->refcount));
- return dma_fence;
- end:
- dma_fence_put(dma_fence);
- return NULL;
- }
- struct dma_fence *cam_dma_fence_get_fence_from_fd(
- int32_t fd, int32_t *dma_fence_row_idx)
- {
- struct dma_fence *dma_fence = NULL;
- dma_fence = __cam_dma_fence_find_fence_in_table(fd, dma_fence_row_idx);
- if (IS_ERR_OR_NULL(dma_fence)) {
- CAM_WARN(CAM_DMA_FENCE,
- "dma fence with fd: %d is an external fence, querying sync file",
- fd);
- return cam_dma_fence_get_fence_from_sync_file(fd, dma_fence_row_idx);
- }
- dma_fence_get(dma_fence);
- CAM_DBG(CAM_DMA_FENCE, "dma fence found for fd: %d with seqno: %llu ref_cnt: %u",
- fd, dma_fence->seqno, kref_read(&dma_fence->refcount));
- return dma_fence;
- }
- int cam_dma_fence_register_cb(int32_t *sync_obj, int32_t *dma_fence_idx,
- cam_sync_callback_for_dma_fence sync_cb)
- {
- int rc = 0;
- int dma_fence_row_idx = 0;
- struct cam_dma_fence_row *row = NULL;
- struct dma_fence *dma_fence = NULL;
- if (!sync_obj || !dma_fence_idx || !sync_cb) {
- CAM_ERR(CAM_DMA_FENCE,
- "Invalid args sync_obj: %p dma_fence_idx: %p sync_cb: %p",
- sync_obj, dma_fence_idx, sync_cb);
- return -EINVAL;
- }
- dma_fence_row_idx = *dma_fence_idx;
- if ((dma_fence_row_idx < 0) ||
- (dma_fence_row_idx >= CAM_DMA_FENCE_MAX_FENCES)) {
- CAM_ERR(CAM_DMA_FENCE, "dma fence idx: %d is invalid",
- dma_fence_row_idx);
- return -EINVAL;
- }
- spin_lock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_fence_row_idx]);
- row = &g_cam_dma_fence_dev->rows[dma_fence_row_idx];
- dma_fence = row->fence;
- if (row->state != CAM_DMA_FENCE_STATE_ACTIVE) {
- CAM_ERR(CAM_DMA_FENCE,
- "dma fence at idx: %d fd: %d seqno: %llu is not active, current state: %d",
- dma_fence_row_idx, row->fd, dma_fence->seqno, row->state);
- rc = -EINVAL;
- goto end;
- }
- /**
- * If the cb is already registered, return
- * If a fd is closed by userspace without releasing the dma fence, it is
- * possible that same fd is returned to a new fence.
- */
- if (row->cb_registered_for_sync) {
- CAM_WARN(CAM_DMA_FENCE,
- "dma fence at idx: %d fd: %d seqno: %llu has already registered a cb for sync: %d - same fd for 2 fences?",
- dma_fence_row_idx, row->fd, dma_fence->seqno, row->sync_obj);
- goto end;
- }
- rc = dma_fence_add_callback(row->fence, &row->fence_cb,
- __cam_dma_fence_signal_cb);
- if (rc) {
- CAM_ERR(CAM_DMA_FENCE,
- "Failed to register cb for dma fence fd: %d seqno: %llu rc: %d",
- row->fd, dma_fence->seqno, rc);
- goto end;
- }
- row->cb_registered_for_sync = true;
- row->sync_obj = *sync_obj;
- row->sync_cb = sync_cb;
- CAM_DBG(CAM_DMA_FENCE,
- "CB successfully registered for dma fence fd: %d seqno: %llu for sync_obj: %d",
- row->fd, dma_fence->seqno, *sync_obj);
- end:
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_fence_row_idx]);
- return rc;
- }
- static int __cam_dma_fence_signal_fence(
- struct dma_fence *dma_fence,
- int32_t status)
- {
- bool fence_signaled = false;
- fence_signaled = dma_fence_is_signaled(dma_fence);
- if (fence_signaled) {
- CAM_WARN(CAM_DMA_FENCE,
- "dma fence seqno: %llu is already signaled",
- dma_fence->seqno);
- return 0;
- }
- if (status)
- dma_fence_set_error(dma_fence, status);
- return dma_fence_signal(dma_fence);
- }
- int cam_dma_fence_internal_signal(
- int32_t dma_fence_row_idx,
- struct cam_dma_fence_signal *signal_dma_fence)
- {
- int rc = 0;
- struct dma_fence *dma_fence = NULL;
- struct cam_dma_fence_row *row = NULL;
- if ((dma_fence_row_idx < 0) ||
- (dma_fence_row_idx >= CAM_DMA_FENCE_MAX_FENCES)) {
- CAM_ERR(CAM_DMA_FENCE, "dma fence idx: %d is invalid",
- dma_fence_row_idx);
- return -EINVAL;
- }
- spin_lock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_fence_row_idx]);
- row = &g_cam_dma_fence_dev->rows[dma_fence_row_idx];
- /* Ensures sync obj cb is not invoked */
- row->sync_signal_dma = true;
- dma_fence = row->fence;
- if (IS_ERR_OR_NULL(dma_fence)) {
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_fence_row_idx]);
- CAM_ERR(CAM_DMA_FENCE, "DMA fence in row: %d is invalid",
- dma_fence_row_idx);
- return -EINVAL;
- }
- if (row->state == CAM_DMA_FENCE_STATE_SIGNALED) {
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_fence_row_idx]);
- CAM_WARN(CAM_DMA_FENCE,
- "dma fence fd: %d[seqno: %llu] already in signaled state",
- signal_dma_fence->dma_fence_fd, dma_fence->seqno);
- return 0;
- }
- rc = __cam_dma_fence_signal_fence(dma_fence, signal_dma_fence->status);
- if (rc)
- CAM_WARN(CAM_DMA_FENCE,
- "dma fence seqno: %llu fd: %d already signaled rc: %d",
- dma_fence->seqno, row->fd, rc);
- row->state = CAM_DMA_FENCE_STATE_SIGNALED;
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_fence_row_idx]);
- CAM_DBG(CAM_DMA_FENCE,
- "dma fence fd: %d[seqno: %llu] signaled with status: %d rc: %d",
- signal_dma_fence->dma_fence_fd, dma_fence->seqno,
- signal_dma_fence->status, rc);
- return rc;
- }
- int cam_dma_fence_signal_fd(struct cam_dma_fence_signal *signal_dma_fence)
- {
- int rc = 0;
- uint32_t idx;
- struct dma_fence *dma_fence = NULL;
- struct cam_dma_fence_row *row = NULL;
- dma_fence = __cam_dma_fence_find_fence_in_table(
- signal_dma_fence->dma_fence_fd, &idx);
- if (IS_ERR_OR_NULL(dma_fence)) {
- CAM_ERR(CAM_DMA_FENCE, "Failed to find dma fence for fd: %d",
- signal_dma_fence->dma_fence_fd);
- return -EINVAL;
- }
- spin_lock_bh(&g_cam_dma_fence_dev->row_spinlocks[idx]);
- row = &g_cam_dma_fence_dev->rows[idx];
- /*
- * Check for invalid state again, there could be a contention
- * between signal and release
- */
- if (row->state == CAM_DMA_FENCE_STATE_INVALID) {
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[idx]);
- CAM_ERR(CAM_DMA_FENCE,
- "dma fence fd: %d is invalid row_idx: %u, failed to signal",
- signal_dma_fence->dma_fence_fd, idx);
- return -EINVAL;
- }
- if (row->state == CAM_DMA_FENCE_STATE_SIGNALED) {
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[idx]);
- CAM_WARN(CAM_DMA_FENCE,
- "dma fence fd: %d[seqno: %llu] already in signaled state",
- signal_dma_fence->dma_fence_fd, dma_fence->seqno);
- return 0;
- }
- rc = __cam_dma_fence_signal_fence(dma_fence, signal_dma_fence->status);
- if (rc)
- CAM_WARN(CAM_DMA_FENCE,
- "dma fence seqno: %llu fd: %d already signaled rc: %d",
- dma_fence->seqno, row->fd, rc);
- row->state = CAM_DMA_FENCE_STATE_SIGNALED;
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[idx]);
- CAM_DBG(CAM_DMA_FENCE,
- "dma fence fd: %d[seqno: %llu] signaled with status: %d rc: %d",
- signal_dma_fence->dma_fence_fd, dma_fence->seqno,
- signal_dma_fence->status, rc);
- return rc;
- }
- static int __cam_dma_fence_get_fd(int32_t *row_idx,
- const char *name)
- {
- int fd = -1;
- uint32_t idx;
- struct dma_fence *dma_fence = NULL;
- spinlock_t *dma_fence_lock = NULL;
- struct sync_file *sync_file = NULL;
- if (__cam_dma_fence_find_free_idx(&idx))
- goto end;
- dma_fence_lock = kzalloc(sizeof(spinlock_t), GFP_KERNEL);
- if (!dma_fence_lock)
- goto free_idx;
- dma_fence = kzalloc(sizeof(struct dma_fence), GFP_KERNEL);
- if (!dma_fence) {
- kfree(dma_fence_lock);
- goto free_idx;
- }
- spin_lock_init(dma_fence_lock);
- dma_fence_init(dma_fence, &cam_sync_dma_fence_ops, dma_fence_lock,
- g_cam_dma_fence_dev->dma_fence_context,
- atomic64_inc_return(&g_cam_dma_fence_seq_no));
- fd = get_unused_fd_flags(O_CLOEXEC);
- if (fd < 0) {
- CAM_ERR(CAM_DMA_FENCE, "failed to get a unused fd: %d", fd);
- dma_fence_put(dma_fence);
- goto free_idx;
- }
- sync_file = sync_file_create(dma_fence);
- if (!sync_file) {
- put_unused_fd(fd);
- fd = -1;
- dma_fence_put(dma_fence);
- goto free_idx;
- }
- fd_install(fd, sync_file->file);
- *row_idx = idx;
- __cam_dma_fence_init_row(name, dma_fence, fd, idx, false);
- CAM_DBG(CAM_DMA_FENCE, "Created dma fence fd: %d[%s] seqno: %llu row_idx: %u ref_cnt: %u",
- fd, name, dma_fence->seqno, idx, kref_read(&dma_fence->refcount));
- return fd;
- free_idx:
- clear_bit(idx, g_cam_dma_fence_dev->bitmap);
- end:
- return fd;
- }
- int cam_dma_fence_create_fd(
- int32_t *dma_fence_fd, int32_t *dma_fence_row_idx, const char *name)
- {
- int fd = -1, rc = 0;
- if (!dma_fence_fd || !dma_fence_row_idx) {
- CAM_ERR(CAM_DMA_FENCE, "Invalid args fd: %pK dma_fence_row_idx: %pK",
- dma_fence_fd, dma_fence_row_idx);
- return -EINVAL;
- }
- fd = __cam_dma_fence_get_fd(dma_fence_row_idx, name);
- if (fd < 0) {
- rc = -EBADFD;
- goto end;
- }
- *dma_fence_fd = fd;
- end:
- return rc;
- }
- static int __cam_dma_fence_release(int32_t dma_row_idx)
- {
- struct dma_fence *dma_fence = NULL;
- struct cam_dma_fence_row *row = NULL;
- spin_lock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_row_idx]);
- row = &g_cam_dma_fence_dev->rows[dma_row_idx];
- dma_fence = row->fence;
- if (row->state == CAM_DMA_FENCE_STATE_INVALID) {
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_row_idx]);
- CAM_ERR(CAM_DMA_FENCE, "Invalid row index: %u, state: %u",
- dma_row_idx, row->state);
- return -EINVAL;
- }
- if (row->state == CAM_DMA_FENCE_STATE_ACTIVE) {
- CAM_WARN(CAM_DMA_FENCE,
- "Unsignaled fence being released name: %s seqno: %llu fd:%d",
- row->name, dma_fence->seqno, row->fd);
- __cam_dma_fence_signal_fence(dma_fence, -ECANCELED);
- }
- CAM_DBG(CAM_DMA_FENCE,
- "Releasing dma fence with fd: %d[%s] row_idx: %u current ref_cnt: %u",
- row->fd, row->name, dma_row_idx, kref_read(&dma_fence->refcount));
- /* putref on dma fence */
- dma_fence_put(dma_fence);
- /* deinit row */
- memset(row, 0, sizeof(struct cam_dma_fence_row));
- clear_bit(dma_row_idx, g_cam_dma_fence_dev->bitmap);
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[dma_row_idx]);
- return 0;
- }
- static int __cam_dma_fence_release_fd(int fd)
- {
- int32_t idx;
- struct dma_fence *dma_fence = NULL;
- dma_fence = __cam_dma_fence_find_fence_in_table(fd, &idx);
- if (IS_ERR_OR_NULL(dma_fence)) {
- CAM_ERR(CAM_DMA_FENCE, "Failed to find dma fence for fd: %d", fd);
- return -EINVAL;
- }
- return __cam_dma_fence_release(idx);
- }
- static int __cam_dma_fence_release_row(
- int32_t dma_fence_row_idx)
- {
- if ((dma_fence_row_idx < 0) ||
- (dma_fence_row_idx >= CAM_DMA_FENCE_MAX_FENCES)) {
- CAM_ERR(CAM_DMA_FENCE, "dma fence idx: %d is invalid",
- dma_fence_row_idx);
- return -EINVAL;
- }
- return __cam_dma_fence_release(dma_fence_row_idx);
- }
- int cam_dma_fence_release(
- struct cam_dma_fence_release_params *release_params)
- {
- if (release_params->use_row_idx)
- return __cam_dma_fence_release_row(release_params->u.dma_row_idx);
- else
- return __cam_dma_fence_release_fd(release_params->u.dma_fence_fd);
- }
- void cam_dma_fence_close(void)
- {
- int i;
- struct cam_dma_fence_row *row = NULL;
- mutex_lock(&g_cam_dma_fence_dev->dev_lock);
- for (i = 0; i < CAM_DMA_FENCE_MAX_FENCES; i++) {
- spin_lock_bh(&g_cam_dma_fence_dev->row_spinlocks[i]);
- row = &g_cam_dma_fence_dev->rows[i];
- if (row->state != CAM_DMA_FENCE_STATE_INVALID) {
- CAM_DBG(CAM_DMA_FENCE,
- "Releasing dma fence seqno: %llu associated with fd: %d[%s] ref_cnt: %u",
- row->fence->seqno, row->fd, row->name,
- kref_read(&row->fence->refcount));
- /* If registered for cb, remove cb */
- if (row->cb_registered_for_sync)
- dma_fence_remove_callback(row->fence, &row->fence_cb);
- /* Signal and put if the dma fence is created from camera */
- if (!row->ext_dma_fence) {
- if (row->state != CAM_DMA_FENCE_STATE_SIGNALED)
- __cam_dma_fence_signal_fence(row->fence, -EADV);
- dma_fence_put(row->fence);
- }
- memset(row, 0, sizeof(struct cam_dma_fence_row));
- clear_bit(i, g_cam_dma_fence_dev->bitmap);
- }
- spin_unlock_bh(&g_cam_dma_fence_dev->row_spinlocks[i]);
- }
- mutex_unlock(&g_cam_dma_fence_dev->dev_lock);
- CAM_DBG(CAM_DMA_FENCE, "Close on Camera DMA fence driver");
- }
- void cam_dma_fence_open(void)
- {
- mutex_lock(&g_cam_dma_fence_dev->dev_lock);
- /* DMA fence seqno reset */
- atomic64_set(&g_cam_dma_fence_seq_no, 0);
- mutex_unlock(&g_cam_dma_fence_dev->dev_lock);
- CAM_DBG(CAM_DMA_FENCE, "Camera DMA fence driver opened");
- }
- int cam_dma_fence_driver_init(void)
- {
- int i;
- g_cam_dma_fence_dev = kzalloc(sizeof(struct cam_dma_fence_device), GFP_KERNEL);
- if (!g_cam_dma_fence_dev)
- return -ENOMEM;
- mutex_init(&g_cam_dma_fence_dev->dev_lock);
- for (i = 0; i < CAM_DMA_FENCE_MAX_FENCES; i++)
- spin_lock_init(&g_cam_dma_fence_dev->row_spinlocks[i]);
- bitmap_zero(g_cam_dma_fence_dev->bitmap, CAM_DMA_FENCE_MAX_FENCES);
- g_cam_dma_fence_dev->dma_fence_context = dma_fence_context_alloc(1);
- CAM_DBG(CAM_DMA_FENCE, "Camera DMA fence driver initialized");
- return 0;
- }
- void cam_dma_fence_driver_deinit(void)
- {
- kfree(g_cam_dma_fence_dev);
- g_cam_dma_fence_dev = NULL;
- CAM_DBG(CAM_DMA_FENCE, "Camera DMA fence driver deinitialized");
- }
|