hc
2025-02-14 bbb9540dc49f70f6b703d1c8d1b85fa5f602d86e
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * Tegra host1x Command DMA
 *
 * Copyright (c) 2010-2013, NVIDIA Corporation.
 */
 
#ifndef __HOST1X_CDMA_H
#define __HOST1X_CDMA_H
 
#include <linux/sched.h>
#include <linux/completion.h>
#include <linux/list.h>
 
struct host1x_syncpt;
struct host1x_userctx_timeout;
struct host1x_job;
 
/*
 * 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 {
   void *mapped;            /* mapped pushbuffer memory */
   dma_addr_t dma;            /* device address of pushbuffer */
   dma_addr_t phys;        /* physical address of pushbuffer */
   u32 fence;            /* index we've written */
   u32 pos;            /* index to write to */
   u32 size;
   u32 alloc_size;
};
 
struct buffer_timeout {
   struct delayed_work wq;        /* work queue */
   bool initialized;        /* timer one-time setup flag */
   struct host1x_syncpt *syncpt;    /* buffer completion syncpt */
   u32 syncpt_val;            /* syncpt value when completed */
   ktime_t start_ktime;        /* starting time */
   /* context timeout information */
   struct host1x_client *client;
};
 
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 */
};
 
struct host1x_cdma {
   struct mutex lock;        /* controls access to shared state */
   struct completion complete;    /* signalled when event occurs */
   enum cdma_event event;        /* event that complete 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_pos;        /* 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 */
   bool running;
   bool torndown;
};
 
#define cdma_to_channel(cdma) container_of(cdma, struct host1x_channel, cdma)
#define cdma_to_host1x(cdma) dev_get_drvdata(cdma_to_channel(cdma)->dev->parent)
#define pb_to_cdma(pb) container_of(pb, struct host1x_cdma, push_buffer)
 
int host1x_cdma_init(struct host1x_cdma *cdma);
int host1x_cdma_deinit(struct host1x_cdma *cdma);
int host1x_cdma_begin(struct host1x_cdma *cdma, struct host1x_job *job);
void host1x_cdma_push(struct host1x_cdma *cdma, u32 op1, u32 op2);
void host1x_cdma_push_wide(struct host1x_cdma *cdma, u32 op1, u32 op2,
              u32 op3, u32 op4);
void host1x_cdma_end(struct host1x_cdma *cdma, struct host1x_job *job);
void host1x_cdma_update(struct host1x_cdma *cdma);
void host1x_cdma_peek(struct host1x_cdma *cdma, u32 dmaget, int slot,
             u32 *out);
unsigned int host1x_cdma_wait_locked(struct host1x_cdma *cdma,
                    enum cdma_event event);
void host1x_cdma_update_sync_queue(struct host1x_cdma *cdma,
                  struct device *dev);
#endif