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 */ 48 irqreturn_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 */ 74 static 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 92 static 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 */ 114 void 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 */ 146 int radeon_driver_irq_postinstall_kms(struct drm_device *dev) 147 { 148 struct radeon_device *rdev = dev->dev_private; 149 150 if (ASIC_IS_AVIVO(rdev)) 151 dev->max_vblank_count = 0x00ffffff; 152 else 153 dev->max_vblank_count = 0x001fffff; 154 155 return 0; 156 } 157 158 /** 159 * radeon_driver_irq_uninstall_kms - drm irq uninstall callback 160 * 161 * @dev: drm dev pointer 162 * 163 * This function disables all interrupt sources on the GPU (all asics). 164 */ 165 void radeon_driver_irq_uninstall_kms(struct drm_device *dev) 166 { 167 struct radeon_device *rdev = dev->dev_private; 168 unsigned long irqflags; 169 unsigned i; 170 171 if (rdev == NULL) { 172 return; 173 } 174 spin_lock_irqsave(&rdev->irq.lock, irqflags); 175 /* Disable *all* interrupts */ 176 for (i = 0; i < RADEON_NUM_RINGS; i++) 177 atomic_set(&rdev->irq.ring_int[i], 0); 178 rdev->irq.dpm_thermal = false; 179 for (i = 0; i < RADEON_MAX_HPD_PINS; i++) 180 rdev->irq.hpd[i] = false; 181 for (i = 0; i < RADEON_MAX_CRTCS; i++) { 182 rdev->irq.crtc_vblank_int[i] = false; 183 atomic_set(&rdev->irq.pflip[i], 0); 184 rdev->irq.afmt[i] = false; 185 } 186 radeon_irq_set(rdev); 187 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 188 } 189 190 /** 191 * radeon_msi_ok - asic specific msi checks 192 * 193 * @rdev: radeon device pointer 194 * 195 * Handles asic specific MSI checks to determine if 196 * MSIs should be enabled on a particular chip (all asics). 197 * Returns true if MSIs should be enabled, false if MSIs 198 * should not be enabled. 199 */ 200 static bool radeon_msi_ok(struct radeon_device *rdev) 201 { 202 /* RV370/RV380 was first asic with MSI support */ 203 if (rdev->family < CHIP_RV380) 204 return false; 205 206 /* MSIs don't work on AGP */ 207 if (rdev->flags & RADEON_IS_AGP) 208 return false; 209 210 /* 211 * Older chips have a HW limitation, they can only generate 40 bits 212 * of address for "64-bit" MSIs which breaks on some platforms, notably 213 * IBM POWER servers, so we limit them 214 */ 215 if (rdev->family < CHIP_BONAIRE) { 216 dev_info(rdev->dev, "radeon: MSI limited to 32-bit\n"); 217 rdev->pdev->no_64bit_msi = 1; 218 } 219 220 /* force MSI on */ 221 if (radeon_msi == 1) 222 return true; 223 else if (radeon_msi == 0) 224 return false; 225 226 /* Quirks */ 227 /* HP RS690 only seems to work with MSIs. */ 228 if ((rdev->pdev->device == 0x791f) && 229 (rdev->pdev->subsystem_vendor == 0x103c) && 230 (rdev->pdev->subsystem_device == 0x30c2)) 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 == 0x01fc)) 237 return true; 238 239 /* Dell RS690 only seems to work with MSIs. */ 240 if ((rdev->pdev->device == 0x791f) && 241 (rdev->pdev->subsystem_vendor == 0x1028) && 242 (rdev->pdev->subsystem_device == 0x01fd)) 243 return true; 244 245 /* Gateway RS690 only seems to work with MSIs. */ 246 if ((rdev->pdev->device == 0x791f) && 247 (rdev->pdev->subsystem_vendor == 0x107b) && 248 (rdev->pdev->subsystem_device == 0x0185)) 249 return true; 250 251 /* try and enable MSIs by default on all RS690s */ 252 if (rdev->family == CHIP_RS690) 253 return true; 254 255 /* RV515 seems to have MSI issues where it loses 256 * MSI rearms occasionally. This leads to lockups and freezes. 257 * disable it by default. 258 */ 259 if (rdev->family == CHIP_RV515) 260 return false; 261 if (rdev->flags & RADEON_IS_IGP) { 262 /* APUs work fine with MSIs */ 263 if (rdev->family >= CHIP_PALM) 264 return true; 265 /* lots of IGPs have problems with MSIs */ 266 return false; 267 } 268 269 return true; 270 } 271 272 /** 273 * radeon_irq_kms_init - init driver interrupt info 274 * 275 * @rdev: radeon device pointer 276 * 277 * Sets up the work irq handlers, vblank init, MSIs, etc. (all asics). 278 * Returns 0 for success, error for failure. 279 */ 280 int radeon_irq_kms_init(struct radeon_device *rdev) 281 { 282 int r = 0; 283 284 spin_lock_init(&rdev->irq.lock); 285 r = drm_vblank_init(rdev->ddev, rdev->num_crtc); 286 if (r) { 287 return r; 288 } 289 /* enable msi */ 290 rdev->msi_enabled = 0; 291 292 if (radeon_msi_ok(rdev)) { 293 int ret = pci_enable_msi(rdev->pdev); 294 if (!ret) { 295 rdev->msi_enabled = 1; 296 dev_info(rdev->dev, "radeon: using MSI.\n"); 297 } 298 } 299 300 INIT_WORK(&rdev->hotplug_work, radeon_hotplug_work_func); 301 INIT_WORK(&rdev->dp_work, radeon_dp_work_func); 302 INIT_WORK(&rdev->audio_work, r600_audio_update_hdmi); 303 304 rdev->irq.installed = true; 305 r = drm_irq_install(rdev->ddev, rdev->ddev->pdev->irq); 306 if (r) { 307 rdev->irq.installed = false; 308 flush_work(&rdev->hotplug_work); 309 return r; 310 } 311 312 DRM_INFO("radeon: irq initialized.\n"); 313 return 0; 314 } 315 316 /** 317 * radeon_irq_kms_fini - tear down driver interrupt info 318 * 319 * @rdev: radeon device pointer 320 * 321 * Tears down the work irq handlers, vblank handlers, MSIs, etc. (all asics). 322 */ 323 void radeon_irq_kms_fini(struct radeon_device *rdev) 324 { 325 drm_vblank_cleanup(rdev->ddev); 326 if (rdev->irq.installed) { 327 drm_irq_uninstall(rdev->ddev); 328 rdev->irq.installed = false; 329 if (rdev->msi_enabled) 330 pci_disable_msi(rdev->pdev); 331 flush_work(&rdev->hotplug_work); 332 } 333 } 334 335 /** 336 * radeon_irq_kms_sw_irq_get - enable software interrupt 337 * 338 * @rdev: radeon device pointer 339 * @ring: ring whose interrupt you want to enable 340 * 341 * Enables the software interrupt for a specific ring (all asics). 342 * The software interrupt is generally used to signal a fence on 343 * a particular ring. 344 */ 345 void radeon_irq_kms_sw_irq_get(struct radeon_device *rdev, int ring) 346 { 347 unsigned long irqflags; 348 349 if (!rdev->ddev->irq_enabled) 350 return; 351 352 if (atomic_inc_return(&rdev->irq.ring_int[ring]) == 1) { 353 spin_lock_irqsave(&rdev->irq.lock, irqflags); 354 radeon_irq_set(rdev); 355 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 356 } 357 } 358 359 /** 360 * radeon_irq_kms_sw_irq_get_delayed - enable software interrupt 361 * 362 * @rdev: radeon device pointer 363 * @ring: ring whose interrupt you want to enable 364 * 365 * Enables the software interrupt for a specific ring (all asics). 366 * The software interrupt is generally used to signal a fence on 367 * a particular ring. 368 */ 369 bool radeon_irq_kms_sw_irq_get_delayed(struct radeon_device *rdev, int ring) 370 { 371 return atomic_inc_return(&rdev->irq.ring_int[ring]) == 1; 372 } 373 374 /** 375 * radeon_irq_kms_sw_irq_put - disable software interrupt 376 * 377 * @rdev: radeon device pointer 378 * @ring: ring whose interrupt you want to disable 379 * 380 * Disables the software interrupt for a specific ring (all asics). 381 * The software interrupt is generally used to signal a fence on 382 * a particular ring. 383 */ 384 void radeon_irq_kms_sw_irq_put(struct radeon_device *rdev, int ring) 385 { 386 unsigned long irqflags; 387 388 if (!rdev->ddev->irq_enabled) 389 return; 390 391 if (atomic_dec_and_test(&rdev->irq.ring_int[ring])) { 392 spin_lock_irqsave(&rdev->irq.lock, irqflags); 393 radeon_irq_set(rdev); 394 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 395 } 396 } 397 398 /** 399 * radeon_irq_kms_pflip_irq_get - enable pageflip interrupt 400 * 401 * @rdev: radeon device pointer 402 * @crtc: crtc whose interrupt you want to enable 403 * 404 * Enables the pageflip interrupt for a specific crtc (all asics). 405 * For pageflips we use the vblank interrupt source. 406 */ 407 void radeon_irq_kms_pflip_irq_get(struct radeon_device *rdev, int crtc) 408 { 409 unsigned long irqflags; 410 411 if (crtc < 0 || crtc >= rdev->num_crtc) 412 return; 413 414 if (!rdev->ddev->irq_enabled) 415 return; 416 417 if (atomic_inc_return(&rdev->irq.pflip[crtc]) == 1) { 418 spin_lock_irqsave(&rdev->irq.lock, irqflags); 419 radeon_irq_set(rdev); 420 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 421 } 422 } 423 424 /** 425 * radeon_irq_kms_pflip_irq_put - disable pageflip interrupt 426 * 427 * @rdev: radeon device pointer 428 * @crtc: crtc whose interrupt you want to disable 429 * 430 * Disables the pageflip interrupt for a specific crtc (all asics). 431 * For pageflips we use the vblank interrupt source. 432 */ 433 void radeon_irq_kms_pflip_irq_put(struct radeon_device *rdev, int crtc) 434 { 435 unsigned long irqflags; 436 437 if (crtc < 0 || crtc >= rdev->num_crtc) 438 return; 439 440 if (!rdev->ddev->irq_enabled) 441 return; 442 443 if (atomic_dec_and_test(&rdev->irq.pflip[crtc])) { 444 spin_lock_irqsave(&rdev->irq.lock, irqflags); 445 radeon_irq_set(rdev); 446 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 447 } 448 } 449 450 /** 451 * radeon_irq_kms_enable_afmt - enable audio format change interrupt 452 * 453 * @rdev: radeon device pointer 454 * @block: afmt block whose interrupt you want to enable 455 * 456 * Enables the afmt change interrupt for a specific afmt block (all asics). 457 */ 458 void radeon_irq_kms_enable_afmt(struct radeon_device *rdev, int block) 459 { 460 unsigned long irqflags; 461 462 if (!rdev->ddev->irq_enabled) 463 return; 464 465 spin_lock_irqsave(&rdev->irq.lock, irqflags); 466 rdev->irq.afmt[block] = true; 467 radeon_irq_set(rdev); 468 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 469 470 } 471 472 /** 473 * radeon_irq_kms_disable_afmt - disable audio format change interrupt 474 * 475 * @rdev: radeon device pointer 476 * @block: afmt block whose interrupt you want to disable 477 * 478 * Disables the afmt change interrupt for a specific afmt block (all asics). 479 */ 480 void radeon_irq_kms_disable_afmt(struct radeon_device *rdev, int block) 481 { 482 unsigned long irqflags; 483 484 if (!rdev->ddev->irq_enabled) 485 return; 486 487 spin_lock_irqsave(&rdev->irq.lock, irqflags); 488 rdev->irq.afmt[block] = false; 489 radeon_irq_set(rdev); 490 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 491 } 492 493 /** 494 * radeon_irq_kms_enable_hpd - enable hotplug detect interrupt 495 * 496 * @rdev: radeon device pointer 497 * @hpd_mask: mask of hpd pins you want to enable. 498 * 499 * Enables the hotplug detect interrupt for a specific hpd pin (all asics). 500 */ 501 void radeon_irq_kms_enable_hpd(struct radeon_device *rdev, unsigned hpd_mask) 502 { 503 unsigned long irqflags; 504 int i; 505 506 if (!rdev->ddev->irq_enabled) 507 return; 508 509 spin_lock_irqsave(&rdev->irq.lock, irqflags); 510 for (i = 0; i < RADEON_MAX_HPD_PINS; ++i) 511 rdev->irq.hpd[i] |= !!(hpd_mask & (1 << i)); 512 radeon_irq_set(rdev); 513 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 514 } 515 516 /** 517 * radeon_irq_kms_disable_hpd - disable hotplug detect interrupt 518 * 519 * @rdev: radeon device pointer 520 * @hpd_mask: mask of hpd pins you want to disable. 521 * 522 * Disables the hotplug detect interrupt for a specific hpd pin (all asics). 523 */ 524 void radeon_irq_kms_disable_hpd(struct radeon_device *rdev, unsigned hpd_mask) 525 { 526 unsigned long irqflags; 527 int i; 528 529 if (!rdev->ddev->irq_enabled) 530 return; 531 532 spin_lock_irqsave(&rdev->irq.lock, irqflags); 533 for (i = 0; i < RADEON_MAX_HPD_PINS; ++i) 534 rdev->irq.hpd[i] &= !(hpd_mask & (1 << i)); 535 radeon_irq_set(rdev); 536 spin_unlock_irqrestore(&rdev->irq.lock, irqflags); 537 } 538 539