drivers/gpu/drm/nouveau/core/subdev/fb/ramnvc0.c

   1 /*
   2  * Copyright 2013 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
  25 #include <subdev/bios.h>
  26 #include <subdev/ltcg.h>
  27
  28 #include "priv.h"
  29
  30 extern const u8 nvc0_pte_storage_type_map[256];
  31
  32 void
  33 nvc0_ram_put(struct nouveau_fb *pfb, struct nouveau_mem **pmem)
  34 {
  35         struct nouveau_ltcg *ltcg = nouveau_ltcg(pfb);
  36
  37         if ((*pmem)->tag)
  38                 ltcg->tags_free(ltcg, &(*pmem)->tag);
  39
  40         nv50_ram_put(pfb, pmem);
  41 }
  42
  43 int
  44 nvc0_ram_get(struct nouveau_fb *pfb, u64 size, u32 align, u32 ncmin,
  45              u32 memtype, struct nouveau_mem **pmem)
  46 {
  47         struct nouveau_mm *mm = &pfb->vram;
  48         struct nouveau_mm_node *r;
  49         struct nouveau_mem *mem;
  50         int type = (memtype & 0x0ff);
  51         int back = (memtype & 0x800);
  52         const bool comp = nvc0_pte_storage_type_map[type] != type;
  53         int ret;
  54
  55         size  >>= 12;
  56         align >>= 12;
  57         ncmin >>= 12;
  58         if (!ncmin)
  59                 ncmin = size;
  60
  61         mem = kzalloc(sizeof(*mem), GFP_KERNEL);
  62         if (!mem)
  63                 return -ENOMEM;
  64
  65         INIT_LIST_HEAD(&mem->regions);
  66         mem->size = size;
  67
  68         mutex_lock(&pfb->base.mutex);
  69         if (comp) {
  70                 struct nouveau_ltcg *ltcg = nouveau_ltcg(pfb);
  71
  72                 /* compression only works with lpages */
  73                 if (align == (1 << (17 - 12))) {
  74                         int n = size >> 5;
  75                         ltcg->tags_alloc(ltcg, n, &mem->tag);
  76                 }
  77
  78                 if (unlikely(!mem->tag))
  79                         type = nvc0_pte_storage_type_map[type];
  80         }
  81         mem->memtype = type;
  82
  83         do {
  84                 if (back)
  85                         ret = nouveau_mm_tail(mm, 1, size, ncmin, align, &r);
  86                 else
  87                         ret = nouveau_mm_head(mm, 1, size, ncmin, align, &r);
  88                 if (ret) {
  89                         mutex_unlock(&pfb->base.mutex);
  90                         pfb->ram->put(pfb, &mem);
  91                         return ret;
  92                 }
  93
  94                 list_add_tail(&r->rl_entry, &mem->regions);
  95                 size -= r->length;
  96         } while (size);
  97         mutex_unlock(&pfb->base.mutex);
  98
  99         r = list_first_entry(&mem->regions, struct nouveau_mm_node, rl_entry);
 100         mem->offset = (u64)r->offset << 12;
 101         *pmem = mem;
 102         return 0;
 103 }
 104
 105 static int
 106 nvc0_ram_create(struct nouveau_object *parent, struct nouveau_object *engine,
 107                 struct nouveau_oclass *oclass, void *data, u32 size,
 108                 struct nouveau_object **pobject)
 109 {
 110         struct nouveau_fb *pfb = nouveau_fb(parent);
 111         struct nouveau_bios *bios = nouveau_bios(pfb);
 112         struct nouveau_ram *ram;
 113         const u32 rsvd_head = ( 256 * 1024) >> 12; /* vga memory */
 114         const u32 rsvd_tail = (1024 * 1024) >> 12; /* vbios etc */
 115         u32 parts = nv_rd32(pfb, 0x022438);
 116         u32 pmask = nv_rd32(pfb, 0x022554);
 117         u32 bsize = nv_rd32(pfb, 0x10f20c);
 118         u32 offset, length;
 119         bool uniform = true;
 120         int ret, part;
 121
 122         ret = nouveau_ram_create(parent, engine, oclass, &ram);
 123         *pobject = nv_object(ram);
 124         if (ret)
 125                 return ret;
 126
 127         nv_debug(pfb, "0x100800: 0x%08x\n", nv_rd32(pfb, 0x100800));
 128         nv_debug(pfb, "parts 0x%08x mask 0x%08x\n", parts, pmask);
 129
 130         ram->type = nouveau_fb_bios_memtype(bios);
 131         ram->ranks = (nv_rd32(pfb, 0x10f200) & 0x00000004) ? 2 : 1;
 132
 133         /* read amount of vram attached to each memory controller */
 134         for (part = 0; part < parts; part++) {
 135                 if (!(pmask & (1 << part))) {
 136                         u32 psize = nv_rd32(pfb, 0x11020c + (part * 0x1000));
 137                         if (psize != bsize) {
 138                                 if (psize < bsize)
 139                                         bsize = psize;
 140                                 uniform = false;
 141                         }
 142
 143                         nv_debug(pfb, "%d: mem_amount 0x%08x\n", part, psize);
 144                         ram->size += (u64)psize << 20;
 145                 }
 146         }
 147
 148         /* if all controllers have the same amount attached, there's no holes */
 149         if (uniform) {
 150                 offset = rsvd_head;
 151                 length = (ram->size >> 12) - rsvd_head - rsvd_tail;
 152                 ret = nouveau_mm_init(&pfb->vram, offset, length, 1);
 153         } else {
 154                 /* otherwise, address lowest common amount from 0GiB */
 155                 ret = nouveau_mm_init(&pfb->vram, rsvd_head,
 156                                       (bsize << 8) * parts, 1);
 157                 if (ret)
 158                         return ret;
 159
 160                 /* and the rest starting from (8GiB + common_size) */
 161                 offset = (0x0200000000ULL >> 12) + (bsize << 8);
 162                 length = (ram->size >> 12) - (bsize << 8) - rsvd_tail;
 163
 164                 ret = nouveau_mm_init(&pfb->vram, offset, length, 0);
 165                 if (ret)
 166                         nouveau_mm_fini(&pfb->vram);
 167         }
 168
 169         if (ret)
 170                 return ret;
 171
 172         ram->get = nvc0_ram_get;
 173         ram->put = nvc0_ram_put;
 174         return 0;
 175 }
 176
 177 struct nouveau_oclass
 178 nvc0_ram_oclass = {
 179         .handle = 0,
 180         .ofuncs = &(struct nouveau_ofuncs) {
 181                 .ctor = nvc0_ram_create,
 182                 .dtor = _nouveau_ram_dtor,
 183                 .init = _nouveau_ram_init,
 184                 .fini = _nouveau_ram_fini,
 185         }
 186 };