Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 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 | #include "nouveau_drv.h" |
Ben Skeggs | aee582d | 2010-09-27 10:13:23 +1000 | [diff] [blame] | 27 | #include "nouveau_bios.h" |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 28 | #include "nouveau_pm.h" |
| 29 | |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 30 | struct nv50_pm_state { |
Ben Skeggs | aee582d | 2010-09-27 10:13:23 +1000 | [diff] [blame] | 31 | struct nouveau_pm_level *perflvl; |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 32 | struct pll_lims pll; |
| 33 | enum pll_types type; |
| 34 | int N, M, P; |
| 35 | }; |
| 36 | |
| 37 | int |
| 38 | nv50_pm_clock_get(struct drm_device *dev, u32 id) |
| 39 | { |
| 40 | struct pll_lims pll; |
| 41 | int P, N, M, ret; |
| 42 | u32 reg0, reg1; |
| 43 | |
| 44 | ret = get_pll_limits(dev, id, &pll); |
| 45 | if (ret) |
| 46 | return ret; |
| 47 | |
Ben Skeggs | fade7ad | 2010-09-27 11:18:14 +1000 | [diff] [blame] | 48 | reg0 = nv_rd32(dev, pll.reg + 0); |
| 49 | reg1 = nv_rd32(dev, pll.reg + 4); |
Emil Velikov | 619d4f7 | 2011-04-11 20:43:23 +0100 | [diff] [blame] | 50 | |
| 51 | if ((reg0 & 0x80000000) == 0) { |
| 52 | if (id == PLL_SHADER) { |
| 53 | NV_DEBUG(dev, "Shader PLL is disabled. " |
| 54 | "Shader clock is twice the core\n"); |
| 55 | ret = nv50_pm_clock_get(dev, PLL_CORE); |
| 56 | if (ret > 0) |
| 57 | return ret << 1; |
| 58 | } else if (id == PLL_MEMORY) { |
| 59 | NV_DEBUG(dev, "Memory PLL is disabled. " |
| 60 | "Memory clock is equal to the ref_clk\n"); |
| 61 | return pll.refclk; |
| 62 | } |
| 63 | } |
| 64 | |
Ben Skeggs | fade7ad | 2010-09-27 11:18:14 +1000 | [diff] [blame] | 65 | P = (reg0 & 0x00070000) >> 16; |
| 66 | N = (reg1 & 0x0000ff00) >> 8; |
| 67 | M = (reg1 & 0x000000ff); |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 68 | |
Ben Skeggs | fade7ad | 2010-09-27 11:18:14 +1000 | [diff] [blame] | 69 | return ((pll.refclk * N / M) >> P); |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 70 | } |
| 71 | |
| 72 | void * |
Ben Skeggs | 5c6dc65 | 2010-09-27 09:47:56 +1000 | [diff] [blame] | 73 | nv50_pm_clock_pre(struct drm_device *dev, struct nouveau_pm_level *perflvl, |
| 74 | u32 id, int khz) |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 75 | { |
| 76 | struct nv50_pm_state *state; |
| 77 | int dummy, ret; |
| 78 | |
| 79 | state = kzalloc(sizeof(*state), GFP_KERNEL); |
| 80 | if (!state) |
| 81 | return ERR_PTR(-ENOMEM); |
| 82 | state->type = id; |
Ben Skeggs | aee582d | 2010-09-27 10:13:23 +1000 | [diff] [blame] | 83 | state->perflvl = perflvl; |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 84 | |
| 85 | ret = get_pll_limits(dev, id, &state->pll); |
| 86 | if (ret < 0) { |
| 87 | kfree(state); |
Ben Skeggs | 6f87698 | 2010-09-16 16:47:14 +1000 | [diff] [blame] | 88 | return (ret == -ENOENT) ? NULL : ERR_PTR(ret); |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 89 | } |
| 90 | |
| 91 | ret = nv50_calc_pll(dev, &state->pll, khz, &state->N, &state->M, |
| 92 | &dummy, &dummy, &state->P); |
| 93 | if (ret < 0) { |
| 94 | kfree(state); |
| 95 | return ERR_PTR(ret); |
| 96 | } |
| 97 | |
| 98 | return state; |
| 99 | } |
| 100 | |
| 101 | void |
| 102 | nv50_pm_clock_set(struct drm_device *dev, void *pre_state) |
| 103 | { |
| 104 | struct nv50_pm_state *state = pre_state; |
Ben Skeggs | aee582d | 2010-09-27 10:13:23 +1000 | [diff] [blame] | 105 | struct nouveau_pm_level *perflvl = state->perflvl; |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 106 | u32 reg = state->pll.reg, tmp; |
Ben Skeggs | aee582d | 2010-09-27 10:13:23 +1000 | [diff] [blame] | 107 | struct bit_entry BIT_M; |
| 108 | u16 script; |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 109 | int N = state->N; |
| 110 | int M = state->M; |
| 111 | int P = state->P; |
| 112 | |
Ben Skeggs | aee582d | 2010-09-27 10:13:23 +1000 | [diff] [blame] | 113 | if (state->type == PLL_MEMORY && perflvl->memscript && |
| 114 | bit_table(dev, 'M', &BIT_M) == 0 && |
| 115 | BIT_M.version == 1 && BIT_M.length >= 0x0b) { |
| 116 | script = ROM16(BIT_M.data[0x05]); |
| 117 | if (script) |
Ben Skeggs | 02e4f58 | 2011-07-06 21:21:42 +1000 | [diff] [blame] | 118 | nouveau_bios_run_init_table(dev, script, NULL, -1); |
Ben Skeggs | aee582d | 2010-09-27 10:13:23 +1000 | [diff] [blame] | 119 | script = ROM16(BIT_M.data[0x07]); |
| 120 | if (script) |
Ben Skeggs | 02e4f58 | 2011-07-06 21:21:42 +1000 | [diff] [blame] | 121 | nouveau_bios_run_init_table(dev, script, NULL, -1); |
Ben Skeggs | aee582d | 2010-09-27 10:13:23 +1000 | [diff] [blame] | 122 | script = ROM16(BIT_M.data[0x09]); |
| 123 | if (script) |
Ben Skeggs | 02e4f58 | 2011-07-06 21:21:42 +1000 | [diff] [blame] | 124 | nouveau_bios_run_init_table(dev, script, NULL, -1); |
Ben Skeggs | aee582d | 2010-09-27 10:13:23 +1000 | [diff] [blame] | 125 | |
Ben Skeggs | 02e4f58 | 2011-07-06 21:21:42 +1000 | [diff] [blame] | 126 | nouveau_bios_run_init_table(dev, perflvl->memscript, NULL, -1); |
Ben Skeggs | aee582d | 2010-09-27 10:13:23 +1000 | [diff] [blame] | 127 | } |
| 128 | |
Ben Skeggs | fade7ad | 2010-09-27 11:18:14 +1000 | [diff] [blame] | 129 | if (state->type == PLL_MEMORY) { |
| 130 | nv_wr32(dev, 0x100210, 0); |
| 131 | nv_wr32(dev, 0x1002dc, 1); |
| 132 | } |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 133 | |
Ben Skeggs | fade7ad | 2010-09-27 11:18:14 +1000 | [diff] [blame] | 134 | tmp = nv_rd32(dev, reg + 0) & 0xfff8ffff; |
| 135 | tmp |= 0x80000000 | (P << 16); |
| 136 | nv_wr32(dev, reg + 0, tmp); |
| 137 | nv_wr32(dev, reg + 4, (N << 8) | M); |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 138 | |
Ben Skeggs | fade7ad | 2010-09-27 11:18:14 +1000 | [diff] [blame] | 139 | if (state->type == PLL_MEMORY) { |
| 140 | nv_wr32(dev, 0x1002dc, 0); |
| 141 | nv_wr32(dev, 0x100210, 0x80000000); |
Ben Skeggs | 02c30ca | 2010-09-16 16:17:35 +1000 | [diff] [blame] | 142 | } |
| 143 | |
| 144 | kfree(state); |
| 145 | } |
| 146 | |
Ben Skeggs | cb9fa62 | 2011-08-14 12:43:47 +1000 | [diff] [blame] | 147 | struct pwm_info { |
| 148 | int id; |
| 149 | int invert; |
| 150 | u8 tag; |
| 151 | u32 ctrl; |
| 152 | int line; |
| 153 | }; |
| 154 | |
| 155 | static int |
| 156 | nv50_pm_fanspeed_pwm(struct drm_device *dev, struct pwm_info *pwm) |
| 157 | { |
| 158 | struct dcb_gpio_entry *gpio; |
| 159 | |
| 160 | gpio = nouveau_bios_gpio_entry(dev, 0x09); |
| 161 | if (gpio) { |
| 162 | pwm->tag = gpio->tag; |
| 163 | pwm->id = (gpio->line == 9) ? 1 : 0; |
| 164 | pwm->invert = gpio->state[0] & 1; |
| 165 | pwm->ctrl = (gpio->line < 16) ? 0xe100 : 0xe28c; |
| 166 | pwm->line = (gpio->line & 0xf); |
| 167 | return 0; |
| 168 | } |
| 169 | |
| 170 | return -ENOENT; |
| 171 | } |
| 172 | |
| 173 | int |
| 174 | nv50_pm_fanspeed_get(struct drm_device *dev) |
| 175 | { |
| 176 | struct drm_nouveau_private *dev_priv = dev->dev_private; |
| 177 | struct nouveau_gpio_engine *pgpio = &dev_priv->engine.gpio; |
| 178 | struct pwm_info pwm; |
| 179 | int ret; |
| 180 | |
| 181 | ret = nv50_pm_fanspeed_pwm(dev, &pwm); |
| 182 | if (ret) |
| 183 | return ret; |
| 184 | |
| 185 | if (nv_rd32(dev, pwm.ctrl) & (0x00000001 << pwm.line)) { |
| 186 | u32 divs = nv_rd32(dev, 0x00e114 + (pwm.id * 8)); |
| 187 | u32 duty = nv_rd32(dev, 0x00e118 + (pwm.id * 8)); |
| 188 | if (divs) { |
| 189 | divs = max(divs, duty); |
| 190 | if (pwm.invert) |
| 191 | duty = divs - duty; |
| 192 | return (duty * 100) / divs; |
| 193 | } |
| 194 | |
| 195 | return 0; |
| 196 | } |
| 197 | |
| 198 | return pgpio->get(dev, pwm.tag) * 100; |
| 199 | } |
| 200 | |
| 201 | int |
| 202 | nv50_pm_fanspeed_set(struct drm_device *dev, int percent) |
| 203 | { |
Ben Skeggs | 3f8e11e | 2011-08-15 16:13:34 +1000 | [diff] [blame^] | 204 | struct drm_nouveau_private *dev_priv = dev->dev_private; |
| 205 | struct nouveau_pm_engine *pm = &dev_priv->engine.pm; |
Ben Skeggs | cb9fa62 | 2011-08-14 12:43:47 +1000 | [diff] [blame] | 206 | struct pwm_info pwm; |
| 207 | u32 divs, duty; |
| 208 | int ret; |
| 209 | |
| 210 | ret = nv50_pm_fanspeed_pwm(dev, &pwm); |
| 211 | if (ret) |
| 212 | return ret; |
| 213 | |
Ben Skeggs | 3f8e11e | 2011-08-15 16:13:34 +1000 | [diff] [blame^] | 214 | divs = pm->pwm_divisor; |
| 215 | if (pm->fan.pwm_freq) { |
| 216 | /*XXX: PNVIO clock more than likely... */ |
| 217 | divs = 1350000 / pm->fan.pwm_freq; |
| 218 | if (dev_priv->chipset < 0xa3) |
| 219 | divs /= 4; |
| 220 | } |
| 221 | |
Ben Skeggs | cb9fa62 | 2011-08-14 12:43:47 +1000 | [diff] [blame] | 222 | duty = ((divs * percent) + 99) / 100; |
| 223 | if (pwm.invert) |
| 224 | duty = divs - duty; |
| 225 | |
| 226 | nv_mask(dev, pwm.ctrl, 0x00010001 << pwm.line, 0x00000001 << pwm.line); |
Ben Skeggs | 3f8e11e | 2011-08-15 16:13:34 +1000 | [diff] [blame^] | 227 | nv_wr32(dev, 0x00e114 + (pwm.id * 8), divs); |
Ben Skeggs | cb9fa62 | 2011-08-14 12:43:47 +1000 | [diff] [blame] | 228 | nv_wr32(dev, 0x00e118 + (pwm.id * 8), 0x80000000 | duty); |
| 229 | return 0; |
| 230 | } |