Pileus Git - ~andy/linux/blob - drivers/gpu/drm/nouveau/core/subdev/ltcg/nvc0.c

   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
  25 #include <subdev/ltcg.h>
  26 #include <subdev/fb.h>
  27 #include <subdev/timer.h>
  28
  29 struct nvc0_ltcg_priv {
  30         struct nouveau_ltcg base;
  31         u32 part_nr;
  32         u32 part_mask;
  33         u32 subp_nr;
  34         struct nouveau_mm tags;
  35         u32 num_tags;
  36         struct nouveau_mm_node *tag_ram;
  37 };
  38
  39 static void
  40 nvc0_ltcg_subp_isr(struct nvc0_ltcg_priv *priv, int unit, int subp)
  41 {
  42         u32 subp_base = 0x141000 + (unit * 0x2000) + (subp * 0x400);
  43         u32 stat = nv_rd32(priv, subp_base + 0x020);
  44
  45         if (stat) {
  46                 nv_info(priv, "LTC%d_LTS%d: 0x%08x\n", unit, subp, stat);
  47                 nv_wr32(priv, subp_base + 0x020, stat);
  48         }
  49 }
  50
  51 static void
  52 nvc0_ltcg_intr(struct nouveau_subdev *subdev)
  53 {
  54         struct nvc0_ltcg_priv *priv = (void *)subdev;
  55         u32 units;
  56
  57         units = nv_rd32(priv, 0x00017c);
  58         while (units) {
  59                 u32 subp, unit = ffs(units) - 1;
  60                 for (subp = 0; subp < priv->subp_nr; subp++)
  61                         nvc0_ltcg_subp_isr(priv, unit, subp);
  62                 units &= ~(1 << unit);
  63         }
  64
  65         /* we do something horribly wrong and upset PMFB a lot, so mask off
  66          * interrupts from it after the first one until it's fixed
  67          */
  68         nv_mask(priv, 0x000640, 0x02000000, 0x00000000);
  69 }
  70
  71 static int
  72 nvc0_ltcg_tags_alloc(struct nouveau_ltcg *ltcg, u32 n,
  73                      struct nouveau_mm_node **pnode)
  74 {
  75         struct nvc0_ltcg_priv *priv = (struct nvc0_ltcg_priv *)ltcg;
  76         int ret;
  77
  78         ret = nouveau_mm_head(&priv->tags, 1, n, n, 1, pnode);
  79         if (ret)
  80                 *pnode = NULL;
  81
  82         return ret;
  83 }
  84
  85 static void
  86 nvc0_ltcg_tags_free(struct nouveau_ltcg *ltcg, struct nouveau_mm_node **pnode)
  87 {
  88         struct nvc0_ltcg_priv *priv = (struct nvc0_ltcg_priv *)ltcg;
  89
  90         nouveau_mm_free(&priv->tags, pnode);
  91 }
  92
  93 static void
  94 nvc0_ltcg_tags_clear(struct nouveau_ltcg *ltcg, u32 first, u32 count)
  95 {
  96         struct nvc0_ltcg_priv *priv = (struct nvc0_ltcg_priv *)ltcg;
  97         u32 last = first + count - 1;
  98         int p, i;
  99
 100         BUG_ON((first > last) || (last >= priv->num_tags));
 101
 102         nv_wr32(priv, 0x17e8cc, first);
 103         nv_wr32(priv, 0x17e8d0, last);
 104         nv_wr32(priv, 0x17e8c8, 0x4); /* trigger clear */
 105
 106         /* wait until it's finished with clearing */
 107         for (p = 0; p < priv->part_nr; ++p) {
 108                 if (!(priv->part_mask & (1 << p)))
 109                         continue;
 110                 for (i = 0; i < priv->subp_nr; ++i)
 111                         nv_wait(priv, 0x1410c8 + p * 0x2000 + i * 0x400, ~0, 0);
 112         }
 113 }
 114
 115 /* TODO: Figure out tag memory details and drop the over-cautious allocation.
 116  */
 117 static int
 118 nvc0_ltcg_init_tag_ram(struct nouveau_fb *pfb, struct nvc0_ltcg_priv *priv)
 119 {
 120         u32 tag_size, tag_margin, tag_align;
 121         int ret;
 122
 123         nv_wr32(priv, 0x17e8d8, priv->part_nr);
 124
 125         /* tags for 1/4 of VRAM should be enough (8192/4 per GiB of VRAM) */
 126         priv->num_tags = (pfb->ram.size >> 17) / 4;
 127         if (priv->num_tags > (1 << 17))
 128                 priv->num_tags = 1 << 17; /* we have 17 bits in PTE */
 129         priv->num_tags = (priv->num_tags + 63) & ~63; /* round up to 64 */
 130
 131         tag_align = priv->part_nr * 0x800;
 132         tag_margin = (tag_align < 0x6000) ? 0x6000 : tag_align;
 133
 134         /* 4 part 4 sub: 0x2000 bytes for 56 tags */
 135         /* 3 part 4 sub: 0x6000 bytes for 168 tags */
 136         /*
 137          * About 147 bytes per tag. Let's be safe and allocate x2, which makes
 138          * 0x4980 bytes for 64 tags, and round up to 0x6000 bytes for 64 tags.
 139          *
 140          * For 4 GiB of memory we'll have 8192 tags which makes 3 MiB, < 0.1 %.
 141          */
 142         tag_size  = (priv->num_tags / 64) * 0x6000 + tag_margin;
 143         tag_size += tag_align;
 144         tag_size  = (tag_size + 0xfff) >> 12; /* round up */
 145
 146         ret = nouveau_mm_tail(&pfb->vram, 0, tag_size, tag_size, 1,
 147                               &priv->tag_ram);
 148         if (ret) {
 149                 priv->num_tags = 0;
 150         } else {
 151                 u64 tag_base = (priv->tag_ram->offset << 12) + tag_margin;
 152
 153                 tag_base += tag_align - 1;
 154                 ret = do_div(tag_base, tag_align);
 155
 156                 nv_wr32(priv, 0x17e8d4, tag_base);
 157         }
 158         ret = nouveau_mm_init(&priv->tags, 0, priv->num_tags, 1);
 159
 160         return ret;
 161 }
 162
 163 static int
 164 nvc0_ltcg_ctor(struct nouveau_object *parent, struct nouveau_object *engine,
 165                struct nouveau_oclass *oclass, void *data, u32 size,
 166                struct nouveau_object **pobject)
 167 {
 168         struct nvc0_ltcg_priv *priv;
 169         struct nouveau_fb *pfb = nouveau_fb(parent);
 170         int ret;
 171
 172         ret = nouveau_ltcg_create(parent, engine, oclass, &priv);
 173         *pobject = nv_object(priv);
 174         if (ret)
 175                 return ret;
 176
 177         priv->part_nr = nv_rd32(priv, 0x022438);
 178         priv->part_mask = nv_rd32(priv, 0x022554);
 179
 180         priv->subp_nr = nv_rd32(priv, 0x17e8dc) >> 28;
 181
 182         nv_mask(priv, 0x17e820, 0x00100000, 0x00000000); /* INTR_EN &= ~0x10 */
 183
 184         ret = nvc0_ltcg_init_tag_ram(pfb, priv);
 185         if (ret)
 186                 return ret;
 187
 188         priv->base.tags_alloc = nvc0_ltcg_tags_alloc;
 189         priv->base.tags_free  = nvc0_ltcg_tags_free;
 190         priv->base.tags_clear = nvc0_ltcg_tags_clear;
 191
 192         nv_subdev(priv)->intr = nvc0_ltcg_intr;
 193         return 0;
 194 }
 195
 196 static void
 197 nvc0_ltcg_dtor(struct nouveau_object *object)
 198 {
 199         struct nouveau_ltcg *ltcg = (struct nouveau_ltcg *)object;
 200         struct nvc0_ltcg_priv *priv = (struct nvc0_ltcg_priv *)ltcg;
 201         struct nouveau_fb *pfb = nouveau_fb(ltcg->base.base.parent);
 202
 203         nouveau_mm_fini(&priv->tags);
 204         nouveau_mm_free(&pfb->vram, &priv->tag_ram);
 205
 206         nouveau_ltcg_destroy(ltcg);
 207 }
 208
 209 struct nouveau_oclass
 210 nvc0_ltcg_oclass = {
 211         .handle = NV_SUBDEV(LTCG, 0xc0),
 212         .ofuncs = &(struct nouveau_ofuncs) {
 213                 .ctor = nvc0_ltcg_ctor,
 214                 .dtor = nvc0_ltcg_dtor,
 215                 .init = _nouveau_ltcg_init,
 216                 .fini = _nouveau_ltcg_fini,
 217         },
 218 };