1 /* 2 * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 */ 23 #include "qmgr.h" 24 25 static bool 26 nvkm_falcon_cmdq_has_room(struct nvkm_falcon_cmdq *cmdq, u32 size, bool *rewind) 27 { 28 u32 head = nvkm_falcon_rd32(cmdq->qmgr->falcon, cmdq->head_reg); 29 u32 tail = nvkm_falcon_rd32(cmdq->qmgr->falcon, cmdq->tail_reg); 30 u32 free; 31 32 size = ALIGN(size, QUEUE_ALIGNMENT); 33 34 if (head >= tail) { 35 free = cmdq->offset + cmdq->size - head; 36 free -= HDR_SIZE; 37 38 if (size > free) { 39 *rewind = true; 40 head = cmdq->offset; 41 } 42 } 43 44 if (head < tail) 45 free = tail - head - 1; 46 47 return size <= free; 48 } 49 50 static void 51 nvkm_falcon_cmdq_push(struct nvkm_falcon_cmdq *cmdq, void *data, u32 size) 52 { 53 struct nvkm_falcon *falcon = cmdq->qmgr->falcon; 54 nvkm_falcon_load_dmem(falcon, data, cmdq->position, size, 0); 55 cmdq->position += ALIGN(size, QUEUE_ALIGNMENT); 56 } 57 58 static void 59 nvkm_falcon_cmdq_rewind(struct nvkm_falcon_cmdq *cmdq) 60 { 61 struct nv_falcon_cmd cmd; 62 63 cmd.unit_id = NV_FALCON_CMD_UNIT_ID_REWIND; 64 cmd.size = sizeof(cmd); 65 nvkm_falcon_cmdq_push(cmdq, &cmd, cmd.size); 66 67 cmdq->position = cmdq->offset; 68 } 69 70 static int 71 nvkm_falcon_cmdq_open(struct nvkm_falcon_cmdq *cmdq, u32 size) 72 { 73 struct nvkm_falcon *falcon = cmdq->qmgr->falcon; 74 bool rewind = false; 75 76 mutex_lock(&cmdq->mutex); 77 78 if (!nvkm_falcon_cmdq_has_room(cmdq, size, &rewind)) { 79 FLCNQ_DBG(cmdq, "queue full"); 80 mutex_unlock(&cmdq->mutex); 81 return -EAGAIN; 82 } 83 84 cmdq->position = nvkm_falcon_rd32(falcon, cmdq->head_reg); 85 86 if (rewind) 87 nvkm_falcon_cmdq_rewind(cmdq); 88 89 return 0; 90 } 91 92 static void 93 nvkm_falcon_cmdq_close(struct nvkm_falcon_cmdq *cmdq) 94 { 95 nvkm_falcon_wr32(cmdq->qmgr->falcon, cmdq->head_reg, cmdq->position); 96 mutex_unlock(&cmdq->mutex); 97 } 98 99 static int 100 nvkm_falcon_cmdq_write(struct nvkm_falcon_cmdq *cmdq, struct nv_falcon_cmd *cmd) 101 { 102 static unsigned timeout = 2000; 103 unsigned long end_jiffies = jiffies + msecs_to_jiffies(timeout); 104 int ret = -EAGAIN; 105 106 while (ret == -EAGAIN && time_before(jiffies, end_jiffies)) 107 ret = nvkm_falcon_cmdq_open(cmdq, cmd->size); 108 if (ret) { 109 FLCNQ_ERR(cmdq, "timeout waiting for queue space"); 110 return ret; 111 } 112 113 nvkm_falcon_cmdq_push(cmdq, cmd, cmd->size); 114 nvkm_falcon_cmdq_close(cmdq); 115 return ret; 116 } 117 118 /* specifies that we want to know the command status in the answer message */ 119 #define CMD_FLAGS_STATUS BIT(0) 120 /* specifies that we want an interrupt when the answer message is queued */ 121 #define CMD_FLAGS_INTR BIT(1) 122 123 int 124 nvkm_falcon_cmdq_send(struct nvkm_falcon_cmdq *cmdq, struct nv_falcon_cmd *cmd, 125 nvkm_falcon_qmgr_callback cb, void *priv, 126 unsigned long timeout) 127 { 128 struct nvkm_falcon_qmgr_seq *seq; 129 int ret; 130 131 if (!wait_for_completion_timeout(&cmdq->ready, 132 msecs_to_jiffies(1000))) { 133 FLCNQ_ERR(cmdq, "timeout waiting for queue ready"); 134 return -ETIMEDOUT; 135 } 136 137 seq = nvkm_falcon_qmgr_seq_acquire(cmdq->qmgr); 138 if (IS_ERR(seq)) 139 return PTR_ERR(seq); 140 141 cmd->seq_id = seq->id; 142 cmd->ctrl_flags = CMD_FLAGS_STATUS | CMD_FLAGS_INTR; 143 144 seq->state = SEQ_STATE_USED; 145 seq->async = !timeout; 146 seq->callback = cb; 147 seq->priv = priv; 148 149 ret = nvkm_falcon_cmdq_write(cmdq, cmd); 150 if (ret) { 151 seq->state = SEQ_STATE_PENDING; 152 nvkm_falcon_qmgr_seq_release(cmdq->qmgr, seq); 153 return ret; 154 } 155 156 if (!seq->async) { 157 if (!wait_for_completion_timeout(&seq->done, timeout)) { 158 FLCNQ_ERR(cmdq, "timeout waiting for reply"); 159 return -ETIMEDOUT; 160 } 161 ret = seq->result; 162 nvkm_falcon_qmgr_seq_release(cmdq->qmgr, seq); 163 } 164 165 return ret; 166 } 167 168 void 169 nvkm_falcon_cmdq_fini(struct nvkm_falcon_cmdq *cmdq) 170 { 171 reinit_completion(&cmdq->ready); 172 } 173 174 void 175 nvkm_falcon_cmdq_init(struct nvkm_falcon_cmdq *cmdq, 176 u32 index, u32 offset, u32 size) 177 { 178 const struct nvkm_falcon_func *func = cmdq->qmgr->falcon->func; 179 180 cmdq->head_reg = func->cmdq.head + index * func->cmdq.stride; 181 cmdq->tail_reg = func->cmdq.tail + index * func->cmdq.stride; 182 cmdq->offset = offset; 183 cmdq->size = size; 184 complete_all(&cmdq->ready); 185 186 FLCNQ_DBG(cmdq, "initialised @ index %d offset 0x%08x size 0x%08x", 187 index, cmdq->offset, cmdq->size); 188 } 189 190 void 191 nvkm_falcon_cmdq_del(struct nvkm_falcon_cmdq **pcmdq) 192 { 193 struct nvkm_falcon_cmdq *cmdq = *pcmdq; 194 if (cmdq) { 195 kfree(*pcmdq); 196 *pcmdq = NULL; 197 } 198 } 199 200 int 201 nvkm_falcon_cmdq_new(struct nvkm_falcon_qmgr *qmgr, const char *name, 202 struct nvkm_falcon_cmdq **pcmdq) 203 { 204 struct nvkm_falcon_cmdq *cmdq = *pcmdq; 205 206 if (!(cmdq = *pcmdq = kzalloc(sizeof(*cmdq), GFP_KERNEL))) 207 return -ENOMEM; 208 209 cmdq->qmgr = qmgr; 210 cmdq->name = name; 211 mutex_init(&cmdq->mutex); 212 init_completion(&cmdq->ready); 213 return 0; 214 } 215