1/* 2 * Copyright 2008 Advanced Micro Devices, Inc. 3 * Copyright 2008 Red Hat Inc. 4 * Copyright 2009 Jerome Glisse. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 * OTHER DEALINGS IN THE SOFTWARE. 23 * 24 * Authors: Dave Airlie 25 * Alex Deucher 26 * Jerome Glisse 27 */ 28#include <drm/drmP.h> 29#include <drm/drm_crtc_helper.h> 30#include <drm/radeon_drm.h> 31#include "radeon_reg.h" 32#include "radeon.h" 33#include "atom.h" 34 35#include <linux/pm_runtime.h> 36 37#define RADEON_WAIT_IDLE_TIMEOUT 200 38 39/** 40 * radeon_driver_irq_handler_kms - irq handler for KMS 41 * 42 * @int irq, void *arg: args 43 * 44 * This is the irq handler for the radeon KMS driver (all asics). 45 * radeon_irq_process is a macro that points to the per-asic 46 * irq handler callback. 47 */ 48irqreturn_t radeon_driver_irq_handler_kms(int irq, void *arg) 49{ 50 struct drm_device *dev = (struct drm_device *) arg; 51 struct radeon_device *rdev = dev->dev_private; 52 irqreturn_t ret; 53 54 ret = radeon_irq_process(rdev); 55 if (ret == IRQ_HANDLED) 56 pm_runtime_mark_last_busy(dev->dev); 57 return ret; 58} 59 60/* 61 * Handle hotplug events outside the interrupt handler proper. 62 */ 63/** 64 * radeon_hotplug_work_func - display hotplug work handler 65 * 66 * @work: work struct 67 * 68 * This is the hot plug event work handler (all asics). 69 * The work gets scheduled from the irq handler if there 70 * was a hot plug interrupt. It walks the connector table 71 * and calls the hotplug handler for each one, then sends 72 * a drm hotplug event to alert userspace. 73 */ 74static void radeon_hotplug_work_func(struct work_struct *work) 75{ 76 struct radeon_device *rdev = container_of(work, struct radeon_device, 77 hotplug_work); 78 struct drm_device *dev = rdev->ddev; 79 struct drm_mode_config *mode_config = &dev->mode_config; 80 struct drm_connector *connector; 81 82 mutex_lock(&mode_config->mutex); 83 if (mode_config->num_connector) { 84 list_for_each_entry(connector, &mode_config->connector_list, head) 85 radeon_connector_hotplug(connector); 86 } 87 mutex_unlock(&mode_config->mutex); 88 /* Just fire off a uevent and let userspace tell us what to do */ 89 drm_helper_hpd_irq_event(dev); 90} 91 92static void radeon_dp_work_func(struct work_struct *work) 93{ 94 struct radeon_device *rdev = container_of(work, struct radeon_device, 95 dp_work); 96 struct drm_device *dev = rdev->ddev; 97 struct drm_mode_config *mode_config = &dev->mode_config; 98 struct drm_connector *connector; 99 100 /* this should take a mutex */ 101 if (mode_config->num_connector) { 102 list_for_each_entry(connector, &mode_config->connector_list, head) 103 radeon_connector_hotplug(connector); 104 } 105} 106/** 107 * radeon_driver_irq_preinstall_kms - drm irq preinstall callback 108 * 109 * @dev: drm dev pointer 110 * 111 * Gets the hw ready to enable irqs (all asics). 112 * This function disables all interrupt sources on the GPU. 113 */ 114void radeon_driver_irq_preinstall_kms(struct drm_device *dev) 115{ 116 struct radeon_device *rdev = dev->dev_private; 117 unsigned long irqflags; 118 unsigned i; 119 120 spin_lock_irqsave(&rdev->irq.lock, irqflags); 121 /* Disable *all* interrupts */ 122 for (i = 0; i < RADEON_NUM_RINGS; i++) 123 atomic_set(&rdev->irq.ring_int[i], 0); 124 rdev->irq.dpm_thermal = false; 125 for (i = 0; i < RADEON_MAX_HPD_PINS; i++) 126 rdev->irq.hpd[i] = false; 127 for (i = 0; i < RADEON_MAX_CRTCS; i++) { 128 rdev->irq.crtc_vblank_int[i] = false; 129 atomic_set(&rdev->irq.pflip[i], 0); 130 rdev->irq.afmt[i] = false; 131 } 132 radeon_irq_set(rdev); 133 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 134 /* Clear bits */ 135 radeon_irq_process(rdev); 136} 137 138/** 139 * radeon_driver_irq_postinstall_kms - drm irq preinstall callback 140 * 141 * @dev: drm dev pointer 142 * 143 * Handles stuff to be done after enabling irqs (all asics). 144 * Returns 0 on success. 145 */ 146int radeon_driver_irq_postinstall_kms(struct drm_device *dev) 147{ 148 dev->max_vblank_count = 0x001fffff; 149 return 0; 150} 151 152/** 153 * radeon_driver_irq_uninstall_kms - drm irq uninstall callback 154 * 155 * @dev: drm dev pointer 156 * 157 * This function disables all interrupt sources on the GPU (all asics). 158 */ 159void radeon_driver_irq_uninstall_kms(struct drm_device *dev) 160{ 161 struct radeon_device *rdev = dev->dev_private; 162 unsigned long irqflags; 163 unsigned i; 164 165 if (rdev == NULL) { 166 return; 167 } 168 spin_lock_irqsave(&rdev->irq.lock, irqflags); 169 /* Disable *all* interrupts */ 170 for (i = 0; i < RADEON_NUM_RINGS; i++) 171 atomic_set(&rdev->irq.ring_int[i], 0); 172 rdev->irq.dpm_thermal = false; 173 for (i = 0; i < RADEON_MAX_HPD_PINS; i++) 174 rdev->irq.hpd[i] = false; 175 for (i = 0; i < RADEON_MAX_CRTCS; i++) { 176 rdev->irq.crtc_vblank_int[i] = false; 177 atomic_set(&rdev->irq.pflip[i], 0); 178 rdev->irq.afmt[i] = false; 179 } 180 radeon_irq_set(rdev); 181 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 182} 183 184/** 185 * radeon_msi_ok - asic specific msi checks 186 * 187 * @rdev: radeon device pointer 188 * 189 * Handles asic specific MSI checks to determine if 190 * MSIs should be enabled on a particular chip (all asics). 191 * Returns true if MSIs should be enabled, false if MSIs 192 * should not be enabled. 193 */ 194static bool radeon_msi_ok(struct radeon_device *rdev) 195{ 196 /* RV370/RV380 was first asic with MSI support */ 197 if (rdev->family < CHIP_RV380) 198 return false; 199 200 /* MSIs don't work on AGP */ 201 if (rdev->flags & RADEON_IS_AGP) 202 return false; 203 204 /* 205 * Older chips have a HW limitation, they can only generate 40 bits 206 * of address for "64-bit" MSIs which breaks on some platforms, notably 207 * IBM POWER servers, so we limit them 208 */ 209 if (rdev->family < CHIP_BONAIRE) { 210 dev_info(rdev->dev, "radeon: MSI limited to 32-bit\n"); 211 rdev->pdev->no_64bit_msi = 1; 212 } 213 214 /* force MSI on */ 215 if (radeon_msi == 1) 216 return true; 217 else if (radeon_msi == 0) 218 return false; 219 220 /* Quirks */ 221 /* HP RS690 only seems to work with MSIs. */ 222 if ((rdev->pdev->device == 0x791f) && 223 (rdev->pdev->subsystem_vendor == 0x103c) && 224 (rdev->pdev->subsystem_device == 0x30c2)) 225 return true; 226 227 /* Dell RS690 only seems to work with MSIs. */ 228 if ((rdev->pdev->device == 0x791f) && 229 (rdev->pdev->subsystem_vendor == 0x1028) && 230 (rdev->pdev->subsystem_device == 0x01fc)) 231 return true; 232 233 /* Dell RS690 only seems to work with MSIs. */ 234 if ((rdev->pdev->device == 0x791f) && 235 (rdev->pdev->subsystem_vendor == 0x1028) && 236 (rdev->pdev->subsystem_device == 0x01fd)) 237 return true; 238 239 /* Gateway RS690 only seems to work with MSIs. */ 240 if ((rdev->pdev->device == 0x791f) && 241 (rdev->pdev->subsystem_vendor == 0x107b) && 242 (rdev->pdev->subsystem_device == 0x0185)) 243 return true; 244 245 /* try and enable MSIs by default on all RS690s */ 246 if (rdev->family == CHIP_RS690) 247 return true; 248 249 /* RV515 seems to have MSI issues where it loses 250 * MSI rearms occasionally. This leads to lockups and freezes. 251 * disable it by default. 252 */ 253 if (rdev->family == CHIP_RV515) 254 return false; 255 if (rdev->flags & RADEON_IS_IGP) { 256 /* APUs work fine with MSIs */ 257 if (rdev->family >= CHIP_PALM) 258 return true; 259 /* lots of IGPs have problems with MSIs */ 260 return false; 261 } 262 263 return true; 264} 265 266/** 267 * radeon_irq_kms_init - init driver interrupt info 268 * 269 * @rdev: radeon device pointer 270 * 271 * Sets up the work irq handlers, vblank init, MSIs, etc. (all asics). 272 * Returns 0 for success, error for failure. 273 */ 274int radeon_irq_kms_init(struct radeon_device *rdev) 275{ 276 int r = 0; 277 278 spin_lock_init(&rdev->irq.lock); 279 r = drm_vblank_init(rdev->ddev, rdev->num_crtc); 280 if (r) { 281 return r; 282 } 283 /* enable msi */ 284 rdev->msi_enabled = 0; 285 286 if (radeon_msi_ok(rdev)) { 287 int ret = pci_enable_msi(rdev->pdev); 288 if (!ret) { 289 rdev->msi_enabled = 1; 290 dev_info(rdev->dev, "radeon: using MSI.\n"); 291 } 292 } 293 294 INIT_WORK(&rdev->hotplug_work, radeon_hotplug_work_func); 295 INIT_WORK(&rdev->dp_work, radeon_dp_work_func); 296 INIT_WORK(&rdev->audio_work, r600_audio_update_hdmi); 297 298 rdev->irq.installed = true; 299 r = drm_irq_install(rdev->ddev, rdev->ddev->pdev->irq); 300 if (r) { 301 rdev->irq.installed = false; 302 flush_work(&rdev->hotplug_work); 303 return r; 304 } 305 306 DRM_INFO("radeon: irq initialized.\n"); 307 return 0; 308} 309 310/** 311 * radeon_irq_kms_fini - tear down driver interrupt info 312 * 313 * @rdev: radeon device pointer 314 * 315 * Tears down the work irq handlers, vblank handlers, MSIs, etc. (all asics). 316 */ 317void radeon_irq_kms_fini(struct radeon_device *rdev) 318{ 319 drm_vblank_cleanup(rdev->ddev); 320 if (rdev->irq.installed) { 321 drm_irq_uninstall(rdev->ddev); 322 rdev->irq.installed = false; 323 if (rdev->msi_enabled) 324 pci_disable_msi(rdev->pdev); 325 flush_work(&rdev->hotplug_work); 326 } 327} 328 329/** 330 * radeon_irq_kms_sw_irq_get - enable software interrupt 331 * 332 * @rdev: radeon device pointer 333 * @ring: ring whose interrupt you want to enable 334 * 335 * Enables the software interrupt for a specific ring (all asics). 336 * The software interrupt is generally used to signal a fence on 337 * a particular ring. 338 */ 339void radeon_irq_kms_sw_irq_get(struct radeon_device *rdev, int ring) 340{ 341 unsigned long irqflags; 342 343 if (!rdev->ddev->irq_enabled) 344 return; 345 346 if (atomic_inc_return(&rdev->irq.ring_int[ring]) == 1) { 347 spin_lock_irqsave(&rdev->irq.lock, irqflags); 348 radeon_irq_set(rdev); 349 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 350 } 351} 352 353/** 354 * radeon_irq_kms_sw_irq_get_delayed - enable software interrupt 355 * 356 * @rdev: radeon device pointer 357 * @ring: ring whose interrupt you want to enable 358 * 359 * Enables the software interrupt for a specific ring (all asics). 360 * The software interrupt is generally used to signal a fence on 361 * a particular ring. 362 */ 363bool radeon_irq_kms_sw_irq_get_delayed(struct radeon_device *rdev, int ring) 364{ 365 return atomic_inc_return(&rdev->irq.ring_int[ring]) == 1; 366} 367 368/** 369 * radeon_irq_kms_sw_irq_put - disable software interrupt 370 * 371 * @rdev: radeon device pointer 372 * @ring: ring whose interrupt you want to disable 373 * 374 * Disables the software interrupt for a specific ring (all asics). 375 * The software interrupt is generally used to signal a fence on 376 * a particular ring. 377 */ 378void radeon_irq_kms_sw_irq_put(struct radeon_device *rdev, int ring) 379{ 380 unsigned long irqflags; 381 382 if (!rdev->ddev->irq_enabled) 383 return; 384 385 if (atomic_dec_and_test(&rdev->irq.ring_int[ring])) { 386 spin_lock_irqsave(&rdev->irq.lock, irqflags); 387 radeon_irq_set(rdev); 388 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 389 } 390} 391 392/** 393 * radeon_irq_kms_pflip_irq_get - enable pageflip interrupt 394 * 395 * @rdev: radeon device pointer 396 * @crtc: crtc whose interrupt you want to enable 397 * 398 * Enables the pageflip interrupt for a specific crtc (all asics). 399 * For pageflips we use the vblank interrupt source. 400 */ 401void radeon_irq_kms_pflip_irq_get(struct radeon_device *rdev, int crtc) 402{ 403 unsigned long irqflags; 404 405 if (crtc < 0 || crtc >= rdev->num_crtc) 406 return; 407 408 if (!rdev->ddev->irq_enabled) 409 return; 410 411 if (atomic_inc_return(&rdev->irq.pflip[crtc]) == 1) { 412 spin_lock_irqsave(&rdev->irq.lock, irqflags); 413 radeon_irq_set(rdev); 414 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 415 } 416} 417 418/** 419 * radeon_irq_kms_pflip_irq_put - disable pageflip interrupt 420 * 421 * @rdev: radeon device pointer 422 * @crtc: crtc whose interrupt you want to disable 423 * 424 * Disables the pageflip interrupt for a specific crtc (all asics). 425 * For pageflips we use the vblank interrupt source. 426 */ 427void radeon_irq_kms_pflip_irq_put(struct radeon_device *rdev, int crtc) 428{ 429 unsigned long irqflags; 430 431 if (crtc < 0 || crtc >= rdev->num_crtc) 432 return; 433 434 if (!rdev->ddev->irq_enabled) 435 return; 436 437 if (atomic_dec_and_test(&rdev->irq.pflip[crtc])) { 438 spin_lock_irqsave(&rdev->irq.lock, irqflags); 439 radeon_irq_set(rdev); 440 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 441 } 442} 443 444/** 445 * radeon_irq_kms_enable_afmt - enable audio format change interrupt 446 * 447 * @rdev: radeon device pointer 448 * @block: afmt block whose interrupt you want to enable 449 * 450 * Enables the afmt change interrupt for a specific afmt block (all asics). 451 */ 452void radeon_irq_kms_enable_afmt(struct radeon_device *rdev, int block) 453{ 454 unsigned long irqflags; 455 456 if (!rdev->ddev->irq_enabled) 457 return; 458 459 spin_lock_irqsave(&rdev->irq.lock, irqflags); 460 rdev->irq.afmt[block] = true; 461 radeon_irq_set(rdev); 462 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 463 464} 465 466/** 467 * radeon_irq_kms_disable_afmt - disable audio format change interrupt 468 * 469 * @rdev: radeon device pointer 470 * @block: afmt block whose interrupt you want to disable 471 * 472 * Disables the afmt change interrupt for a specific afmt block (all asics). 473 */ 474void radeon_irq_kms_disable_afmt(struct radeon_device *rdev, int block) 475{ 476 unsigned long irqflags; 477 478 if (!rdev->ddev->irq_enabled) 479 return; 480 481 spin_lock_irqsave(&rdev->irq.lock, irqflags); 482 rdev->irq.afmt[block] = false; 483 radeon_irq_set(rdev); 484 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 485} 486 487/** 488 * radeon_irq_kms_enable_hpd - enable hotplug detect interrupt 489 * 490 * @rdev: radeon device pointer 491 * @hpd_mask: mask of hpd pins you want to enable. 492 * 493 * Enables the hotplug detect interrupt for a specific hpd pin (all asics). 494 */ 495void radeon_irq_kms_enable_hpd(struct radeon_device *rdev, unsigned hpd_mask) 496{ 497 unsigned long irqflags; 498 int i; 499 500 if (!rdev->ddev->irq_enabled) 501 return; 502 503 spin_lock_irqsave(&rdev->irq.lock, irqflags); 504 for (i = 0; i < RADEON_MAX_HPD_PINS; ++i) 505 rdev->irq.hpd[i] |= !!(hpd_mask & (1 << i)); 506 radeon_irq_set(rdev); 507 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 508} 509 510/** 511 * radeon_irq_kms_disable_hpd - disable hotplug detect interrupt 512 * 513 * @rdev: radeon device pointer 514 * @hpd_mask: mask of hpd pins you want to disable. 515 * 516 * Disables the hotplug detect interrupt for a specific hpd pin (all asics). 517 */ 518void radeon_irq_kms_disable_hpd(struct radeon_device *rdev, unsigned hpd_mask) 519{ 520 unsigned long irqflags; 521 int i; 522 523 if (!rdev->ddev->irq_enabled) 524 return; 525 526 spin_lock_irqsave(&rdev->irq.lock, irqflags); 527 for (i = 0; i < RADEON_MAX_HPD_PINS; ++i) 528 rdev->irq.hpd[i] &= !(hpd_mask & (1 << i)); 529 radeon_irq_set(rdev); 530 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 531} 532 533