1 /* 2 * Copyright 2012 Red Hat Inc. 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 * Authors: Ben Skeggs 23 */ 24 #include "priv.h" 25 26 #include <subdev/bar.h> 27 28 /****************************************************************************** 29 * instmem object base implementation 30 *****************************************************************************/ 31 void 32 nvkm_instobj_load(struct nvkm_instobj *iobj) 33 { 34 struct nvkm_memory *memory = &iobj->memory; 35 const u64 size = nvkm_memory_size(memory); 36 void __iomem *map; 37 int i; 38 39 if (!(map = nvkm_kmap(memory))) { 40 for (i = 0; i < size; i += 4) 41 nvkm_wo32(memory, i, iobj->suspend[i / 4]); 42 } else { 43 memcpy_toio(map, iobj->suspend, size); 44 } 45 nvkm_done(memory); 46 47 kvfree(iobj->suspend); 48 iobj->suspend = NULL; 49 } 50 51 int 52 nvkm_instobj_save(struct nvkm_instobj *iobj) 53 { 54 struct nvkm_memory *memory = &iobj->memory; 55 const u64 size = nvkm_memory_size(memory); 56 void __iomem *map; 57 int i; 58 59 iobj->suspend = kvmalloc(size, GFP_KERNEL); 60 if (!iobj->suspend) 61 return -ENOMEM; 62 63 if (!(map = nvkm_kmap(memory))) { 64 for (i = 0; i < size; i += 4) 65 iobj->suspend[i / 4] = nvkm_ro32(memory, i); 66 } else { 67 memcpy_fromio(iobj->suspend, map, size); 68 } 69 nvkm_done(memory); 70 return 0; 71 } 72 73 void 74 nvkm_instobj_dtor(struct nvkm_instmem *imem, struct nvkm_instobj *iobj) 75 { 76 spin_lock(&imem->lock); 77 list_del(&iobj->head); 78 spin_unlock(&imem->lock); 79 } 80 81 void 82 nvkm_instobj_ctor(const struct nvkm_memory_func *func, 83 struct nvkm_instmem *imem, struct nvkm_instobj *iobj) 84 { 85 nvkm_memory_ctor(func, &iobj->memory); 86 iobj->suspend = NULL; 87 spin_lock(&imem->lock); 88 list_add_tail(&iobj->head, &imem->list); 89 spin_unlock(&imem->lock); 90 } 91 92 int 93 nvkm_instobj_wrap(struct nvkm_device *device, 94 struct nvkm_memory *memory, struct nvkm_memory **pmemory) 95 { 96 struct nvkm_instmem *imem = device->imem; 97 int ret; 98 99 if (!imem->func->memory_wrap) 100 return -ENOSYS; 101 102 ret = imem->func->memory_wrap(imem, memory, pmemory); 103 if (ret) 104 return ret; 105 106 container_of(*pmemory, struct nvkm_instobj, memory)->preserve = true; 107 return 0; 108 } 109 110 int 111 nvkm_instobj_new(struct nvkm_instmem *imem, u32 size, u32 align, bool zero, bool preserve, 112 struct nvkm_memory **pmemory) 113 { 114 struct nvkm_subdev *subdev = &imem->subdev; 115 struct nvkm_memory *memory = NULL; 116 u32 offset; 117 int ret; 118 119 ret = imem->func->memory_new(imem, size, align, zero, &memory); 120 if (ret) { 121 nvkm_error(subdev, "OOM: %08x %08x %d\n", size, align, ret); 122 goto done; 123 } 124 125 nvkm_trace(subdev, "new %08x %08x %d: %010llx %010llx\n", size, align, 126 zero, nvkm_memory_addr(memory), nvkm_memory_size(memory)); 127 128 if (!imem->func->zero && zero) { 129 void __iomem *map = nvkm_kmap(memory); 130 if (unlikely(!map)) { 131 for (offset = 0; offset < size; offset += 4) 132 nvkm_wo32(memory, offset, 0x00000000); 133 } else { 134 memset_io(map, 0x00, size); 135 } 136 nvkm_done(memory); 137 } 138 139 container_of(memory, struct nvkm_instobj, memory)->preserve = preserve; 140 done: 141 if (ret) 142 nvkm_memory_unref(&memory); 143 *pmemory = memory; 144 return ret; 145 } 146 147 /****************************************************************************** 148 * instmem subdev base implementation 149 *****************************************************************************/ 150 151 u32 152 nvkm_instmem_rd32(struct nvkm_instmem *imem, u32 addr) 153 { 154 return imem->func->rd32(imem, addr); 155 } 156 157 void 158 nvkm_instmem_wr32(struct nvkm_instmem *imem, u32 addr, u32 data) 159 { 160 return imem->func->wr32(imem, addr, data); 161 } 162 163 void 164 nvkm_instmem_boot(struct nvkm_instmem *imem) 165 { 166 /* Separate bootstrapped objects from normal list, as we need 167 * to make sure they're accessed with the slowpath on suspend 168 * and resume. 169 */ 170 struct nvkm_instobj *iobj, *itmp; 171 spin_lock(&imem->lock); 172 list_for_each_entry_safe(iobj, itmp, &imem->list, head) { 173 list_move_tail(&iobj->head, &imem->boot); 174 } 175 spin_unlock(&imem->lock); 176 } 177 178 static int 179 nvkm_instmem_fini(struct nvkm_subdev *subdev, bool suspend) 180 { 181 struct nvkm_instmem *imem = nvkm_instmem(subdev); 182 int ret; 183 184 if (suspend) { 185 ret = imem->func->suspend(imem); 186 if (ret) 187 return ret; 188 189 imem->suspend = true; 190 } 191 192 if (imem->func->fini) 193 imem->func->fini(imem); 194 195 return 0; 196 } 197 198 static int 199 nvkm_instmem_init(struct nvkm_subdev *subdev) 200 { 201 struct nvkm_instmem *imem = nvkm_instmem(subdev); 202 203 if (imem->suspend) { 204 if (imem->func->resume) 205 imem->func->resume(imem); 206 207 imem->suspend = false; 208 return 0; 209 } 210 211 nvkm_bar_bar2_init(subdev->device); 212 return 0; 213 } 214 215 static int 216 nvkm_instmem_oneinit(struct nvkm_subdev *subdev) 217 { 218 struct nvkm_instmem *imem = nvkm_instmem(subdev); 219 if (imem->func->oneinit) 220 return imem->func->oneinit(imem); 221 return 0; 222 } 223 224 static void * 225 nvkm_instmem_dtor(struct nvkm_subdev *subdev) 226 { 227 struct nvkm_instmem *imem = nvkm_instmem(subdev); 228 void *data = imem; 229 if (imem->func->dtor) 230 data = imem->func->dtor(imem); 231 mutex_destroy(&imem->mutex); 232 return data; 233 } 234 235 static const struct nvkm_subdev_func 236 nvkm_instmem = { 237 .dtor = nvkm_instmem_dtor, 238 .oneinit = nvkm_instmem_oneinit, 239 .init = nvkm_instmem_init, 240 .fini = nvkm_instmem_fini, 241 }; 242 243 void 244 nvkm_instmem_ctor(const struct nvkm_instmem_func *func, struct nvkm_device *device, 245 enum nvkm_subdev_type type, int inst, struct nvkm_instmem *imem) 246 { 247 nvkm_subdev_ctor(&nvkm_instmem, device, type, inst, &imem->subdev); 248 imem->func = func; 249 spin_lock_init(&imem->lock); 250 INIT_LIST_HEAD(&imem->list); 251 INIT_LIST_HEAD(&imem->boot); 252 mutex_init(&imem->mutex); 253 } 254