2009-06-05 19:42:42 +07:00
|
|
|
/*
|
|
|
|
* Copyright 2008 Advanced Micro Devices, Inc.
|
|
|
|
* Copyright 2008 Red Hat Inc.
|
|
|
|
* Copyright 2009 Jerome Glisse.
|
|
|
|
*
|
|
|
|
* 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: Dave Airlie
|
|
|
|
* Alex Deucher
|
|
|
|
* Jerome Glisse
|
|
|
|
*/
|
2019-06-08 15:02:40 +07:00
|
|
|
|
|
|
|
#include <linux/pm_runtime.h>
|
|
|
|
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/drm_crtc_helper.h>
|
2019-06-08 15:02:40 +07:00
|
|
|
#include <drm/drm_device.h>
|
|
|
|
#include <drm/drm_irq.h>
|
|
|
|
#include <drm/drm_pci.h>
|
2019-01-18 04:03:34 +07:00
|
|
|
#include <drm/drm_probe_helper.h>
|
2019-06-08 15:02:40 +07:00
|
|
|
#include <drm/drm_vblank.h>
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/radeon_drm.h>
|
2019-06-08 15:02:40 +07:00
|
|
|
|
2009-06-05 19:42:42 +07:00
|
|
|
#include "atom.h"
|
2019-06-08 15:02:40 +07:00
|
|
|
#include "radeon.h"
|
|
|
|
#include "radeon_reg.h"
|
2009-06-05 19:42:42 +07:00
|
|
|
|
2012-09-17 11:40:31 +07:00
|
|
|
|
2012-05-17 06:33:30 +07:00
|
|
|
#define RADEON_WAIT_IDLE_TIMEOUT 200
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_driver_irq_handler_kms - irq handler for KMS
|
|
|
|
*
|
2013-12-11 17:34:42 +07:00
|
|
|
* @int irq, void *arg: args
|
2012-07-18 01:02:35 +07:00
|
|
|
*
|
|
|
|
* This is the irq handler for the radeon KMS driver (all asics).
|
|
|
|
* radeon_irq_process is a macro that points to the per-asic
|
|
|
|
* irq handler callback.
|
|
|
|
*/
|
2013-12-11 17:34:42 +07:00
|
|
|
irqreturn_t radeon_driver_irq_handler_kms(int irq, void *arg)
|
2009-06-05 19:42:42 +07:00
|
|
|
{
|
|
|
|
struct drm_device *dev = (struct drm_device *) arg;
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2012-09-17 11:40:31 +07:00
|
|
|
irqreturn_t ret;
|
2009-06-05 19:42:42 +07:00
|
|
|
|
2012-09-17 11:40:31 +07:00
|
|
|
ret = radeon_irq_process(rdev);
|
|
|
|
if (ret == IRQ_HANDLED)
|
|
|
|
pm_runtime_mark_last_busy(dev->dev);
|
|
|
|
return ret;
|
2009-06-05 19:42:42 +07:00
|
|
|
}
|
|
|
|
|
2009-12-05 04:56:37 +07:00
|
|
|
/*
|
|
|
|
* Handle hotplug events outside the interrupt handler proper.
|
|
|
|
*/
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_hotplug_work_func - display hotplug work handler
|
|
|
|
*
|
|
|
|
* @work: work struct
|
|
|
|
*
|
|
|
|
* This is the hot plug event work handler (all asics).
|
|
|
|
* The work gets scheduled from the irq handler if there
|
|
|
|
* was a hot plug interrupt. It walks the connector table
|
|
|
|
* and calls the hotplug handler for each one, then sends
|
|
|
|
* a drm hotplug event to alert userspace.
|
|
|
|
*/
|
2009-12-05 04:56:37 +07:00
|
|
|
static void radeon_hotplug_work_func(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct radeon_device *rdev = container_of(work, struct radeon_device,
|
2015-12-04 06:26:07 +07:00
|
|
|
hotplug_work.work);
|
2009-12-05 04:56:37 +07:00
|
|
|
struct drm_device *dev = rdev->ddev;
|
|
|
|
struct drm_mode_config *mode_config = &dev->mode_config;
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
2015-08-20 07:13:55 +07:00
|
|
|
/* we can race here at startup, some boards seem to trigger
|
|
|
|
* hotplug irqs when they shouldn't. */
|
|
|
|
if (!rdev->mode_info.mode_config_initialized)
|
|
|
|
return;
|
|
|
|
|
2015-05-15 22:48:52 +07:00
|
|
|
mutex_lock(&mode_config->mutex);
|
2016-12-14 06:08:04 +07:00
|
|
|
list_for_each_entry(connector, &mode_config->connector_list, head)
|
|
|
|
radeon_connector_hotplug(connector);
|
2015-05-15 22:48:52 +07:00
|
|
|
mutex_unlock(&mode_config->mutex);
|
2009-12-05 04:56:37 +07:00
|
|
|
/* Just fire off a uevent and let userspace tell us what to do */
|
2010-05-07 13:42:51 +07:00
|
|
|
drm_helper_hpd_irq_event(dev);
|
2009-12-05 04:56:37 +07:00
|
|
|
}
|
|
|
|
|
2015-02-24 06:23:56 +07:00
|
|
|
static void radeon_dp_work_func(struct work_struct *work)
|
|
|
|
{
|
2015-02-24 06:24:04 +07:00
|
|
|
struct radeon_device *rdev = container_of(work, struct radeon_device,
|
|
|
|
dp_work);
|
|
|
|
struct drm_device *dev = rdev->ddev;
|
|
|
|
struct drm_mode_config *mode_config = &dev->mode_config;
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
|
|
|
/* this should take a mutex */
|
2016-12-14 06:08:04 +07:00
|
|
|
list_for_each_entry(connector, &mode_config->connector_list, head)
|
|
|
|
radeon_connector_hotplug(connector);
|
2015-02-24 06:23:56 +07:00
|
|
|
}
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_driver_irq_preinstall_kms - drm irq preinstall callback
|
|
|
|
*
|
|
|
|
* @dev: drm dev pointer
|
|
|
|
*
|
|
|
|
* Gets the hw ready to enable irqs (all asics).
|
|
|
|
* This function disables all interrupt sources on the GPU.
|
|
|
|
*/
|
2009-06-05 19:42:42 +07:00
|
|
|
void radeon_driver_irq_preinstall_kms(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2012-05-17 06:33:30 +07:00
|
|
|
unsigned long irqflags;
|
2009-06-05 19:42:42 +07:00
|
|
|
unsigned i;
|
|
|
|
|
2012-05-17 06:33:30 +07:00
|
|
|
spin_lock_irqsave(&rdev->irq.lock, irqflags);
|
2009-06-05 19:42:42 +07:00
|
|
|
/* Disable *all* interrupts */
|
2011-11-18 08:13:28 +07:00
|
|
|
for (i = 0; i < RADEON_NUM_RINGS; i++)
|
2012-05-18 00:52:00 +07:00
|
|
|
atomic_set(&rdev->irq.ring_int[i], 0);
|
2013-04-13 01:04:10 +07:00
|
|
|
rdev->irq.dpm_thermal = false;
|
2011-10-27 02:43:58 +07:00
|
|
|
for (i = 0; i < RADEON_MAX_HPD_PINS; i++)
|
2010-03-17 04:08:06 +07:00
|
|
|
rdev->irq.hpd[i] = false;
|
2011-10-27 02:43:58 +07:00
|
|
|
for (i = 0; i < RADEON_MAX_CRTCS; i++) {
|
|
|
|
rdev->irq.crtc_vblank_int[i] = false;
|
2012-05-18 00:52:00 +07:00
|
|
|
atomic_set(&rdev->irq.pflip[i], 0);
|
2012-03-30 19:59:57 +07:00
|
|
|
rdev->irq.afmt[i] = false;
|
2010-11-21 22:59:01 +07:00
|
|
|
}
|
2009-06-05 19:42:42 +07:00
|
|
|
radeon_irq_set(rdev);
|
2012-05-17 06:33:30 +07:00
|
|
|
spin_unlock_irqrestore(&rdev->irq.lock, irqflags);
|
2009-06-05 19:42:42 +07:00
|
|
|
/* Clear bits */
|
|
|
|
radeon_irq_process(rdev);
|
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_driver_irq_postinstall_kms - drm irq preinstall callback
|
|
|
|
*
|
|
|
|
* @dev: drm dev pointer
|
|
|
|
*
|
|
|
|
* Handles stuff to be done after enabling irqs (all asics).
|
|
|
|
* Returns 0 on success.
|
|
|
|
*/
|
2009-06-05 19:42:42 +07:00
|
|
|
int radeon_driver_irq_postinstall_kms(struct drm_device *dev)
|
|
|
|
{
|
2015-05-26 15:53:39 +07:00
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
|
|
|
|
|
|
|
if (ASIC_IS_AVIVO(rdev))
|
|
|
|
dev->max_vblank_count = 0x00ffffff;
|
|
|
|
else
|
|
|
|
dev->max_vblank_count = 0x001fffff;
|
|
|
|
|
2009-06-05 19:42:42 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_driver_irq_uninstall_kms - drm irq uninstall callback
|
|
|
|
*
|
|
|
|
* @dev: drm dev pointer
|
|
|
|
*
|
|
|
|
* This function disables all interrupt sources on the GPU (all asics).
|
|
|
|
*/
|
2009-06-05 19:42:42 +07:00
|
|
|
void radeon_driver_irq_uninstall_kms(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct radeon_device *rdev = dev->dev_private;
|
2012-05-17 06:33:30 +07:00
|
|
|
unsigned long irqflags;
|
2009-06-05 19:42:42 +07:00
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
if (rdev == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
2012-05-17 06:33:30 +07:00
|
|
|
spin_lock_irqsave(&rdev->irq.lock, irqflags);
|
2009-06-05 19:42:42 +07:00
|
|
|
/* Disable *all* interrupts */
|
2011-11-18 08:13:28 +07:00
|
|
|
for (i = 0; i < RADEON_NUM_RINGS; i++)
|
2012-05-18 00:52:00 +07:00
|
|
|
atomic_set(&rdev->irq.ring_int[i], 0);
|
2013-04-13 01:04:10 +07:00
|
|
|
rdev->irq.dpm_thermal = false;
|
2011-10-27 02:43:58 +07:00
|
|
|
for (i = 0; i < RADEON_MAX_HPD_PINS; i++)
|
2010-01-07 21:39:14 +07:00
|
|
|
rdev->irq.hpd[i] = false;
|
2011-10-27 02:43:58 +07:00
|
|
|
for (i = 0; i < RADEON_MAX_CRTCS; i++) {
|
|
|
|
rdev->irq.crtc_vblank_int[i] = false;
|
2012-05-18 00:52:00 +07:00
|
|
|
atomic_set(&rdev->irq.pflip[i], 0);
|
2012-03-30 19:59:57 +07:00
|
|
|
rdev->irq.afmt[i] = false;
|
2010-11-21 22:59:01 +07:00
|
|
|
}
|
2009-06-05 19:42:42 +07:00
|
|
|
radeon_irq_set(rdev);
|
2012-05-17 06:33:30 +07:00
|
|
|
spin_unlock_irqrestore(&rdev->irq.lock, irqflags);
|
2009-06-05 19:42:42 +07:00
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_msi_ok - asic specific msi checks
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
*
|
|
|
|
* Handles asic specific MSI checks to determine if
|
|
|
|
* MSIs should be enabled on a particular chip (all asics).
|
|
|
|
* Returns true if MSIs should be enabled, false if MSIs
|
|
|
|
* should not be enabled.
|
|
|
|
*/
|
2011-10-26 01:58:49 +07:00
|
|
|
static bool radeon_msi_ok(struct radeon_device *rdev)
|
|
|
|
{
|
|
|
|
/* RV370/RV380 was first asic with MSI support */
|
|
|
|
if (rdev->family < CHIP_RV380)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* MSIs don't work on AGP */
|
|
|
|
if (rdev->flags & RADEON_IS_AGP)
|
|
|
|
return false;
|
|
|
|
|
2014-10-03 12:18:59 +07:00
|
|
|
/*
|
|
|
|
* Older chips have a HW limitation, they can only generate 40 bits
|
|
|
|
* of address for "64-bit" MSIs which breaks on some platforms, notably
|
|
|
|
* IBM POWER servers, so we limit them
|
|
|
|
*/
|
|
|
|
if (rdev->family < CHIP_BONAIRE) {
|
|
|
|
dev_info(rdev->dev, "radeon: MSI limited to 32-bit\n");
|
|
|
|
rdev->pdev->no_64bit_msi = 1;
|
|
|
|
}
|
|
|
|
|
2011-11-02 01:20:30 +07:00
|
|
|
/* force MSI on */
|
|
|
|
if (radeon_msi == 1)
|
|
|
|
return true;
|
|
|
|
else if (radeon_msi == 0)
|
|
|
|
return false;
|
|
|
|
|
2011-10-26 02:11:08 +07:00
|
|
|
/* Quirks */
|
|
|
|
/* HP RS690 only seems to work with MSIs. */
|
|
|
|
if ((rdev->pdev->device == 0x791f) &&
|
|
|
|
(rdev->pdev->subsystem_vendor == 0x103c) &&
|
|
|
|
(rdev->pdev->subsystem_device == 0x30c2))
|
|
|
|
return true;
|
|
|
|
|
2012-01-15 20:51:12 +07:00
|
|
|
/* Dell RS690 only seems to work with MSIs. */
|
|
|
|
if ((rdev->pdev->device == 0x791f) &&
|
|
|
|
(rdev->pdev->subsystem_vendor == 0x1028) &&
|
|
|
|
(rdev->pdev->subsystem_device == 0x01fc))
|
|
|
|
return true;
|
|
|
|
|
2011-11-02 01:14:18 +07:00
|
|
|
/* Dell RS690 only seems to work with MSIs. */
|
|
|
|
if ((rdev->pdev->device == 0x791f) &&
|
|
|
|
(rdev->pdev->subsystem_vendor == 0x1028) &&
|
|
|
|
(rdev->pdev->subsystem_device == 0x01fd))
|
|
|
|
return true;
|
|
|
|
|
2012-09-26 23:31:45 +07:00
|
|
|
/* Gateway RS690 only seems to work with MSIs. */
|
|
|
|
if ((rdev->pdev->device == 0x791f) &&
|
|
|
|
(rdev->pdev->subsystem_vendor == 0x107b) &&
|
|
|
|
(rdev->pdev->subsystem_device == 0x0185))
|
|
|
|
return true;
|
|
|
|
|
2012-09-26 23:40:45 +07:00
|
|
|
/* try and enable MSIs by default on all RS690s */
|
|
|
|
if (rdev->family == CHIP_RS690)
|
|
|
|
return true;
|
|
|
|
|
2012-04-13 17:14:50 +07:00
|
|
|
/* RV515 seems to have MSI issues where it loses
|
|
|
|
* MSI rearms occasionally. This leads to lockups and freezes.
|
|
|
|
* disable it by default.
|
|
|
|
*/
|
|
|
|
if (rdev->family == CHIP_RV515)
|
|
|
|
return false;
|
2011-10-26 01:58:49 +07:00
|
|
|
if (rdev->flags & RADEON_IS_IGP) {
|
|
|
|
/* APUs work fine with MSIs */
|
|
|
|
if (rdev->family >= CHIP_PALM)
|
|
|
|
return true;
|
|
|
|
/* lots of IGPs have problems with MSIs */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_irq_kms_init - init driver interrupt info
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
*
|
|
|
|
* Sets up the work irq handlers, vblank init, MSIs, etc. (all asics).
|
|
|
|
* Returns 0 for success, error for failure.
|
|
|
|
*/
|
2009-06-05 19:42:42 +07:00
|
|
|
int radeon_irq_kms_init(struct radeon_device *rdev)
|
|
|
|
{
|
|
|
|
int r = 0;
|
|
|
|
|
2012-05-17 06:33:30 +07:00
|
|
|
spin_lock_init(&rdev->irq.lock);
|
2017-06-21 08:44:55 +07:00
|
|
|
|
|
|
|
/* Disable vblank irqs aggressively for power-saving */
|
|
|
|
rdev->ddev->vblank_disable_immediate = true;
|
|
|
|
|
2010-03-17 04:08:06 +07:00
|
|
|
r = drm_vblank_init(rdev->ddev, rdev->num_crtc);
|
2009-06-05 19:42:42 +07:00
|
|
|
if (r) {
|
|
|
|
return r;
|
|
|
|
}
|
2016-03-31 13:46:42 +07:00
|
|
|
|
2009-10-16 23:21:24 +07:00
|
|
|
/* enable msi */
|
|
|
|
rdev->msi_enabled = 0;
|
2011-10-26 01:58:49 +07:00
|
|
|
|
|
|
|
if (radeon_msi_ok(rdev)) {
|
2009-10-16 23:21:24 +07:00
|
|
|
int ret = pci_enable_msi(rdev->pdev);
|
2009-12-02 01:43:46 +07:00
|
|
|
if (!ret) {
|
2009-10-16 23:21:24 +07:00
|
|
|
rdev->msi_enabled = 1;
|
2010-08-13 05:05:34 +07:00
|
|
|
dev_info(rdev->dev, "radeon: using MSI.\n");
|
2009-12-02 01:43:46 +07:00
|
|
|
}
|
2009-10-16 23:21:24 +07:00
|
|
|
}
|
2013-08-29 16:29:35 +07:00
|
|
|
|
2015-12-04 06:26:07 +07:00
|
|
|
INIT_DELAYED_WORK(&rdev->hotplug_work, radeon_hotplug_work_func);
|
2015-02-24 06:23:56 +07:00
|
|
|
INIT_WORK(&rdev->dp_work, radeon_dp_work_func);
|
2013-08-29 16:29:35 +07:00
|
|
|
INIT_WORK(&rdev->audio_work, r600_audio_update_hdmi);
|
|
|
|
|
2009-06-05 19:42:42 +07:00
|
|
|
rdev->irq.installed = true;
|
2013-11-04 03:09:27 +07:00
|
|
|
r = drm_irq_install(rdev->ddev, rdev->ddev->pdev->irq);
|
2010-01-07 21:39:14 +07:00
|
|
|
if (r) {
|
|
|
|
rdev->irq.installed = false;
|
2015-12-04 06:26:07 +07:00
|
|
|
flush_delayed_work(&rdev->hotplug_work);
|
2010-01-07 21:39:14 +07:00
|
|
|
return r;
|
|
|
|
}
|
2013-07-14 18:03:27 +07:00
|
|
|
|
2009-06-05 19:42:42 +07:00
|
|
|
DRM_INFO("radeon: irq initialized.\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
2013-03-16 18:53:05 +07:00
|
|
|
* radeon_irq_kms_fini - tear down driver interrupt info
|
2012-07-18 01:02:35 +07:00
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
*
|
|
|
|
* Tears down the work irq handlers, vblank handlers, MSIs, etc. (all asics).
|
|
|
|
*/
|
2009-06-05 19:42:42 +07:00
|
|
|
void radeon_irq_kms_fini(struct radeon_device *rdev)
|
|
|
|
{
|
|
|
|
if (rdev->irq.installed) {
|
|
|
|
drm_irq_uninstall(rdev->ddev);
|
2010-01-07 21:39:14 +07:00
|
|
|
rdev->irq.installed = false;
|
2009-10-16 23:21:24 +07:00
|
|
|
if (rdev->msi_enabled)
|
|
|
|
pci_disable_msi(rdev->pdev);
|
2015-12-04 06:26:07 +07:00
|
|
|
flush_delayed_work(&rdev->hotplug_work);
|
2009-06-05 19:42:42 +07:00
|
|
|
}
|
|
|
|
}
|
2009-12-01 13:04:56 +07:00
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_irq_kms_sw_irq_get - enable software interrupt
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
* @ring: ring whose interrupt you want to enable
|
|
|
|
*
|
|
|
|
* Enables the software interrupt for a specific ring (all asics).
|
|
|
|
* The software interrupt is generally used to signal a fence on
|
|
|
|
* a particular ring.
|
|
|
|
*/
|
2011-11-18 08:13:28 +07:00
|
|
|
void radeon_irq_kms_sw_irq_get(struct radeon_device *rdev, int ring)
|
2009-12-01 13:04:56 +07:00
|
|
|
{
|
|
|
|
unsigned long irqflags;
|
|
|
|
|
2012-05-18 00:52:00 +07:00
|
|
|
if (!rdev->ddev->irq_enabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (atomic_inc_return(&rdev->irq.ring_int[ring]) == 1) {
|
|
|
|
spin_lock_irqsave(&rdev->irq.lock, irqflags);
|
2009-12-01 13:04:56 +07:00
|
|
|
radeon_irq_set(rdev);
|
2012-05-18 00:52:00 +07:00
|
|
|
spin_unlock_irqrestore(&rdev->irq.lock, irqflags);
|
2009-12-01 13:04:56 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-09 17:03:12 +07:00
|
|
|
/**
|
|
|
|
* radeon_irq_kms_sw_irq_get_delayed - enable software interrupt
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
* @ring: ring whose interrupt you want to enable
|
|
|
|
*
|
|
|
|
* Enables the software interrupt for a specific ring (all asics).
|
|
|
|
* The software interrupt is generally used to signal a fence on
|
|
|
|
* a particular ring.
|
|
|
|
*/
|
|
|
|
bool radeon_irq_kms_sw_irq_get_delayed(struct radeon_device *rdev, int ring)
|
|
|
|
{
|
|
|
|
return atomic_inc_return(&rdev->irq.ring_int[ring]) == 1;
|
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_irq_kms_sw_irq_put - disable software interrupt
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
* @ring: ring whose interrupt you want to disable
|
|
|
|
*
|
|
|
|
* Disables the software interrupt for a specific ring (all asics).
|
|
|
|
* The software interrupt is generally used to signal a fence on
|
|
|
|
* a particular ring.
|
|
|
|
*/
|
2011-11-18 08:13:28 +07:00
|
|
|
void radeon_irq_kms_sw_irq_put(struct radeon_device *rdev, int ring)
|
2009-12-01 13:04:56 +07:00
|
|
|
{
|
|
|
|
unsigned long irqflags;
|
|
|
|
|
2012-05-18 00:52:00 +07:00
|
|
|
if (!rdev->ddev->irq_enabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (atomic_dec_and_test(&rdev->irq.ring_int[ring])) {
|
|
|
|
spin_lock_irqsave(&rdev->irq.lock, irqflags);
|
2009-12-01 13:04:56 +07:00
|
|
|
radeon_irq_set(rdev);
|
2012-05-18 00:52:00 +07:00
|
|
|
spin_unlock_irqrestore(&rdev->irq.lock, irqflags);
|
2009-12-01 13:04:56 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_irq_kms_pflip_irq_get - enable pageflip interrupt
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
* @crtc: crtc whose interrupt you want to enable
|
|
|
|
*
|
|
|
|
* Enables the pageflip interrupt for a specific crtc (all asics).
|
|
|
|
* For pageflips we use the vblank interrupt source.
|
|
|
|
*/
|
2010-11-21 22:59:01 +07:00
|
|
|
void radeon_irq_kms_pflip_irq_get(struct radeon_device *rdev, int crtc)
|
|
|
|
{
|
|
|
|
unsigned long irqflags;
|
|
|
|
|
|
|
|
if (crtc < 0 || crtc >= rdev->num_crtc)
|
|
|
|
return;
|
|
|
|
|
2012-05-18 00:52:00 +07:00
|
|
|
if (!rdev->ddev->irq_enabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (atomic_inc_return(&rdev->irq.pflip[crtc]) == 1) {
|
|
|
|
spin_lock_irqsave(&rdev->irq.lock, irqflags);
|
2010-11-21 22:59:01 +07:00
|
|
|
radeon_irq_set(rdev);
|
2012-05-18 00:52:00 +07:00
|
|
|
spin_unlock_irqrestore(&rdev->irq.lock, irqflags);
|
2010-11-21 22:59:01 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_irq_kms_pflip_irq_put - disable pageflip interrupt
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
* @crtc: crtc whose interrupt you want to disable
|
|
|
|
*
|
|
|
|
* Disables the pageflip interrupt for a specific crtc (all asics).
|
|
|
|
* For pageflips we use the vblank interrupt source.
|
|
|
|
*/
|
2010-11-21 22:59:01 +07:00
|
|
|
void radeon_irq_kms_pflip_irq_put(struct radeon_device *rdev, int crtc)
|
|
|
|
{
|
|
|
|
unsigned long irqflags;
|
|
|
|
|
|
|
|
if (crtc < 0 || crtc >= rdev->num_crtc)
|
|
|
|
return;
|
|
|
|
|
2012-05-18 00:52:00 +07:00
|
|
|
if (!rdev->ddev->irq_enabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (atomic_dec_and_test(&rdev->irq.pflip[crtc])) {
|
|
|
|
spin_lock_irqsave(&rdev->irq.lock, irqflags);
|
2010-11-21 22:59:01 +07:00
|
|
|
radeon_irq_set(rdev);
|
2012-05-18 00:52:00 +07:00
|
|
|
spin_unlock_irqrestore(&rdev->irq.lock, irqflags);
|
2010-11-21 22:59:01 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_irq_kms_enable_afmt - enable audio format change interrupt
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
* @block: afmt block whose interrupt you want to enable
|
|
|
|
*
|
|
|
|
* Enables the afmt change interrupt for a specific afmt block (all asics).
|
|
|
|
*/
|
2012-05-17 06:33:30 +07:00
|
|
|
void radeon_irq_kms_enable_afmt(struct radeon_device *rdev, int block)
|
|
|
|
{
|
|
|
|
unsigned long irqflags;
|
|
|
|
|
2013-02-27 04:17:33 +07:00
|
|
|
if (!rdev->ddev->irq_enabled)
|
|
|
|
return;
|
|
|
|
|
2012-05-17 06:33:30 +07:00
|
|
|
spin_lock_irqsave(&rdev->irq.lock, irqflags);
|
|
|
|
rdev->irq.afmt[block] = true;
|
|
|
|
radeon_irq_set(rdev);
|
|
|
|
spin_unlock_irqrestore(&rdev->irq.lock, irqflags);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_irq_kms_disable_afmt - disable audio format change interrupt
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
* @block: afmt block whose interrupt you want to disable
|
|
|
|
*
|
|
|
|
* Disables the afmt change interrupt for a specific afmt block (all asics).
|
|
|
|
*/
|
2012-05-17 06:33:30 +07:00
|
|
|
void radeon_irq_kms_disable_afmt(struct radeon_device *rdev, int block)
|
|
|
|
{
|
|
|
|
unsigned long irqflags;
|
|
|
|
|
2013-02-27 04:17:33 +07:00
|
|
|
if (!rdev->ddev->irq_enabled)
|
|
|
|
return;
|
|
|
|
|
2012-05-17 06:33:30 +07:00
|
|
|
spin_lock_irqsave(&rdev->irq.lock, irqflags);
|
|
|
|
rdev->irq.afmt[block] = false;
|
|
|
|
radeon_irq_set(rdev);
|
|
|
|
spin_unlock_irqrestore(&rdev->irq.lock, irqflags);
|
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_irq_kms_enable_hpd - enable hotplug detect interrupt
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
* @hpd_mask: mask of hpd pins you want to enable.
|
|
|
|
*
|
|
|
|
* Enables the hotplug detect interrupt for a specific hpd pin (all asics).
|
|
|
|
*/
|
2012-05-17 06:33:30 +07:00
|
|
|
void radeon_irq_kms_enable_hpd(struct radeon_device *rdev, unsigned hpd_mask)
|
|
|
|
{
|
|
|
|
unsigned long irqflags;
|
|
|
|
int i;
|
|
|
|
|
2013-02-27 04:17:33 +07:00
|
|
|
if (!rdev->ddev->irq_enabled)
|
|
|
|
return;
|
|
|
|
|
2012-05-17 06:33:30 +07:00
|
|
|
spin_lock_irqsave(&rdev->irq.lock, irqflags);
|
|
|
|
for (i = 0; i < RADEON_MAX_HPD_PINS; ++i)
|
|
|
|
rdev->irq.hpd[i] |= !!(hpd_mask & (1 << i));
|
|
|
|
radeon_irq_set(rdev);
|
|
|
|
spin_unlock_irqrestore(&rdev->irq.lock, irqflags);
|
|
|
|
}
|
|
|
|
|
2012-07-18 01:02:35 +07:00
|
|
|
/**
|
|
|
|
* radeon_irq_kms_disable_hpd - disable hotplug detect interrupt
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
* @hpd_mask: mask of hpd pins you want to disable.
|
|
|
|
*
|
|
|
|
* Disables the hotplug detect interrupt for a specific hpd pin (all asics).
|
|
|
|
*/
|
2012-05-17 06:33:30 +07:00
|
|
|
void radeon_irq_kms_disable_hpd(struct radeon_device *rdev, unsigned hpd_mask)
|
|
|
|
{
|
|
|
|
unsigned long irqflags;
|
|
|
|
int i;
|
|
|
|
|
2013-02-27 04:17:33 +07:00
|
|
|
if (!rdev->ddev->irq_enabled)
|
|
|
|
return;
|
|
|
|
|
2012-05-17 06:33:30 +07:00
|
|
|
spin_lock_irqsave(&rdev->irq.lock, irqflags);
|
|
|
|
for (i = 0; i < RADEON_MAX_HPD_PINS; ++i)
|
|
|
|
rdev->irq.hpd[i] &= !(hpd_mask & (1 << i));
|
|
|
|
radeon_irq_set(rdev);
|
|
|
|
spin_unlock_irqrestore(&rdev->irq.lock, irqflags);
|
|
|
|
}
|
|
|
|
|
drm/radeon: Cleanup display interrupt handling for evergreen, si
The current code here is really, really bad. A huge amount of it looks
to be copy pasted, it has some weird hatred of arrays and code sharing,
switch cases everywhere for things that really don't need them, and it
makes the file seem immensely more complex then it actually is. This is
a pain for maintanence, and is vulnerable to more weird irq handling
bugs.
So, let's start cleaning this up a bit. Modify all of the IRQ handlers
for evergreen/si so that they just use for loops. As well, we add a
helper function radeon_irq_kms_set_irq_n_enabled(), whose purpose is
just to update the state of registers that enable/disable interrupts
while printing any changes to the set of enabled interrupts to the
kernel log.
Note in this commit, since vblank/vline irq acking is intertwined with
page flip irq acking, we can't cut out all of the copy paste in
evergreen/si_irq_ack() just yet.
Changes since v1:
- Preserve order we write back all registers
Acked-by: Christian König <christian.koenig@amd.com>
Signed-off-by: Lyude <lyude@redhat.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
2017-05-20 06:48:37 +07:00
|
|
|
/**
|
|
|
|
* radeon_irq_kms_update_int_n - helper for updating interrupt enable registers
|
|
|
|
*
|
|
|
|
* @rdev: radeon device pointer
|
|
|
|
* @reg: the register to write to enable/disable interrupts
|
|
|
|
* @mask: the mask that enables the interrupts
|
|
|
|
* @enable: whether to enable or disable the interrupt register
|
|
|
|
* @name: the name of the interrupt register to print to the kernel log
|
|
|
|
* @num: the number of the interrupt register to print to the kernel log
|
|
|
|
*
|
|
|
|
* Helper for updating the enable state of interrupt registers. Checks whether
|
|
|
|
* or not the interrupt matches the enable state we want. If it doesn't, then
|
|
|
|
* we update it and print a debugging message to the kernel log indicating the
|
|
|
|
* new state of the interrupt register.
|
|
|
|
*
|
|
|
|
* Used for updating sequences of interrupts registers like HPD1, HPD2, etc.
|
|
|
|
*/
|
|
|
|
void radeon_irq_kms_set_irq_n_enabled(struct radeon_device *rdev,
|
|
|
|
u32 reg, u32 mask,
|
|
|
|
bool enable, const char *name, unsigned n)
|
|
|
|
{
|
|
|
|
u32 tmp = RREG32(reg);
|
|
|
|
|
|
|
|
/* Interrupt state didn't change */
|
|
|
|
if (!!(tmp & mask) == enable)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (enable) {
|
|
|
|
DRM_DEBUG("%s%d interrupts enabled\n", name, n);
|
|
|
|
WREG32(reg, tmp |= mask);
|
|
|
|
} else {
|
|
|
|
DRM_DEBUG("%s%d interrupts disabled\n", name, n);
|
|
|
|
WREG32(reg, tmp & ~mask);
|
|
|
|
}
|
|
|
|
}
|