184 lines
6.4 KiB
C
184 lines
6.4 KiB
C
/*
|
|
* drivers/video/tegra/host/nvhost_cdma.h
|
|
*
|
|
* Tegra Graphics Host Command DMA
|
|
*
|
|
* Copyright (c) 2010-2017, 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/>.
|
|
*/
|
|
|
|
#ifndef __NVHOST_CDMA_H
|
|
#define __NVHOST_CDMA_H
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/semaphore.h>
|
|
|
|
#include <linux/nvhost.h>
|
|
#include <linux/list.h>
|
|
|
|
struct nvhost_syncpt;
|
|
struct nvhost_userctx_timeout;
|
|
struct nvhost_job;
|
|
struct mem_mgr;
|
|
struct mem_handle;
|
|
|
|
/* Number of gathers we allow to be queued up per channel. Must be a
|
|
* power of two. Currently sized such that pushbuffer is 4KB (512*8B). */
|
|
#define NVHOST_GATHER_QUEUE_SIZE 512
|
|
|
|
/* 8 bytes per slot. (This number does not include the final RESTART.) */
|
|
#define PUSH_BUFFER_SIZE (NVHOST_GATHER_QUEUE_SIZE * 8)
|
|
|
|
/* 4K page containing GATHERed methods to increment channel syncpts
|
|
* and replaces the original timed out contexts GATHER slots */
|
|
#define SYNCPT_INCR_BUFFER_SIZE_WORDS (4096 / sizeof(u32))
|
|
|
|
/*
|
|
* cdma
|
|
*
|
|
* This is in charge of a host command DMA channel.
|
|
* Sends ops to a push buffer, and takes responsibility for unpinning
|
|
* (& possibly freeing) of memory after those ops have completed.
|
|
* Producer:
|
|
* begin
|
|
* push - send ops to the push buffer
|
|
* end - start command DMA and enqueue handles to be unpinned
|
|
* Consumer:
|
|
* update - call to update sync queue and push buffer, unpin memory
|
|
*/
|
|
|
|
struct push_buffer {
|
|
u32 *mapped; /* mapped pushbuffer memory */
|
|
dma_addr_t dma_addr; /* dma address of pushbuffer */
|
|
u32 fence; /* index we've written */
|
|
u32 cur; /* index to write to */
|
|
};
|
|
|
|
struct buffer_timeout {
|
|
struct delayed_work wq; /* work queue */
|
|
bool initialized; /* timer one-time setup flag */
|
|
struct nvhost_job_syncpt *sp; /* buffer syncpoint information */
|
|
ktime_t start_ktime; /* starting time */
|
|
/* context timeout information */
|
|
int clientid;
|
|
bool timeout_debug_dump;
|
|
int num_syncpts;
|
|
int timeout;
|
|
bool allow_dependency;
|
|
};
|
|
|
|
enum cdma_event {
|
|
CDMA_EVENT_NONE, /* not waiting for any event */
|
|
CDMA_EVENT_SYNC_QUEUE_EMPTY, /* wait for empty sync queue */
|
|
CDMA_EVENT_PUSH_BUFFER_SPACE /* wait for space in push buffer */
|
|
};
|
|
|
|
/*
|
|
* Notes on CDMA locking and synchronization :-
|
|
*
|
|
* We have various mutexes and semaphores to handle synchronization between
|
|
* multiple threads and to protect CDMA resources and events
|
|
* They are detailed as below
|
|
*
|
|
* 1) nvhost_cdma->lock
|
|
* type : rw_semaphore
|
|
*
|
|
* We take a read lock in job submit path and job cleanup path so that these two
|
|
* threads can run parallely - this is essential for performance and submit time
|
|
* latencies to be consistent
|
|
*
|
|
* We take a write lock in timeout handler so that we block job submission and
|
|
* job cleanup when recovery routine is triggered
|
|
*
|
|
* We take write lock for dumping debug data as well
|
|
*
|
|
* We should really avoid adding this lock to new places and prefer adding finer
|
|
* and specific locks like below ones
|
|
*
|
|
* 2) nvhost_cdma->push_buffer_lock
|
|
* type : mutex
|
|
*
|
|
* We use this lock to protect handling of CDMA_EVENT_PUSH_BUFFER_SPACE event
|
|
*
|
|
* 3) nvhost_cdma->sync_queue_lock
|
|
* type : mutex
|
|
*
|
|
* We use this lock to protect accesses to nvhost_cdma->sync_queue list and
|
|
* to protect handling of CDMA_EVENT_SYNC_QUEUE_EMPTY event
|
|
*
|
|
* 4) nvhost_cdma->timeout_lock
|
|
* type : mutex
|
|
*
|
|
* We use this flag to protect timeout flags/settings and enabling/disabling
|
|
* of timeout
|
|
*
|
|
* 5) nvhost_channel->submitlock
|
|
* type : mutex
|
|
*
|
|
* We use this lock to serialize all submits on a channel/CDMA
|
|
* This lock also protects interleaving of CDMA commands in case a channel is
|
|
* shared between multiple users
|
|
*/
|
|
|
|
struct nvhost_cdma {
|
|
struct semaphore sem; /* signalled when event occurs */
|
|
struct rw_semaphore lock; /* controls access to shared state */
|
|
struct mutex push_buffer_lock; /* protect push buffer space event */
|
|
struct mutex sync_queue_lock; /* protect sync_queue accesses */
|
|
struct mutex timeout_lock; /* control access to timeout flag */
|
|
enum cdma_event event; /* event that sem is waiting for */
|
|
unsigned int slots_used; /* pb slots used in current submit */
|
|
unsigned int slots_free; /* pb slots free in current submit */
|
|
unsigned int first_get; /* DMAGET value, where submit begins */
|
|
unsigned int last_put; /* last value written to DMAPUT */
|
|
struct push_buffer push_buffer; /* channel's push buffer */
|
|
struct list_head sync_queue; /* job queue */
|
|
struct buffer_timeout timeout; /* channel's timeout state/wq */
|
|
struct platform_device *pdev; /* pointer to host1x device */
|
|
bool running;
|
|
bool torndown;
|
|
};
|
|
|
|
#define cdma_to_channel(cdma) container_of(cdma, struct nvhost_channel, cdma)
|
|
#define cdma_to_dev(cdma) nvhost_get_host(cdma->pdev)
|
|
#define pb_to_cdma(pb) container_of(pb, struct nvhost_cdma, push_buffer)
|
|
|
|
void nvhost_push_buffer_destroy(struct push_buffer *pb);
|
|
int nvhost_push_buffer_alloc(struct push_buffer *pb);
|
|
u32 nvhost_push_buffer_putptr(struct push_buffer *pb);
|
|
dma_addr_t nvhost_push_buffer_start(struct push_buffer *pb);
|
|
dma_addr_t nvhost_push_buffer_end(struct push_buffer *pb);
|
|
|
|
int nvhost_cdma_init(struct platform_device *pdev,
|
|
struct nvhost_cdma *cdma);
|
|
void nvhost_cdma_deinit(struct nvhost_cdma *cdma);
|
|
void nvhost_cdma_stop(struct nvhost_cdma *cdma);
|
|
int nvhost_cdma_begin(struct nvhost_cdma *cdma, struct nvhost_job *job);
|
|
void nvhost_cdma_push(struct nvhost_cdma *cdma, u32 op1, u32 op2);
|
|
void nvhost_cdma_push_gather(struct nvhost_cdma *cdma,
|
|
u32 *cpuva, dma_addr_t iova,
|
|
u32 offset, u32 op1, u32 op2);
|
|
void nvhost_cdma_end(struct nvhost_cdma *cdma,
|
|
struct nvhost_job *job);
|
|
void nvhost_cdma_update(struct nvhost_cdma *cdma);
|
|
void nvhost_cdma_peek(struct nvhost_cdma *cdma,
|
|
u32 dmaget, int slot, u32 *out);
|
|
unsigned int nvhost_cdma_wait_locked(struct nvhost_cdma *cdma,
|
|
enum cdma_event event);
|
|
void nvhost_cdma_finalize_job_incrs(struct nvhost_syncpt *syncpt,
|
|
struct nvhost_job_syncpt *sp);
|
|
void nvhost_cdma_update_sync_queue(struct nvhost_cdma *cdma,
|
|
struct nvhost_syncpt *syncpt, struct platform_device *dev);
|
|
#endif
|