1 /* 2 * Copyright (C) 2009 Red Hat <mjg@redhat.com> 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining 5 * a copy of this software and associated documentation files (the 6 * "Software"), to deal in the Software without restriction, including 7 * without limitation the rights to use, copy, modify, merge, publish, 8 * distribute, sublicense, and/or sell copies of the Software, and to 9 * permit persons to whom the Software is furnished to do so, subject to 10 * the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the 13 * next paragraph) shall be included in all copies or substantial 14 * portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE 20 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 21 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 22 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 * 24 */ 25 26 /* 27 * Authors: 28 * Matthew Garrett <mjg@redhat.com> 29 * 30 * Register locations derived from NVClock by Roderick Colenbrander 31 */ 32 33 #include <linux/backlight.h> 34 #include <linux/acpi.h> 35 36 #include "nouveau_drm.h" 37 #include "nouveau_reg.h" 38 #include "nouveau_encoder.h" 39 40 static int 41 nv40_get_intensity(struct backlight_device *bd) 42 { 43 struct nouveau_drm *drm = bl_get_data(bd); 44 struct nouveau_device *device = nv_device(drm->device); 45 int val = (nv_rd32(device, NV40_PMC_BACKLIGHT) & 46 NV40_PMC_BACKLIGHT_MASK) >> 16; 47 48 return val; 49 } 50 51 static int 52 nv40_set_intensity(struct backlight_device *bd) 53 { 54 struct nouveau_drm *drm = bl_get_data(bd); 55 struct nouveau_device *device = nv_device(drm->device); 56 int val = bd->props.brightness; 57 int reg = nv_rd32(device, NV40_PMC_BACKLIGHT); 58 59 nv_wr32(device, NV40_PMC_BACKLIGHT, 60 (val << 16) | (reg & ~NV40_PMC_BACKLIGHT_MASK)); 61 62 return 0; 63 } 64 65 static const struct backlight_ops nv40_bl_ops = { 66 .options = BL_CORE_SUSPENDRESUME, 67 .get_brightness = nv40_get_intensity, 68 .update_status = nv40_set_intensity, 69 }; 70 71 static int 72 nv40_backlight_init(struct drm_connector *connector) 73 { 74 struct nouveau_drm *drm = nouveau_drm(connector->dev); 75 struct nouveau_device *device = nv_device(drm->device); 76 struct backlight_properties props; 77 struct backlight_device *bd; 78 79 if (!(nv_rd32(device, NV40_PMC_BACKLIGHT) & NV40_PMC_BACKLIGHT_MASK)) 80 return 0; 81 82 memset(&props, 0, sizeof(struct backlight_properties)); 83 props.type = BACKLIGHT_RAW; 84 props.max_brightness = 31; 85 bd = backlight_device_register("nv_backlight", &connector->kdev, drm, 86 &nv40_bl_ops, &props); 87 drm->backlight = bd; 88 bd->props.brightness = nv40_get_intensity(bd); 89 backlight_update_status(bd); 90 91 return 0; 92 } 93 94 static int 95 nv50_get_intensity(struct backlight_device *bd) 96 { 97 struct nouveau_encoder *nv_encoder = bl_get_data(bd); 98 struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); 99 struct nouveau_device *device = nv_device(drm->device); 100 int or = nv_encoder->or; 101 u32 div = 1025; 102 u32 val; 103 104 val = nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(or)); 105 val &= NV50_PDISP_SOR_PWM_CTL_VAL; 106 return ((val * 100) + (div / 2)) / div; 107 } 108 109 static int 110 nv50_set_intensity(struct backlight_device *bd) 111 { 112 struct nouveau_encoder *nv_encoder = bl_get_data(bd); 113 struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); 114 struct nouveau_device *device = nv_device(drm->device); 115 int or = nv_encoder->or; 116 u32 div = 1025; 117 u32 val = (bd->props.brightness * div) / 100; 118 119 nv_wr32(device, NV50_PDISP_SOR_PWM_CTL(or), 120 NV50_PDISP_SOR_PWM_CTL_NEW | val); 121 return 0; 122 } 123 124 static const struct backlight_ops nv50_bl_ops = { 125 .options = BL_CORE_SUSPENDRESUME, 126 .get_brightness = nv50_get_intensity, 127 .update_status = nv50_set_intensity, 128 }; 129 130 static int 131 nva3_get_intensity(struct backlight_device *bd) 132 { 133 struct nouveau_encoder *nv_encoder = bl_get_data(bd); 134 struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); 135 struct nouveau_device *device = nv_device(drm->device); 136 int or = nv_encoder->or; 137 u32 div, val; 138 139 div = nv_rd32(device, NV50_PDISP_SOR_PWM_DIV(or)); 140 val = nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(or)); 141 val &= NVA3_PDISP_SOR_PWM_CTL_VAL; 142 if (div && div >= val) 143 return ((val * 100) + (div / 2)) / div; 144 145 return 100; 146 } 147 148 static int 149 nva3_set_intensity(struct backlight_device *bd) 150 { 151 struct nouveau_encoder *nv_encoder = bl_get_data(bd); 152 struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); 153 struct nouveau_device *device = nv_device(drm->device); 154 int or = nv_encoder->or; 155 u32 div, val; 156 157 div = nv_rd32(device, NV50_PDISP_SOR_PWM_DIV(or)); 158 val = (bd->props.brightness * div) / 100; 159 if (div) { 160 nv_wr32(device, NV50_PDISP_SOR_PWM_CTL(or), val | 161 NV50_PDISP_SOR_PWM_CTL_NEW | 162 NVA3_PDISP_SOR_PWM_CTL_UNK); 163 return 0; 164 } 165 166 return -EINVAL; 167 } 168 169 static const struct backlight_ops nva3_bl_ops = { 170 .options = BL_CORE_SUSPENDRESUME, 171 .get_brightness = nva3_get_intensity, 172 .update_status = nva3_set_intensity, 173 }; 174 175 static int 176 nv50_backlight_init(struct drm_connector *connector) 177 { 178 struct nouveau_drm *drm = nouveau_drm(connector->dev); 179 struct nouveau_device *device = nv_device(drm->device); 180 struct nouveau_encoder *nv_encoder; 181 struct backlight_properties props; 182 struct backlight_device *bd; 183 const struct backlight_ops *ops; 184 185 nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS); 186 if (!nv_encoder) { 187 nv_encoder = find_encoder(connector, DCB_OUTPUT_DP); 188 if (!nv_encoder) 189 return -ENODEV; 190 } 191 192 if (!nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(nv_encoder->or))) 193 return 0; 194 195 if (device->chipset <= 0xa0 || 196 device->chipset == 0xaa || 197 device->chipset == 0xac) 198 ops = &nv50_bl_ops; 199 else 200 ops = &nva3_bl_ops; 201 202 memset(&props, 0, sizeof(struct backlight_properties)); 203 props.type = BACKLIGHT_RAW; 204 props.max_brightness = 100; 205 bd = backlight_device_register("nv_backlight", &connector->kdev, 206 nv_encoder, ops, &props); 207 if (IS_ERR(bd)) 208 return PTR_ERR(bd); 209 210 drm->backlight = bd; 211 bd->props.brightness = bd->ops->get_brightness(bd); 212 backlight_update_status(bd); 213 return 0; 214 } 215 216 int 217 nouveau_backlight_init(struct drm_device *dev) 218 { 219 struct nouveau_drm *drm = nouveau_drm(dev); 220 struct nouveau_device *device = nv_device(drm->device); 221 struct drm_connector *connector; 222 223 #ifdef CONFIG_ACPI 224 if (acpi_video_backlight_support()) { 225 NV_INFO(drm, "ACPI backlight interface available, " 226 "not registering our own\n"); 227 return 0; 228 } 229 #endif 230 231 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 232 if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS && 233 connector->connector_type != DRM_MODE_CONNECTOR_eDP) 234 continue; 235 236 switch (device->card_type) { 237 case NV_40: 238 return nv40_backlight_init(connector); 239 case NV_50: 240 return nv50_backlight_init(connector); 241 default: 242 break; 243 } 244 } 245 246 247 return 0; 248 } 249 250 void 251 nouveau_backlight_exit(struct drm_device *dev) 252 { 253 struct nouveau_drm *drm = nouveau_drm(dev); 254 255 if (drm->backlight) { 256 backlight_device_unregister(drm->backlight); 257 drm->backlight = NULL; 258 } 259 } 260