root/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/base.c

DEFINITIONS

1. nvkm_instobj_load
2. nvkm_instobj_save
3. nvkm_instobj_dtor
4. nvkm_instobj_ctor
5. nvkm_instobj_new
6. nvkm_instmem_rd32
7. nvkm_instmem_wr32
8. nvkm_instmem_boot
9. nvkm_instmem_fini
10. nvkm_instmem_init
11. nvkm_instmem_oneinit
12. nvkm_instmem_dtor
13. nvkm_instmem_ctor

   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 static 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 static 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_new(struct nvkm_instmem *imem, u32 size, u32 align, bool zero,
  94                  struct nvkm_memory **pmemory)
  95 {
  96         struct nvkm_subdev *subdev = &imem->subdev;
  97         struct nvkm_memory *memory = NULL;
  98         u32 offset;
  99         int ret;
 100 
 101         ret = imem->func->memory_new(imem, size, align, zero, &memory);
 102         if (ret) {
 103                 nvkm_error(subdev, "OOM: %08x %08x %d\n", size, align, ret);
 104                 goto done;
 105         }
 106 
 107         nvkm_trace(subdev, "new %08x %08x %d: %010llx %010llx\n", size, align,
 108                    zero, nvkm_memory_addr(memory), nvkm_memory_size(memory));
 109 
 110         if (!imem->func->zero && zero) {
 111                 void __iomem *map = nvkm_kmap(memory);
 112                 if (unlikely(!map)) {
 113                         for (offset = 0; offset < size; offset += 4)
 114                                 nvkm_wo32(memory, offset, 0x00000000);
 115                 } else {
 116                         memset_io(map, 0x00, size);
 117                 }
 118                 nvkm_done(memory);
 119         }
 120 
 121 done:
 122         if (ret)
 123                 nvkm_memory_unref(&memory);
 124         *pmemory = memory;
 125         return ret;
 126 }
 127 
 128 /******************************************************************************
 129  * instmem subdev base implementation
 130  *****************************************************************************/
 131 
 132 u32
 133 nvkm_instmem_rd32(struct nvkm_instmem *imem, u32 addr)
 134 {
 135         return imem->func->rd32(imem, addr);
 136 }
 137 
 138 void
 139 nvkm_instmem_wr32(struct nvkm_instmem *imem, u32 addr, u32 data)
 140 {
 141         return imem->func->wr32(imem, addr, data);
 142 }
 143 
 144 void
 145 nvkm_instmem_boot(struct nvkm_instmem *imem)
 146 {
 147         /* Separate bootstrapped objects from normal list, as we need
 148          * to make sure they're accessed with the slowpath on suspend
 149          * and resume.
 150          */
 151         struct nvkm_instobj *iobj, *itmp;
 152         spin_lock(&imem->lock);
 153         list_for_each_entry_safe(iobj, itmp, &imem->list, head) {
 154                 list_move_tail(&iobj->head, &imem->boot);
 155         }
 156         spin_unlock(&imem->lock);
 157 }
 158 
 159 static int
 160 nvkm_instmem_fini(struct nvkm_subdev *subdev, bool suspend)
 161 {
 162         struct nvkm_instmem *imem = nvkm_instmem(subdev);
 163         struct nvkm_instobj *iobj;
 164 
 165         if (suspend) {
 166                 list_for_each_entry(iobj, &imem->list, head) {
 167                         int ret = nvkm_instobj_save(iobj);
 168                         if (ret)
 169                                 return ret;
 170                 }
 171 
 172                 nvkm_bar_bar2_fini(subdev->device);
 173 
 174                 list_for_each_entry(iobj, &imem->boot, head) {
 175                         int ret = nvkm_instobj_save(iobj);
 176                         if (ret)
 177                                 return ret;
 178                 }
 179         }
 180 
 181         if (imem->func->fini)
 182                 imem->func->fini(imem);
 183 
 184         return 0;
 185 }
 186 
 187 static int
 188 nvkm_instmem_init(struct nvkm_subdev *subdev)
 189 {
 190         struct nvkm_instmem *imem = nvkm_instmem(subdev);
 191         struct nvkm_instobj *iobj;
 192 
 193         list_for_each_entry(iobj, &imem->boot, head) {
 194                 if (iobj->suspend)
 195                         nvkm_instobj_load(iobj);
 196         }
 197 
 198         nvkm_bar_bar2_init(subdev->device);
 199 
 200         list_for_each_entry(iobj, &imem->list, head) {
 201                 if (iobj->suspend)
 202                         nvkm_instobj_load(iobj);
 203         }
 204 
 205         return 0;
 206 }
 207 
 208 static int
 209 nvkm_instmem_oneinit(struct nvkm_subdev *subdev)
 210 {
 211         struct nvkm_instmem *imem = nvkm_instmem(subdev);
 212         if (imem->func->oneinit)
 213                 return imem->func->oneinit(imem);
 214         return 0;
 215 }
 216 
 217 static void *
 218 nvkm_instmem_dtor(struct nvkm_subdev *subdev)
 219 {
 220         struct nvkm_instmem *imem = nvkm_instmem(subdev);
 221         if (imem->func->dtor)
 222                 return imem->func->dtor(imem);
 223         return imem;
 224 }
 225 
 226 static const struct nvkm_subdev_func
 227 nvkm_instmem = {
 228         .dtor = nvkm_instmem_dtor,
 229         .oneinit = nvkm_instmem_oneinit,
 230         .init = nvkm_instmem_init,
 231         .fini = nvkm_instmem_fini,
 232 };
 233 
 234 void
 235 nvkm_instmem_ctor(const struct nvkm_instmem_func *func,
 236                   struct nvkm_device *device, int index,
 237                   struct nvkm_instmem *imem)
 238 {
 239         nvkm_subdev_ctor(&nvkm_instmem, device, index, &imem->subdev);
 240         imem->func = func;
 241         spin_lock_init(&imem->lock);
 242         INIT_LIST_HEAD(&imem->list);
 243         INIT_LIST_HEAD(&imem->boot);
 244 }