drivers/gpu/drm/nouveau/nouveau_volt.c

   1 /*
   2  * Copyright 2010 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 "drmP.h"
  26
  27 #include "nouveau_drv.h"
  28 #include "nouveau_pm.h"
  29 #include "nouveau_gpio.h"
  30
  31 static const enum dcb_gpio_tag vidtag[] = { 0x04, 0x05, 0x06, 0x1a, 0x73 };
  32 static int nr_vidtag = sizeof(vidtag) / sizeof(vidtag[0]);
  33
  34 int
  35 nouveau_voltage_gpio_get(struct drm_device *dev)
  36 {
  37         struct drm_nouveau_private *dev_priv = dev->dev_private;
  38         struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
  39         u8 vid = 0;
  40         int i;
  41
  42         for (i = 0; i < nr_vidtag; i++) {
  43                 if (!(volt->vid_mask & (1 << i)))
  44                         continue;
  45
  46                 vid |= nouveau_gpio_func_get(dev, vidtag[i]) << i;
  47         }
  48
  49         return nouveau_volt_lvl_lookup(dev, vid);
  50 }
  51
  52 int
  53 nouveau_voltage_gpio_set(struct drm_device *dev, int voltage)
  54 {
  55         struct drm_nouveau_private *dev_priv = dev->dev_private;
  56         struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
  57         int vid, i;
  58
  59         vid = nouveau_volt_vid_lookup(dev, voltage);
  60         if (vid < 0)
  61                 return vid;
  62
  63         for (i = 0; i < nr_vidtag; i++) {
  64                 if (!(volt->vid_mask & (1 << i)))
  65                         continue;
  66
  67                 nouveau_gpio_func_set(dev, vidtag[i], !!(vid & (1 << i)));
  68         }
  69
  70         return 0;
  71 }
  72
  73 int
  74 nouveau_volt_vid_lookup(struct drm_device *dev, int voltage)
  75 {
  76         struct drm_nouveau_private *dev_priv = dev->dev_private;
  77         struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
  78         int i;
  79
  80         for (i = 0; i < volt->nr_level; i++) {
  81                 if (volt->level[i].voltage == voltage)
  82                         return volt->level[i].vid;
  83         }
  84
  85         return -ENOENT;
  86 }
  87
  88 int
  89 nouveau_volt_lvl_lookup(struct drm_device *dev, int vid)
  90 {
  91         struct drm_nouveau_private *dev_priv = dev->dev_private;
  92         struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
  93         int i;
  94
  95         for (i = 0; i < volt->nr_level; i++) {
  96                 if (volt->level[i].vid == vid)
  97                         return volt->level[i].voltage;
  98         }
  99
 100         return -ENOENT;
 101 }
 102
 103 void
 104 nouveau_volt_init(struct drm_device *dev)
 105 {
 106         struct drm_nouveau_private *dev_priv = dev->dev_private;
 107         struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
 108         struct nouveau_pm_voltage *voltage = &pm->voltage;
 109         struct nvbios *bios = &dev_priv->vbios;
 110         struct bit_entry P;
 111         u8 *volt = NULL, *entry;
 112         int i, headerlen, recordlen, entries, vidmask, vidshift;
 113
 114         if (bios->type == NVBIOS_BIT) {
 115                 if (bit_table(dev, 'P', &P))
 116                         return;
 117
 118                 if (P.version == 1)
 119                         volt = ROMPTR(dev, P.data[16]);
 120                 else
 121                 if (P.version == 2)
 122                         volt = ROMPTR(dev, P.data[12]);
 123                 else {
 124                         NV_WARN(dev, "unknown volt for BIT P %d\n", P.version);
 125                 }
 126         } else {
 127                 if (bios->data[bios->offset + 6] < 0x27) {
 128                         NV_DEBUG(dev, "BMP version too old for voltage\n");
 129                         return;
 130                 }
 131
 132                 volt = ROMPTR(dev, bios->data[bios->offset + 0x98]);
 133         }
 134
 135         if (!volt) {
 136                 NV_DEBUG(dev, "voltage table pointer invalid\n");
 137                 return;
 138         }
 139
 140         switch (volt[0]) {
 141         case 0x10:
 142         case 0x11:
 143         case 0x12:
 144                 headerlen = 5;
 145                 recordlen = volt[1];
 146                 entries   = volt[2];
 147                 vidshift  = 0;
 148                 vidmask   = volt[4];
 149                 break;
 150         case 0x20:
 151                 headerlen = volt[1];
 152                 recordlen = volt[3];
 153                 entries   = volt[2];
 154                 vidshift  = 0; /* could be vidshift like 0x30? */
 155                 vidmask   = volt[5];
 156                 break;
 157         case 0x30:
 158                 headerlen = volt[1];
 159                 recordlen = volt[2];
 160                 entries   = volt[3];
 161                 vidmask   = volt[4];
 162                 /* no longer certain what volt[5] is, if it's related to
 163                  * the vid shift then it's definitely not a function of
 164                  * how many bits are set.
 165                  *
 166                  * after looking at a number of nva3+ vbios images, they
 167                  * all seem likely to have a static shift of 2.. lets
 168                  * go with that for now until proven otherwise.
 169                  */
 170                 vidshift  = 2;
 171                 break;
 172         case 0x40:
 173                 headerlen = volt[1];
 174                 recordlen = volt[2];
 175                 entries   = volt[3]; /* not a clue what the entries are for.. */
 176                 vidmask   = volt[11]; /* guess.. */
 177                 vidshift  = 0;
 178                 break;
 179         default:
 180                 NV_WARN(dev, "voltage table 0x%02x unknown\n", volt[0]);
 181                 return;
 182         }
 183
 184         /* validate vid mask */
 185         voltage->vid_mask = vidmask;
 186         if (!voltage->vid_mask)
 187                 return;
 188
 189         i = 0;
 190         while (vidmask) {
 191                 if (i > nr_vidtag) {
 192                         NV_DEBUG(dev, "vid bit %d unknown\n", i);
 193                         return;
 194                 }
 195
 196                 if (!nouveau_gpio_func_valid(dev, vidtag[i])) {
 197                         NV_DEBUG(dev, "vid bit %d has no gpio tag\n", i);
 198                         return;
 199                 }
 200
 201                 vidmask >>= 1;
 202                 i++;
 203         }
 204
 205         /* parse vbios entries into common format */
 206         voltage->version = volt[0];
 207         if (voltage->version < 0x40) {
 208                 voltage->nr_level = entries;
 209                 voltage->level =
 210                         kcalloc(entries, sizeof(*voltage->level), GFP_KERNEL);
 211                 if (!voltage->level)
 212                         return;
 213
 214                 entry = volt + headerlen;
 215                 for (i = 0; i < entries; i++, entry += recordlen) {
 216                         voltage->level[i].voltage = entry[0] * 10000;
 217                         voltage->level[i].vid     = entry[1] >> vidshift;
 218                 }
 219         } else {
 220                 u32 volt_uv = ROM32(volt[4]);
 221                 s16 step_uv = ROM16(volt[8]);
 222                 u8 vid;
 223
 224                 voltage->nr_level = voltage->vid_mask + 1;
 225                 voltage->level = kcalloc(voltage->nr_level,
 226                                          sizeof(*voltage->level), GFP_KERNEL);
 227                 if (!voltage->level)
 228                         return;
 229
 230                 for (vid = 0; vid <= voltage->vid_mask; vid++) {
 231                         voltage->level[vid].voltage = volt_uv;
 232                         voltage->level[vid].vid = vid;
 233                         volt_uv += step_uv;
 234                 }
 235         }
 236
 237         voltage->supported = true;
 238 }
 239
 240 void
 241 nouveau_volt_fini(struct drm_device *dev)
 242 {
 243         struct drm_nouveau_private *dev_priv = dev->dev_private;
 244         struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
 245
 246         kfree(volt->level);
 247 }