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 *****************************************************************************/ 31void 32nvkm_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 51int 52nvkm_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 73void 74nvkm_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 81void 82nvkm_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 92int 93nvkm_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 110int 111nvkm_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; 140done: 141 if (ret) 142 nvkm_memory_unref(&memory); 143 *pmemory = memory; 144 return ret; 145} 146 147/****************************************************************************** 148 * instmem subdev base implementation 149 *****************************************************************************/ 150 151u32 152nvkm_instmem_rd32(struct nvkm_instmem *imem, u32 addr) 153{ 154 return imem->func->rd32(imem, addr); 155} 156 157void 158nvkm_instmem_wr32(struct nvkm_instmem *imem, u32 addr, u32 data) 159{ 160 return imem->func->wr32(imem, addr, data); 161} 162 163void 164nvkm_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 178static int 179nvkm_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 198static int 199nvkm_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 215static int 216nvkm_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 224static void * 225nvkm_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 235static const struct nvkm_subdev_func 236nvkm_instmem = { 237 .dtor = nvkm_instmem_dtor, 238 .oneinit = nvkm_instmem_oneinit, 239 .init = nvkm_instmem_init, 240 .fini = nvkm_instmem_fini, 241}; 242 243void 244nvkm_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