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