[deliverable/linux.git] / drivers / gpu / drm / nouveau / nouveau_volt.c

/*
 * Copyright 2010 Red Hat Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: Ben Skeggs
 */

#include "drmP.h"

#include "nouveau_drv.h"
#include "nouveau_pm.h"

static const enum dcb_gpio_tag vidtag[] = { 0x04, 0x05, 0x06, 0x1a };
static int nr_vidtag = sizeof(vidtag) / sizeof(vidtag[0]);

int
nouveau_voltage_gpio_get(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_gpio_engine *gpio = &dev_priv->engine.gpio;
	struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
	u8 vid = 0;
	int i;

	for (i = 0; i < nr_vidtag; i++) {
		if (!(volt->vid_mask & (1 << i)))
			continue;

		vid |= gpio->get(dev, vidtag[i]) << i;
	}

	return nouveau_volt_lvl_lookup(dev, vid);
}

int
nouveau_voltage_gpio_set(struct drm_device *dev, int voltage)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_gpio_engine *gpio = &dev_priv->engine.gpio;
	struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
	int vid, i;

	vid = nouveau_volt_vid_lookup(dev, voltage);
	if (vid < 0)
		return vid;

	for (i = 0; i < nr_vidtag; i++) {
		if (!(volt->vid_mask & (1 << i)))
			continue;

		gpio->set(dev, vidtag[i], !!(vid & (1 << i)));
	}

	return 0;
}

int
nouveau_volt_vid_lookup(struct drm_device *dev, int voltage)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
	int i;

	for (i = 0; i < volt->nr_level; i++) {
		if (volt->level[i].voltage == voltage)
			return volt->level[i].vid;
	}

	return -ENOENT;
}

int
nouveau_volt_lvl_lookup(struct drm_device *dev, int vid)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;
	int i;

	for (i = 0; i < volt->nr_level; i++) {
		if (volt->level[i].vid == vid)
			return volt->level[i].voltage;
	}

	return -ENOENT;
}

void
nouveau_volt_init(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
	struct nouveau_pm_voltage *voltage = &pm->voltage;
	struct nvbios *bios = &dev_priv->vbios;
	struct bit_entry P;
	u8 *volt = NULL, *entry;
	int i, headerlen, recordlen, entries, vidmask, vidshift;

	if (bios->type == NVBIOS_BIT) {
		if (bit_table(dev, 'P', &P))
			return;

		if (P.version == 1)
			volt = ROMPTR(bios, P.data[16]);
		else
		if (P.version == 2)
			volt = ROMPTR(bios, P.data[12]);
		else {
			NV_WARN(dev, "unknown volt for BIT P %d\n", P.version);
		}
	} else {
		if (bios->data[bios->offset + 6] < 0x27) {
			NV_DEBUG(dev, "BMP version too old for voltage\n");
			return;
		}

		volt = ROMPTR(bios, bios->data[bios->offset + 0x98]);
	}

	if (!volt) {
		NV_DEBUG(dev, "voltage table pointer invalid\n");
		return;
	}

	switch (volt[0]) {
	case 0x10:
	case 0x11:
	case 0x12:
		headerlen = 5;
		recordlen = volt[1];
		entries   = volt[2];
		vidshift  = 0;
		vidmask   = volt[4];
		break;
	case 0x20:
		headerlen = volt[1];
		recordlen = volt[3];
		entries   = volt[2];
		vidshift  = 0; /* could be vidshift like 0x30? */
		vidmask   = volt[5];
		break;
	case 0x30:
		headerlen = volt[1];
		recordlen = volt[2];
		entries   = volt[3];
		vidmask   = volt[4];
		/* no longer certain what volt[5] is, if it's related to
		 * the vid shift then it's definitely not a function of
		 * how many bits are set.
		 *
		 * after looking at a number of nva3+ vbios images, they
		 * all seem likely to have a static shift of 2.. lets
		 * go with that for now until proven otherwise.
		 */
		vidshift  = 2;
		break;
	default:
		NV_WARN(dev, "voltage table 0x%02x unknown\n", volt[0]);
		return;
	}

	/* validate vid mask */
	voltage->vid_mask = vidmask;
	if (!voltage->vid_mask)
		return;

	i = 0;
	while (vidmask) {
		if (i > nr_vidtag) {
			NV_DEBUG(dev, "vid bit %d unknown\n", i);
			return;
		}

		if (!nouveau_bios_gpio_entry(dev, vidtag[i])) {
			NV_DEBUG(dev, "vid bit %d has no gpio tag\n", i);
			return;
		}

		vidmask >>= 1;
		i++;
	}

	/* parse vbios entries into common format */
	voltage->level = kcalloc(entries, sizeof(*voltage->level), GFP_KERNEL);
	if (!voltage->level)
		return;

	entry = volt + headerlen;
	for (i = 0; i < entries; i++, entry += recordlen) {
		voltage->level[i].voltage = entry[0];
		voltage->level[i].vid     = entry[1] >> vidshift;
	}
	voltage->nr_level  = entries;
	voltage->supported = true;
}

void
nouveau_volt_fini(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_pm_voltage *volt = &dev_priv->engine.pm.voltage;

	kfree(volt->level);
}
Commit	Line	Data
330c5988 BS	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
	30	static const enum dcb_gpio_tag vidtag[] = { 0x04, 0x05, 0x06, 0x1a };
	31	static int nr_vidtag = sizeof(vidtag) / sizeof(vidtag[0]);
	32
	33	int
	34	nouveau_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
	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_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
74	int
75	nouveau_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
89	int
90	nouveau_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
104	void
105	nouveau_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;
dc7339df	113	int i, headerlen, recordlen, entries, vidmask, vidshift;
330c5988 BS	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:
dc7339df BS	145	headerlen = 5;
dc7339df BS	146	recordlen = volt[1];
330c5988 BS	147	entries = volt[2];
	148	vidshift = 0;
	149	vidmask = volt[4];
	150	break;
	151	case 0x20:
dc7339df	152	headerlen = volt[1];
330c5988 BS	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:
dc7339df	159	headerlen = volt[1];
330c5988 BS	160	recordlen = volt[2];
330c5988 BS	161	entries = volt[3];
330c5988	162	vidmask = volt[4];
475feffa BS	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;
330c5988 BS	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
dc7339df	204	entry = volt + headerlen;
330c5988 BS	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
	213	void
	214	nouveau_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	}