1 /* 2 * Copyright (c) 2016, 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 20 * DEALINGS IN THE SOFTWARE. 21 */ 22 #include "priv.h" 23 24 #include <subdev/mc.h> 25 #include <subdev/top.h> 26 27 void 28 nvkm_falcon_load_imem(struct nvkm_falcon *falcon, void *data, u32 start, 29 u32 size, u16 tag, u8 port, bool secure) 30 { 31 if (secure && !falcon->secret) { 32 nvkm_warn(falcon->user, 33 "writing with secure tag on a non-secure falcon!\n"); 34 return; 35 } 36 37 falcon->func->load_imem(falcon, data, start, size, tag, port, 38 secure); 39 } 40 41 void 42 nvkm_falcon_load_dmem(struct nvkm_falcon *falcon, void *data, u32 start, 43 u32 size, u8 port) 44 { 45 mutex_lock(&falcon->dmem_mutex); 46 47 falcon->func->load_dmem(falcon, data, start, size, port); 48 49 mutex_unlock(&falcon->dmem_mutex); 50 } 51 52 void 53 nvkm_falcon_read_dmem(struct nvkm_falcon *falcon, u32 start, u32 size, u8 port, 54 void *data) 55 { 56 mutex_lock(&falcon->dmem_mutex); 57 58 falcon->func->read_dmem(falcon, start, size, port, data); 59 60 mutex_unlock(&falcon->dmem_mutex); 61 } 62 63 void 64 nvkm_falcon_bind_context(struct nvkm_falcon *falcon, struct nvkm_memory *inst) 65 { 66 if (!falcon->func->bind_context) { 67 nvkm_error(falcon->user, 68 "Context binding not supported on this falcon!\n"); 69 return; 70 } 71 72 falcon->func->bind_context(falcon, inst); 73 } 74 75 void 76 nvkm_falcon_set_start_addr(struct nvkm_falcon *falcon, u32 start_addr) 77 { 78 falcon->func->set_start_addr(falcon, start_addr); 79 } 80 81 void 82 nvkm_falcon_start(struct nvkm_falcon *falcon) 83 { 84 falcon->func->start(falcon); 85 } 86 87 int 88 nvkm_falcon_enable(struct nvkm_falcon *falcon) 89 { 90 struct nvkm_device *device = falcon->owner->device; 91 enum nvkm_devidx id = falcon->owner->index; 92 int ret; 93 94 nvkm_mc_enable(device, id); 95 ret = falcon->func->enable(falcon); 96 if (ret) { 97 nvkm_mc_disable(device, id); 98 return ret; 99 } 100 101 return 0; 102 } 103 104 void 105 nvkm_falcon_disable(struct nvkm_falcon *falcon) 106 { 107 struct nvkm_device *device = falcon->owner->device; 108 enum nvkm_devidx id = falcon->owner->index; 109 110 /* already disabled, return or wait_idle will timeout */ 111 if (!nvkm_mc_enabled(device, id)) 112 return; 113 114 falcon->func->disable(falcon); 115 116 nvkm_mc_disable(device, id); 117 } 118 119 int 120 nvkm_falcon_reset(struct nvkm_falcon *falcon) 121 { 122 nvkm_falcon_disable(falcon); 123 return nvkm_falcon_enable(falcon); 124 } 125 126 int 127 nvkm_falcon_wait_for_halt(struct nvkm_falcon *falcon, u32 ms) 128 { 129 return falcon->func->wait_for_halt(falcon, ms); 130 } 131 132 int 133 nvkm_falcon_clear_interrupt(struct nvkm_falcon *falcon, u32 mask) 134 { 135 return falcon->func->clear_interrupt(falcon, mask); 136 } 137 138 static int 139 nvkm_falcon_oneinit(struct nvkm_falcon *falcon) 140 { 141 const struct nvkm_falcon_func *func = falcon->func; 142 const struct nvkm_subdev *subdev = falcon->owner; 143 u32 reg; 144 145 if (!falcon->addr) { 146 falcon->addr = nvkm_top_addr(subdev->device, subdev->index); 147 if (WARN_ON(!falcon->addr)) 148 return -ENODEV; 149 } 150 151 reg = nvkm_falcon_rd32(falcon, 0x12c); 152 falcon->version = reg & 0xf; 153 falcon->secret = (reg >> 4) & 0x3; 154 falcon->code.ports = (reg >> 8) & 0xf; 155 falcon->data.ports = (reg >> 12) & 0xf; 156 157 reg = nvkm_falcon_rd32(falcon, 0x108); 158 falcon->code.limit = (reg & 0x1ff) << 8; 159 falcon->data.limit = (reg & 0x3fe00) >> 1; 160 161 if (func->debug) { 162 u32 val = nvkm_falcon_rd32(falcon, func->debug); 163 falcon->debug = (val >> 20) & 0x1; 164 } 165 166 return 0; 167 } 168 169 void 170 nvkm_falcon_put(struct nvkm_falcon *falcon, const struct nvkm_subdev *user) 171 { 172 if (unlikely(!falcon)) 173 return; 174 175 mutex_lock(&falcon->mutex); 176 if (falcon->user == user) { 177 nvkm_debug(falcon->user, "released %s falcon\n", falcon->name); 178 falcon->user = NULL; 179 } 180 mutex_unlock(&falcon->mutex); 181 } 182 183 int 184 nvkm_falcon_get(struct nvkm_falcon *falcon, const struct nvkm_subdev *user) 185 { 186 int ret = 0; 187 188 mutex_lock(&falcon->mutex); 189 if (falcon->user) { 190 nvkm_error(user, "%s falcon already acquired by %s!\n", 191 falcon->name, nvkm_subdev_name[falcon->user->index]); 192 mutex_unlock(&falcon->mutex); 193 return -EBUSY; 194 } 195 196 nvkm_debug(user, "acquired %s falcon\n", falcon->name); 197 if (!falcon->oneinit) 198 ret = nvkm_falcon_oneinit(falcon); 199 falcon->user = user; 200 mutex_unlock(&falcon->mutex); 201 return ret; 202 } 203 204 void 205 nvkm_falcon_dtor(struct nvkm_falcon *falcon) 206 { 207 } 208 209 int 210 nvkm_falcon_ctor(const struct nvkm_falcon_func *func, 211 struct nvkm_subdev *subdev, const char *name, u32 addr, 212 struct nvkm_falcon *falcon) 213 { 214 falcon->func = func; 215 falcon->owner = subdev; 216 falcon->name = name; 217 falcon->addr = addr; 218 mutex_init(&falcon->mutex); 219 mutex_init(&falcon->dmem_mutex); 220 return 0; 221 } 222 223 void 224 nvkm_falcon_del(struct nvkm_falcon **pfalcon) 225 { 226 if (*pfalcon) { 227 nvkm_falcon_dtor(*pfalcon); 228 kfree(*pfalcon); 229 *pfalcon = NULL; 230 } 231 } 232