github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-26 08:02:27 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

Merge tag 'drm-misc-fixes-2026-02-05' of https://gitlab.freedesktop.org/drm/misc/kernel into drm-fixes

Browse Source 
drm-misc-fixes for v6.19 final:

nouveau
-------
Revert adding atomic commit functions as it regresses pre-nv50.
Fix bugs exposed by enabling 570 firmware.

gma500
------
Revert a regression caused by vblank changes.

mgag200
-------
Replace a busy loop with a polling loop to fix that blocking 1 cpu for 300 ms roughly every 20 minutes.

bridge
------
imx8mp-hdmi-pa: Use runtime pm to fix a bug in channel ordering.

Signed-off-by: Dave Airlie <airlied@redhat.com>
From: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Link: https://patch.msgid.link/c0077ea5-faeb-4b0c-bd4a-ea2384d6dc0c@linux.intel.com
This commit is contained in:
Dave Airlie 2026-02-06 12:24:38 +10:00
commit 4e3b2f0db4
67 changed files with 207 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
drivers/gpu/drm/bridge/imx/imx8mp-hdmi-pai.c
View File

@ -8,6 +8,7 @@
#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <drm/bridge/dw_hdmi.h>
#include <sound/asoundef.h>
@ -33,6 +34,7 @@
struct imx8mp_hdmi_pai {
struct regmap *regmap;
struct device *dev;
};
static void imx8mp_hdmi_pai_enable(struct dw_hdmi *dw_hdmi, int channel,
@ -43,6 +45,9 @@ static void imx8mp_hdmi_pai_enable(struct dw_hdmi *dw_hdmi, int channel,
struct imx8mp_hdmi_pai *hdmi_pai = pdata->priv_audio;
int val;
if (pm_runtime_resume_and_get(hdmi_pai->dev) < 0)
return;
/* PAI set control extended */
val = WTMK_HIGH(3) | WTMK_LOW(3);
val |= NUM_CH(channel);
@ -85,6 +90,8 @@ static void imx8mp_hdmi_pai_disable(struct dw_hdmi *dw_hdmi)
/* Stop PAI */
regmap_write(hdmi_pai->regmap, HTX_PAI_CTRL, 0);
pm_runtime_put_sync(hdmi_pai->dev);
}
static const struct regmap_config imx8mp_hdmi_pai_regmap_config = {
@ -101,6 +108,7 @@ static int imx8mp_hdmi_pai_bind(struct device *dev, struct device *master, void
struct imx8mp_hdmi_pai *hdmi_pai;
struct resource *res;
void __iomem *base;
int ret;
hdmi_pai = devm_kzalloc(dev, sizeof(*hdmi_pai), GFP_KERNEL);
if (!hdmi_pai)
@ -121,6 +129,13 @@ static int imx8mp_hdmi_pai_bind(struct device *dev, struct device *master, void
plat_data->disable_audio = imx8mp_hdmi_pai_disable;
plat_data->priv_audio = hdmi_pai;
hdmi_pai->dev = dev;
ret = devm_pm_runtime_enable(dev);
if (ret < 0) {
dev_err(dev, "failed to enable PM runtime: %d\n", ret);
return ret;
}
return 0;
}

36
drivers/gpu/drm/gma500/psb_irq.c
View File

@ -250,7 +250,6 @@ static irqreturn_t gma_irq_handler(int irq, void *arg)
void gma_irq_preinstall(struct drm_device *dev)
{
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
struct drm_crtc *crtc;
unsigned long irqflags;
spin_lock_irqsave(&dev_priv->irqmask_lock, irqflags);
@ -261,15 +260,10 @@ void gma_irq_preinstall(struct drm_device *dev)
PSB_WSGX32(0x00000000, PSB_CR_EVENT_HOST_ENABLE);
PSB_RSGX32(PSB_CR_EVENT_HOST_ENABLE);
drm_for_each_crtc(crtc, dev) {
struct drm_vblank_crtc *vblank = drm_crtc_vblank_crtc(crtc);
if (vblank->enabled) {
u32 mask = drm_crtc_index(crtc) ? _PSB_VSYNC_PIPEB_FLAG :
_PSB_VSYNC_PIPEA_FLAG;
dev_priv->vdc_irq_mask |= mask;
}
}
if (dev->vblank[0].enabled)
dev_priv->vdc_irq_mask |= _PSB_VSYNC_PIPEA_FLAG;
if (dev->vblank[1].enabled)
dev_priv->vdc_irq_mask |= _PSB_VSYNC_PIPEB_FLAG;
/* Revisit this area - want per device masks ? */
if (dev_priv->ops->hotplug)
@ -284,8 +278,8 @@ void gma_irq_preinstall(struct drm_device *dev)
void gma_irq_postinstall(struct drm_device *dev)
{
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
struct drm_crtc *crtc;
unsigned long irqflags;
unsigned int i;
spin_lock_irqsave(&dev_priv->irqmask_lock, irqflags);
@ -298,13 +292,11 @@ void gma_irq_postinstall(struct drm_device *dev)
PSB_WVDC32(dev_priv->vdc_irq_mask, PSB_INT_ENABLE_R);
PSB_WVDC32(0xFFFFFFFF, PSB_HWSTAM);
drm_for_each_crtc(crtc, dev) {
struct drm_vblank_crtc *vblank = drm_crtc_vblank_crtc(crtc);
if (vblank->enabled)
gma_enable_pipestat(dev_priv, drm_crtc_index(crtc), PIPE_VBLANK_INTERRUPT_ENABLE);
for (i = 0; i < dev->num_crtcs; ++i) {
if (dev->vblank[i].enabled)
gma_enable_pipestat(dev_priv, i, PIPE_VBLANK_INTERRUPT_ENABLE);
else
gma_disable_pipestat(dev_priv, drm_crtc_index(crtc), PIPE_VBLANK_INTERRUPT_ENABLE);
gma_disable_pipestat(dev_priv, i, PIPE_VBLANK_INTERRUPT_ENABLE);
}
if (dev_priv->ops->hotplug_enable)
@ -345,8 +337,8 @@ void gma_irq_uninstall(struct drm_device *dev)
{
struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
struct pci_dev *pdev = to_pci_dev(dev->dev);
struct drm_crtc *crtc;
unsigned long irqflags;
unsigned int i;
if (!dev_priv->irq_enabled)
return;
@ -358,11 +350,9 @@ void gma_irq_uninstall(struct drm_device *dev)
PSB_WVDC32(0xFFFFFFFF, PSB_HWSTAM);
drm_for_each_crtc(crtc, dev) {
struct drm_vblank_crtc *vblank = drm_crtc_vblank_crtc(crtc);
if (vblank->enabled)
gma_disable_pipestat(dev_priv, drm_crtc_index(crtc), PIPE_VBLANK_INTERRUPT_ENABLE);
for (i = 0; i < dev->num_crtcs; ++i) {
if (dev->vblank[i].enabled)
gma_disable_pipestat(dev_priv, i, PIPE_VBLANK_INTERRUPT_ENABLE);
}
dev_priv->vdc_irq_mask &= _PSB_IRQ_SGX_FLAG |

31
drivers/gpu/drm/mgag200/mgag200_bmc.c
View File

@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-2.0-only
#include <linux/delay.h>
#include <linux/iopoll.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_edid.h>
@ -12,7 +13,7 @@
void mgag200_bmc_stop_scanout(struct mga_device *mdev)
{
u8 tmp;
int iter_max;
int ret;
/*
* 1 - The first step is to inform the BMC of an upcoming mode
@ -42,30 +43,22 @@ void mgag200_bmc_stop_scanout(struct mga_device *mdev)
/*
* 3a- The third step is to verify if there is an active scan.
* We are waiting for a 0 on remhsyncsts <XSPAREREG<0>).
* We are waiting for a 0 on remhsyncsts (<XSPAREREG<0>).
*/
iter_max = 300;
while (!(tmp & 0x1) && iter_max) {
WREG8(DAC_INDEX, MGA1064_SPAREREG);
tmp = RREG8(DAC_DATA);
udelay(1000);
iter_max--;
}
ret = read_poll_timeout(RREG_DAC, tmp, !(tmp & 0x1),
1000, 300000, false,
MGA1064_SPAREREG);
if (ret == -ETIMEDOUT)
return;
/*
* 3b- This step occurs only if the remove is actually
* 3b- This step occurs only if the remote BMC is actually
* scanning. We are waiting for the end of the frame which is
* a 1 on remvsyncsts (XSPAREREG<1>)
*/
if (iter_max) {
iter_max = 300;
while ((tmp & 0x2) && iter_max) {
WREG8(DAC_INDEX, MGA1064_SPAREREG);
tmp = RREG8(DAC_DATA);
udelay(1000);
iter_max--;
}
}
(void)read_poll_timeout(RREG_DAC, tmp, (tmp & 0x2),
1000, 300000, false,
MGA1064_SPAREREG);
}
void mgag200_bmc_start_scanout(struct mga_device *mdev)

6
drivers/gpu/drm/mgag200/mgag200_drv.h
View File

@ -111,6 +111,12 @@
#define DAC_INDEX 0x3c00
#define DAC_DATA 0x3c0a
#define RREG_DAC(reg) \
({ \
WREG8(DAC_INDEX, reg); \
RREG8(DAC_DATA); \
}) \
#define WREG_DAC(reg, v) \
do { \
WREG8(DAC_INDEX, reg); \

2
drivers/gpu/drm/nouveau/include/nvif/client.h
View File

@ -11,7 +11,7 @@ struct nvif_client {
int nvif_client_ctor(struct nvif_client *parent, const char *name, struct nvif_client *);
void nvif_client_dtor(struct nvif_client *);
int nvif_client_suspend(struct nvif_client *);
int nvif_client_suspend(struct nvif_client *, bool);
int nvif_client_resume(struct nvif_client *);
/*XXX*/

2
drivers/gpu/drm/nouveau/include/nvif/driver.h
View File

@ -8,7 +8,7 @@ struct nvif_driver {
const char *name;
int (*init)(const char *name, u64 device, const char *cfg,
const char *dbg, void **priv);
int (*suspend)(void *priv);
int (*suspend)(void *priv, bool runtime);
int (*resume)(void *priv);
int (*ioctl)(void *priv, void *data, u32 size, void **hack);
void __iomem *(*map)(void *priv, u64 handle, u32 size);

3
drivers/gpu/drm/nouveau/include/nvkm/core/device.h
View File

@ -2,6 +2,7 @@
#ifndef __NVKM_DEVICE_H__
#define __NVKM_DEVICE_H__
#include <core/oclass.h>
#include <core/suspend_state.h>
#include <core/intr.h>
enum nvkm_subdev_type;
@ -93,7 +94,7 @@ struct nvkm_device_func {
void *(*dtor)(struct nvkm_device *);
int (*preinit)(struct nvkm_device *);
int (*init)(struct nvkm_device *);
void (*fini)(struct nvkm_device *, bool suspend);
void (*fini)(struct nvkm_device *, enum nvkm_suspend_state suspend);
int (*irq)(struct nvkm_device *);
resource_size_t (*resource_addr)(struct nvkm_device *, enum nvkm_bar_id);
resource_size_t (*resource_size)(struct nvkm_device *, enum nvkm_bar_id);

2
drivers/gpu/drm/nouveau/include/nvkm/core/engine.h
View File

@ -20,7 +20,7 @@ struct nvkm_engine_func {
int (*oneinit)(struct nvkm_engine *);
int (*info)(struct nvkm_engine *, u64 mthd, u64 *data);
int (*init)(struct nvkm_engine *);
int (*fini)(struct nvkm_engine *, bool suspend);
int (*fini)(struct nvkm_engine *, enum nvkm_suspend_state suspend);
int (*reset)(struct nvkm_engine *);
int (*nonstall)(struct nvkm_engine *);
void (*intr)(struct nvkm_engine *);

5
drivers/gpu/drm/nouveau/include/nvkm/core/object.h
View File

@ -2,6 +2,7 @@
#ifndef __NVKM_OBJECT_H__
#define __NVKM_OBJECT_H__
#include <core/oclass.h>
#include <core/suspend_state.h>
struct nvkm_event;
struct nvkm_gpuobj;
struct nvkm_uevent;
@ -27,7 +28,7 @@ enum nvkm_object_map {
struct nvkm_object_func {
void *(*dtor)(struct nvkm_object *);
int (*init)(struct nvkm_object *);
int (*fini)(struct nvkm_object *, bool suspend);
int (*fini)(struct nvkm_object *, enum nvkm_suspend_state suspend);
int (*mthd)(struct nvkm_object *, u32 mthd, void *data, u32 size);
int (*ntfy)(struct nvkm_object *, u32 mthd, struct nvkm_event **);
int (*map)(struct nvkm_object *, void *argv, u32 argc,
@ -49,7 +50,7 @@ int nvkm_object_new(const struct nvkm_oclass *, void *data, u32 size,
void nvkm_object_del(struct nvkm_object **);
void *nvkm_object_dtor(struct nvkm_object *);
int nvkm_object_init(struct nvkm_object *);
int nvkm_object_fini(struct nvkm_object *, bool suspend);
int nvkm_object_fini(struct nvkm_object *, enum nvkm_suspend_state);
int nvkm_object_mthd(struct nvkm_object *, u32 mthd, void *data, u32 size);
int nvkm_object_ntfy(struct nvkm_object *, u32 mthd, struct nvkm_event **);
int nvkm_object_map(struct nvkm_object *, void *argv, u32 argc,

2
drivers/gpu/drm/nouveau/include/nvkm/core/oproxy.h
View File

@ -13,7 +13,7 @@ struct nvkm_oproxy {
struct nvkm_oproxy_func {
void (*dtor[2])(struct nvkm_oproxy *);
int (*init[2])(struct nvkm_oproxy *);
int (*fini[2])(struct nvkm_oproxy *, bool suspend);
int (*fini[2])(struct nvkm_oproxy *, enum nvkm_suspend_state suspend);
};
void nvkm_oproxy_ctor(const struct nvkm_oproxy_func *,

4
drivers/gpu/drm/nouveau/include/nvkm/core/subdev.h
View File

@ -40,7 +40,7 @@ struct nvkm_subdev_func {
int (*oneinit)(struct nvkm_subdev *);
int (*info)(struct nvkm_subdev *, u64 mthd, u64 *data);
int (*init)(struct nvkm_subdev *);
int (*fini)(struct nvkm_subdev *, bool suspend);
int (*fini)(struct nvkm_subdev *, enum nvkm_suspend_state suspend);
void (*intr)(struct nvkm_subdev *);
};
@ -65,7 +65,7 @@ void nvkm_subdev_unref(struct nvkm_subdev *);
int nvkm_subdev_preinit(struct nvkm_subdev *);
int nvkm_subdev_oneinit(struct nvkm_subdev *);
int nvkm_subdev_init(struct nvkm_subdev *);
int nvkm_subdev_fini(struct nvkm_subdev *, bool suspend);
int nvkm_subdev_fini(struct nvkm_subdev *, enum nvkm_suspend_state suspend);
int nvkm_subdev_info(struct nvkm_subdev *, u64, u64 *);
void nvkm_subdev_intr(struct nvkm_subdev *);

11
drivers/gpu/drm/nouveau/include/nvkm/core/suspend_state.h Normal file
View File

@ -0,0 +1,11 @@
/* SPDX-License-Identifier: MIT */
#ifndef __NVKM_SUSPEND_STATE_H__
#define __NVKM_SUSPEND_STATE_H__
enum nvkm_suspend_state {
NVKM_POWEROFF,
NVKM_SUSPEND,
NVKM_RUNTIME_SUSPEND,
};
#endif

6
drivers/gpu/drm/nouveau/include/nvkm/subdev/gsp.h
View File

@ -44,6 +44,9 @@ typedef void (*nvkm_gsp_event_func)(struct nvkm_gsp_event *, void *repv, u32 rep
* NVKM_GSP_RPC_REPLY_NOWAIT - If specified, immediately return to the
* caller after the GSP RPC command is issued.
*
* NVKM_GSP_RPC_REPLY_NOSEQ - If specified, exactly like NOWAIT
* but don't emit RPC sequence number.
*
* NVKM_GSP_RPC_REPLY_RECV - If specified, wait and receive the entire GSP
* RPC message after the GSP RPC command is issued.
*
@ -53,6 +56,7 @@ typedef void (*nvkm_gsp_event_func)(struct nvkm_gsp_event *, void *repv, u32 rep
*/
enum nvkm_gsp_rpc_reply_policy {
NVKM_GSP_RPC_REPLY_NOWAIT = 0,
NVKM_GSP_RPC_REPLY_NOSEQ,
NVKM_GSP_RPC_REPLY_RECV,
NVKM_GSP_RPC_REPLY_POLL,
};
@ -242,6 +246,8 @@ struct nvkm_gsp {
/* The size of the registry RPC */
size_t registry_rpc_size;
u32 rpc_seq;
#ifdef CONFIG_DEBUG_FS
/*
* Logging buffers in debugfs. The wrapper objects need to remain

2
drivers/gpu/drm/nouveau/nouveau_display.c
View File

@ -352,8 +352,6 @@ nouveau_user_framebuffer_create(struct drm_device *dev,
static const struct drm_mode_config_funcs nouveau_mode_config_funcs = {
.fb_create = nouveau_user_framebuffer_create,
.atomic_commit = drm_atomic_helper_commit,
.atomic_check = drm_atomic_helper_check,
};

2
drivers/gpu/drm/nouveau/nouveau_drm.c
View File

@ -983,7 +983,7 @@ nouveau_do_suspend(struct nouveau_drm *drm, bool runtime)
}
NV_DEBUG(drm, "suspending object tree...\n");
ret = nvif_client_suspend(&drm->_client);
ret = nvif_client_suspend(&drm->_client, runtime);
if (ret)
goto fail_client;

10
drivers/gpu/drm/nouveau/nouveau_nvif.c
View File

@ -62,10 +62,16 @@ nvkm_client_resume(void *priv)
}
static int
nvkm_client_suspend(void *priv)
nvkm_client_suspend(void *priv, bool runtime)
{
struct nvkm_client *client = priv;
return nvkm_object_fini(&client->object, true);
enum nvkm_suspend_state state;
if (runtime)
state = NVKM_RUNTIME_SUSPEND;
else
state = NVKM_SUSPEND;
return nvkm_object_fini(&client->object, state);
}
static int

4
drivers/gpu/drm/nouveau/nvif/client.c
View File

@ -30,9 +30,9 @@
#include <nvif/if0000.h>
int
nvif_client_suspend(struct nvif_client *client)
nvif_client_suspend(struct nvif_client *client, bool runtime)
{
return client->driver->suspend(client->object.priv);
return client->driver->suspend(client->object.priv, runtime);
}
int

4
drivers/gpu/drm/nouveau/nvkm/core/engine.c
View File

@ -41,7 +41,7 @@ nvkm_engine_reset(struct nvkm_engine *engine)
if (engine->func->reset)
return engine->func->reset(engine);
nvkm_subdev_fini(&engine->subdev, false);
nvkm_subdev_fini(&engine->subdev, NVKM_POWEROFF);
return nvkm_subdev_init(&engine->subdev);
}
@ -98,7 +98,7 @@ nvkm_engine_info(struct nvkm_subdev *subdev, u64 mthd, u64 *data)
}
static int
nvkm_engine_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_engine_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_engine *engine = nvkm_engine(subdev);
if (engine->func->fini)

4
drivers/gpu/drm/nouveau/nvkm/core/ioctl.c
View File

@ -141,7 +141,7 @@ nvkm_ioctl_new(struct nvkm_client *client,
}
ret = -EEXIST;
}
nvkm_object_fini(object, false);
nvkm_object_fini(object, NVKM_POWEROFF);
}
nvkm_object_del(&object);
@ -160,7 +160,7 @@ nvkm_ioctl_del(struct nvkm_client *client,
nvif_ioctl(object, "delete size %d\n", size);
if (!(ret = nvif_unvers(ret, &data, &size, args->none))) {
nvif_ioctl(object, "delete\n");
nvkm_object_fini(object, false);
nvkm_object_fini(object, NVKM_POWEROFF);
nvkm_object_del(&object);
}

20
drivers/gpu/drm/nouveau/nvkm/core/object.c
View File

@ -142,13 +142,25 @@ nvkm_object_bind(struct nvkm_object *object, struct nvkm_gpuobj *gpuobj,
}
int
nvkm_object_fini(struct nvkm_object *object, bool suspend)
nvkm_object_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
const char *action = suspend ? "suspend" : "fini";
const char *action;
struct nvkm_object *child;
s64 time;
int ret;
switch (suspend) {
case NVKM_POWEROFF:
default:
action = "fini";
break;
case NVKM_SUSPEND:
action = "suspend";
break;
case NVKM_RUNTIME_SUSPEND:
action = "runtime";
break;
}
nvif_debug(object, "%s children...\n", action);
time = ktime_to_us(ktime_get());
list_for_each_entry_reverse(child, &object->tree, head) {
@ -212,11 +224,11 @@ nvkm_object_init(struct nvkm_object *object)
fail_child:
list_for_each_entry_continue_reverse(child, &object->tree, head)
nvkm_object_fini(child, false);
nvkm_object_fini(child, NVKM_POWEROFF);
fail:
nvif_error(object, "init failed with %d\n", ret);
if (object->func->fini)
object->func->fini(object, false);
object->func->fini(object, NVKM_POWEROFF);
return ret;
}

2
drivers/gpu/drm/nouveau/nvkm/core/oproxy.c
View File

@ -87,7 +87,7 @@ nvkm_oproxy_uevent(struct nvkm_object *object, void *argv, u32 argc,
}
static int
nvkm_oproxy_fini(struct nvkm_object *object, bool suspend)
nvkm_oproxy_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
struct nvkm_oproxy *oproxy = nvkm_oproxy(object);
int ret;

18
drivers/gpu/drm/nouveau/nvkm/core/subdev.c
View File

@ -51,12 +51,24 @@ nvkm_subdev_info(struct nvkm_subdev *subdev, u64 mthd, u64 *data)
}
int
nvkm_subdev_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_subdev_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_device *device = subdev->device;
const char *action = suspend ? "suspend" : subdev->use.enabled ? "fini" : "reset";
const char *action;
s64 time;
switch (suspend) {
case NVKM_POWEROFF:
default:
action = subdev->use.enabled ? "fini" : "reset";
break;
case NVKM_SUSPEND:
action = "suspend";
break;
case NVKM_RUNTIME_SUSPEND:
action = "runtime";
break;
}
nvkm_trace(subdev, "%s running...\n", action);
time = ktime_to_us(ktime_get());
@ -186,7 +198,7 @@ void
nvkm_subdev_unref(struct nvkm_subdev *subdev)
{
if (refcount_dec_and_mutex_lock(&subdev->use.refcount, &subdev->use.mutex)) {
nvkm_subdev_fini(subdev, false);
nvkm_subdev_fini(subdev, NVKM_POWEROFF);
mutex_unlock(&subdev->use.mutex);
}
}

2
drivers/gpu/drm/nouveau/nvkm/core/uevent.c
View File

@ -73,7 +73,7 @@ nvkm_uevent_mthd(struct nvkm_object *object, u32 mthd, void *argv, u32 argc)
}
static int
nvkm_uevent_fini(struct nvkm_object *object, bool suspend)
nvkm_uevent_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
struct nvkm_uevent *uevent = nvkm_uevent(object);

2
drivers/gpu/drm/nouveau/nvkm/engine/ce/ga100.c
View File

@ -46,7 +46,7 @@ ga100_ce_nonstall(struct nvkm_engine *engine)
}
int
ga100_ce_fini(struct nvkm_engine *engine, bool suspend)
ga100_ce_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend)
{
nvkm_inth_block(&engine->subdev.inth);
return 0;

2
drivers/gpu/drm/nouveau/nvkm/engine/ce/priv.h
View File

@ -14,7 +14,7 @@ extern const struct nvkm_object_func gv100_ce_cclass;
int ga100_ce_oneinit(struct nvkm_engine *);
int ga100_ce_init(struct nvkm_engine *);
int ga100_ce_fini(struct nvkm_engine *, bool);
int ga100_ce_fini(struct nvkm_engine *, enum nvkm_suspend_state);
int ga100_ce_nonstall(struct nvkm_engine *);
u32 gb202_ce_grce_mask(struct nvkm_device *);

22
drivers/gpu/drm/nouveau/nvkm/engine/device/base.c
View File

@ -2936,13 +2936,25 @@ nvkm_device_engine(struct nvkm_device *device, int type, int inst)
}
int
nvkm_device_fini(struct nvkm_device *device, bool suspend)
nvkm_device_fini(struct nvkm_device *device, enum nvkm_suspend_state suspend)
{
const char *action = suspend ? "suspend" : "fini";
const char *action;
struct nvkm_subdev *subdev;
int ret;
s64 time;
switch (suspend) {
case NVKM_POWEROFF:
default:
action = "fini";
break;
case NVKM_SUSPEND:
action = "suspend";
break;
case NVKM_RUNTIME_SUSPEND:
action = "runtime";
break;
}
nvdev_trace(device, "%s running...\n", action);
time = ktime_to_us(ktime_get());
@ -3032,7 +3044,7 @@ nvkm_device_init(struct nvkm_device *device)
if (ret)
return ret;
nvkm_device_fini(device, false);
nvkm_device_fini(device, NVKM_POWEROFF);
nvdev_trace(device, "init running...\n");
time = ktime_to_us(ktime_get());
@ -3060,9 +3072,9 @@ nvkm_device_init(struct nvkm_device *device)
fail_subdev:
list_for_each_entry_from(subdev, &device->subdev, head)
nvkm_subdev_fini(subdev, false);
nvkm_subdev_fini(subdev, NVKM_POWEROFF);
fail:
nvkm_device_fini(device, false);
nvkm_device_fini(device, NVKM_POWEROFF);
nvdev_error(device, "init failed with %d\n", ret);
return ret;

4
drivers/gpu/drm/nouveau/nvkm/engine/device/pci.c
View File

@ -1605,10 +1605,10 @@ nvkm_device_pci_irq(struct nvkm_device *device)
}
static void
nvkm_device_pci_fini(struct nvkm_device *device, bool suspend)
nvkm_device_pci_fini(struct nvkm_device *device, enum nvkm_suspend_state suspend)
{
struct nvkm_device_pci *pdev = nvkm_device_pci(device);
if (suspend) {
if (suspend != NVKM_POWEROFF) {
pci_disable_device(pdev->pdev);
pdev->suspend = true;
}

2
drivers/gpu/drm/nouveau/nvkm/engine/device/priv.h
View File

@ -56,5 +56,5 @@ int nvkm_device_ctor(const struct nvkm_device_func *,
const char *name, const char *cfg, const char *dbg,
struct nvkm_device *);
int nvkm_device_init(struct nvkm_device *);
int nvkm_device_fini(struct nvkm_device *, bool suspend);
int nvkm_device_fini(struct nvkm_device *, enum nvkm_suspend_state suspend);
#endif

2
drivers/gpu/drm/nouveau/nvkm/engine/device/user.c
View File

@ -218,7 +218,7 @@ nvkm_udevice_map(struct nvkm_object *object, void *argv, u32 argc,
}
static int
nvkm_udevice_fini(struct nvkm_object *object, bool suspend)
nvkm_udevice_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
struct nvkm_udevice *udev = nvkm_udevice(object);
struct nvkm_device *device = udev->device;

4
drivers/gpu/drm/nouveau/nvkm/engine/disp/base.c
View File

@ -99,13 +99,13 @@ nvkm_disp_intr(struct nvkm_engine *engine)
}
static int
nvkm_disp_fini(struct nvkm_engine *engine, bool suspend)
nvkm_disp_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend)
{
struct nvkm_disp *disp = nvkm_disp(engine);
struct nvkm_outp *outp;
if (disp->func->fini)
disp->func->fini(disp, suspend);
disp->func->fini(disp, suspend != NVKM_POWEROFF);
list_for_each_entry(outp, &disp->outps, head) {
if (outp->func->fini)

2
drivers/gpu/drm/nouveau/nvkm/engine/disp/chan.c
View File

@ -128,7 +128,7 @@ nvkm_disp_chan_child_get(struct nvkm_object *object, int index, struct nvkm_ocla
}
static int
nvkm_disp_chan_fini(struct nvkm_object *object, bool suspend)
nvkm_disp_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
struct nvkm_disp_chan *chan = nvkm_disp_chan(object);

4
drivers/gpu/drm/nouveau/nvkm/engine/falcon.c
View File

@ -93,13 +93,13 @@ nvkm_falcon_intr(struct nvkm_engine *engine)
}
static int
nvkm_falcon_fini(struct nvkm_engine *engine, bool suspend)
nvkm_falcon_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend)
{
struct nvkm_falcon *falcon = nvkm_falcon(engine);
struct nvkm_device *device = falcon->engine.subdev.device;
const u32 base = falcon->addr;
if (!suspend) {
if (suspend == NVKM_POWEROFF) {
nvkm_memory_unref(&falcon->core);
if (falcon->external) {
vfree(falcon->data.data);

2
drivers/gpu/drm/nouveau/nvkm/engine/fifo/base.c
View File

@ -122,7 +122,7 @@ nvkm_fifo_class_get(struct nvkm_oclass *oclass, int index, const struct nvkm_dev
}
static int
nvkm_fifo_fini(struct nvkm_engine *engine, bool suspend)
nvkm_fifo_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend)
{
struct nvkm_fifo *fifo = nvkm_fifo(engine);
struct nvkm_runl *runl;

6
drivers/gpu/drm/nouveau/nvkm/engine/fifo/uchan.c
View File

@ -72,7 +72,7 @@ struct nvkm_uobj {
};
static int
nvkm_uchan_object_fini_1(struct nvkm_oproxy *oproxy, bool suspend)
nvkm_uchan_object_fini_1(struct nvkm_oproxy *oproxy, enum nvkm_suspend_state suspend)
{
struct nvkm_uobj *uobj = container_of(oproxy, typeof(*uobj), oproxy);
struct nvkm_chan *chan = uobj->chan;
@ -87,7 +87,7 @@ nvkm_uchan_object_fini_1(struct nvkm_oproxy *oproxy, bool suspend)
nvkm_chan_cctx_bind(chan, ectx->engn, NULL);
if (refcount_dec_and_test(&ectx->uses))
nvkm_object_fini(ectx->object, false);
nvkm_object_fini(ectx->object, NVKM_POWEROFF);
mutex_unlock(&chan->cgrp->mutex);
}
@ -269,7 +269,7 @@ nvkm_uchan_map(struct nvkm_object *object, void *argv, u32 argc,
}
static int
nvkm_uchan_fini(struct nvkm_object *object, bool suspend)
nvkm_uchan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
struct nvkm_chan *chan = nvkm_uchan(object)->chan;

4
drivers/gpu/drm/nouveau/nvkm/engine/gr/base.c
View File

@ -168,11 +168,11 @@ nvkm_gr_init(struct nvkm_engine *engine)
}
static int
nvkm_gr_fini(struct nvkm_engine *engine, bool suspend)
nvkm_gr_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend)
{
struct nvkm_gr *gr = nvkm_gr(engine);
if (gr->func->fini)
return gr->func->fini(gr, suspend);
return gr->func->fini(gr, suspend != NVKM_POWEROFF);
return 0;
}

2
drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.c
View File

@ -2330,7 +2330,7 @@ gf100_gr_reset(struct nvkm_gr *base)
WARN_ON(gf100_gr_fecs_halt_pipeline(gr));
subdev->func->fini(subdev, false);
subdev->func->fini(subdev, NVKM_POWEROFF);
nvkm_mc_disable(device, subdev->type, subdev->inst);
if (gr->func->gpccs.reset)
gr->func->gpccs.reset(gr);

2
drivers/gpu/drm/nouveau/nvkm/engine/gr/nv04.c
View File

@ -1158,7 +1158,7 @@ nv04_gr_chan_dtor(struct nvkm_object *object)
}
static int
nv04_gr_chan_fini(struct nvkm_object *object, bool suspend)
nv04_gr_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
struct nv04_gr_chan *chan = nv04_gr_chan(object);
struct nv04_gr *gr = chan->gr;

2
drivers/gpu/drm/nouveau/nvkm/engine/gr/nv10.c
View File

@ -951,7 +951,7 @@ nv10_gr_context_switch(struct nv10_gr *gr)
}
static int
nv10_gr_chan_fini(struct nvkm_object *object, bool suspend)
nv10_gr_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
struct nv10_gr_chan *chan = nv10_gr_chan(object);
struct nv10_gr *gr = chan->gr;

2
drivers/gpu/drm/nouveau/nvkm/engine/gr/nv20.c
View File

@ -27,7 +27,7 @@ nv20_gr_chan_init(struct nvkm_object *object)
}
int
nv20_gr_chan_fini(struct nvkm_object *object, bool suspend)
nv20_gr_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
struct nv20_gr_chan *chan = nv20_gr_chan(object);
struct nv20_gr *gr = chan->gr;

2
drivers/gpu/drm/nouveau/nvkm/engine/gr/nv20.h
View File

@ -31,5 +31,5 @@ struct nv20_gr_chan {
void *nv20_gr_chan_dtor(struct nvkm_object *);
int nv20_gr_chan_init(struct nvkm_object *);
int nv20_gr_chan_fini(struct nvkm_object *, bool);
int nv20_gr_chan_fini(struct nvkm_object *, enum nvkm_suspend_state);
#endif

4
drivers/gpu/drm/nouveau/nvkm/engine/gr/nv40.c
View File

@ -89,7 +89,7 @@ nv40_gr_chan_bind(struct nvkm_object *object, struct nvkm_gpuobj *parent,
}
static int
nv40_gr_chan_fini(struct nvkm_object *object, bool suspend)
nv40_gr_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
struct nv40_gr_chan *chan = nv40_gr_chan(object);
struct nv40_gr *gr = chan->gr;
@ -101,7 +101,7 @@ nv40_gr_chan_fini(struct nvkm_object *object, bool suspend)
nvkm_mask(device, 0x400720, 0x00000001, 0x00000000);
if (nvkm_rd32(device, 0x40032c) == inst) {
if (suspend) {
if (suspend != NVKM_POWEROFF) {
nvkm_wr32(device, 0x400720, 0x00000000);
nvkm_wr32(device, 0x400784, inst);
nvkm_mask(device, 0x400310, 0x00000020, 0x00000020);

2
drivers/gpu/drm/nouveau/nvkm/engine/mpeg/nv44.c
View File

@ -65,7 +65,7 @@ nv44_mpeg_chan_bind(struct nvkm_object *object, struct nvkm_gpuobj *parent,
}
static int
nv44_mpeg_chan_fini(struct nvkm_object *object, bool suspend)
nv44_mpeg_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
struct nv44_mpeg_chan *chan = nv44_mpeg_chan(object);

2
drivers/gpu/drm/nouveau/nvkm/engine/sec2/base.c
View File

@ -37,7 +37,7 @@ nvkm_sec2_finimsg(void *priv, struct nvfw_falcon_msg *hdr)
}
static int
nvkm_sec2_fini(struct nvkm_engine *engine, bool suspend)
nvkm_sec2_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend)
{
struct nvkm_sec2 *sec2 = nvkm_sec2(engine);
struct nvkm_subdev *subdev = &sec2->engine.subdev;

4
drivers/gpu/drm/nouveau/nvkm/engine/xtensa.c
View File

@ -76,7 +76,7 @@ nvkm_xtensa_intr(struct nvkm_engine *engine)
}
static int
nvkm_xtensa_fini(struct nvkm_engine *engine, bool suspend)
nvkm_xtensa_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend)
{
struct nvkm_xtensa *xtensa = nvkm_xtensa(engine);
struct nvkm_device *device = xtensa->engine.subdev.device;
@ -85,7 +85,7 @@ nvkm_xtensa_fini(struct nvkm_engine *engine, bool suspend)
nvkm_wr32(device, base + 0xd84, 0); /* INTR_EN */
nvkm_wr32(device, base + 0xd94, 0); /* FIFO_CTRL */
if (!suspend)
if (suspend == NVKM_POWEROFF)
nvkm_memory_unref(&xtensa->gpu_fw);
return 0;
}

2
drivers/gpu/drm/nouveau/nvkm/subdev/acr/base.c
View File

@ -182,7 +182,7 @@ nvkm_acr_managed_falcon(struct nvkm_device *device, enum nvkm_acr_lsf_id id)
}
static int
nvkm_acr_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_acr_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
if (!subdev->use.enabled)
return 0;

2
drivers/gpu/drm/nouveau/nvkm/subdev/bar/base.c
View File

@ -90,7 +90,7 @@ nvkm_bar_bar2_init(struct nvkm_device *device)
}
static int
nvkm_bar_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_bar_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_bar *bar = nvkm_bar(subdev);

2
drivers/gpu/drm/nouveau/nvkm/subdev/clk/base.c
View File

@ -577,7 +577,7 @@ nvkm_clk_read(struct nvkm_clk *clk, enum nv_clk_src src)
}
static int
nvkm_clk_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_clk_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_clk *clk = nvkm_clk(subdev);
flush_work(&clk->work);

4
drivers/gpu/drm/nouveau/nvkm/subdev/devinit/base.c
View File

@ -67,11 +67,11 @@ nvkm_devinit_post(struct nvkm_devinit *init)
}
static int
nvkm_devinit_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_devinit_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_devinit *init = nvkm_devinit(subdev);
/* force full reinit on resume */
if (suspend)
if (suspend != NVKM_POWEROFF)
init->post = true;
return 0;
}

2
drivers/gpu/drm/nouveau/nvkm/subdev/fault/base.c
View File

@ -51,7 +51,7 @@ nvkm_fault_intr(struct nvkm_subdev *subdev)
}
static int
nvkm_fault_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_fault_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_fault *fault = nvkm_fault(subdev);
if (fault->func->fini)

2
drivers/gpu/drm/nouveau/nvkm/subdev/fault/user.c
View File

@ -56,7 +56,7 @@ nvkm_ufault_map(struct nvkm_object *object, void *argv, u32 argc,
}
static int
nvkm_ufault_fini(struct nvkm_object *object, bool suspend)
nvkm_ufault_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend)
{
struct nvkm_fault_buffer *buffer = nvkm_fault_buffer(object);
buffer->fault->func->buffer.fini(buffer);

2
drivers/gpu/drm/nouveau/nvkm/subdev/gpio/base.c
View File

@ -144,7 +144,7 @@ nvkm_gpio_intr(struct nvkm_subdev *subdev)
}
static int
nvkm_gpio_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_gpio_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_gpio *gpio = nvkm_gpio(subdev);
u32 mask = (1ULL << gpio->func->lines) - 1;

2
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/base.c
View File

@ -48,7 +48,7 @@ nvkm_gsp_intr_stall(struct nvkm_gsp *gsp, enum nvkm_subdev_type type, int inst)
}
static int
nvkm_gsp_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_gsp_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_gsp *gsp = nvkm_gsp(subdev);

2
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/gh100.c
View File

@ -17,7 +17,7 @@
#include <nvhw/ref/gh100/dev_riscv_pri.h>
int
gh100_gsp_fini(struct nvkm_gsp *gsp, bool suspend)
gh100_gsp_fini(struct nvkm_gsp *gsp, enum nvkm_suspend_state suspend)
{
struct nvkm_falcon *falcon = &gsp->falcon;
int ret, time = 4000;

8
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/priv.h
View File

@ -59,7 +59,7 @@ struct nvkm_gsp_func {
void (*dtor)(struct nvkm_gsp *);
int (*oneinit)(struct nvkm_gsp *);
int (*init)(struct nvkm_gsp *);
int (*fini)(struct nvkm_gsp *, bool suspend);
int (*fini)(struct nvkm_gsp *, enum nvkm_suspend_state suspend);
int (*reset)(struct nvkm_gsp *);
struct {
@ -75,7 +75,7 @@ int tu102_gsp_fwsec_sb_ctor(struct nvkm_gsp *);
void tu102_gsp_fwsec_sb_dtor(struct nvkm_gsp *);
int tu102_gsp_oneinit(struct nvkm_gsp *);
int tu102_gsp_init(struct nvkm_gsp *);
int tu102_gsp_fini(struct nvkm_gsp *, bool suspend);
int tu102_gsp_fini(struct nvkm_gsp *, enum nvkm_suspend_state suspend);
int tu102_gsp_reset(struct nvkm_gsp *);
u64 tu102_gsp_wpr_heap_size(struct nvkm_gsp *);
@ -87,12 +87,12 @@ int ga102_gsp_reset(struct nvkm_gsp *);
int gh100_gsp_oneinit(struct nvkm_gsp *);
int gh100_gsp_init(struct nvkm_gsp *);
int gh100_gsp_fini(struct nvkm_gsp *, bool suspend);
int gh100_gsp_fini(struct nvkm_gsp *, enum nvkm_suspend_state suspend);
void r535_gsp_dtor(struct nvkm_gsp *);
int r535_gsp_oneinit(struct nvkm_gsp *);
int r535_gsp_init(struct nvkm_gsp *);
int r535_gsp_fini(struct nvkm_gsp *, bool suspend);
int r535_gsp_fini(struct nvkm_gsp *, enum nvkm_suspend_state suspend);
int nvkm_gsp_new_(const struct nvkm_gsp_fwif *, struct nvkm_device *, enum nvkm_subdev_type, int,
struct nvkm_gsp **);

2
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/fbsr.c
View File

@ -208,7 +208,7 @@ r535_fbsr_resume(struct nvkm_gsp *gsp)
}
static int
r535_fbsr_suspend(struct nvkm_gsp *gsp)
r535_fbsr_suspend(struct nvkm_gsp *gsp, bool runtime)
{
struct nvkm_subdev *subdev = &gsp->subdev;
struct nvkm_device *device = subdev->device;

8
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c
View File

@ -704,7 +704,7 @@ r535_gsp_rpc_set_registry(struct nvkm_gsp *gsp)
build_registry(gsp, rpc);
return nvkm_gsp_rpc_wr(gsp, rpc, NVKM_GSP_RPC_REPLY_NOWAIT);
return nvkm_gsp_rpc_wr(gsp, rpc, NVKM_GSP_RPC_REPLY_NOSEQ);
fail:
clean_registry(gsp);
@ -921,7 +921,7 @@ r535_gsp_set_system_info(struct nvkm_gsp *gsp)
info->pciConfigMirrorSize = device->pci->func->cfg.size;
r535_gsp_acpi_info(gsp, &info->acpiMethodData);
return nvkm_gsp_rpc_wr(gsp, info, NVKM_GSP_RPC_REPLY_NOWAIT);
return nvkm_gsp_rpc_wr(gsp, info, NVKM_GSP_RPC_REPLY_NOSEQ);
}
static int
@ -1721,7 +1721,7 @@ r535_gsp_sr_data_size(struct nvkm_gsp *gsp)
}
int
r535_gsp_fini(struct nvkm_gsp *gsp, bool suspend)
r535_gsp_fini(struct nvkm_gsp *gsp, enum nvkm_suspend_state suspend)
{
struct nvkm_rm *rm = gsp->rm;
int ret;
@ -1748,7 +1748,7 @@ r535_gsp_fini(struct nvkm_gsp *gsp, bool suspend)
sr->sysmemAddrOfSuspendResumeData = gsp->sr.radix3.lvl0.addr;
sr->sizeOfSuspendResumeData = len;
ret = rm->api->fbsr->suspend(gsp);
ret = rm->api->fbsr->suspend(gsp, suspend == NVKM_RUNTIME_SUSPEND);
if (ret) {
nvkm_gsp_mem_dtor(&gsp->sr.meta);
nvkm_gsp_radix3_dtor(gsp, &gsp->sr.radix3);

6
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/rpc.c
View File

@ -557,6 +557,7 @@ r535_gsp_rpc_handle_reply(struct nvkm_gsp *gsp, u32 fn,
switch (policy) {
case NVKM_GSP_RPC_REPLY_NOWAIT:
case NVKM_GSP_RPC_REPLY_NOSEQ:
break;
case NVKM_GSP_RPC_REPLY_RECV:
reply = r535_gsp_msg_recv(gsp, fn, gsp_rpc_len);
@ -588,6 +589,11 @@ r535_gsp_rpc_send(struct nvkm_gsp *gsp, void *payload,
rpc->data, rpc->length - sizeof(*rpc), true);
}
if (policy == NVKM_GSP_RPC_REPLY_NOSEQ)
rpc->sequence = 0;
else
rpc->sequence = gsp->rpc_seq++;
ret = r535_gsp_cmdq_push(gsp, rpc);
if (ret)
return ERR_PTR(ret);

8
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r570/fbsr.c
View File

@ -62,7 +62,7 @@ r570_fbsr_resume(struct nvkm_gsp *gsp)
}
static int
r570_fbsr_init(struct nvkm_gsp *gsp, struct sg_table *sgt, u64 size)
r570_fbsr_init(struct nvkm_gsp *gsp, struct sg_table *sgt, u64 size, bool runtime)
{
NV2080_CTRL_INTERNAL_FBSR_INIT_PARAMS *ctrl;
struct nvkm_gsp_object memlist;
@ -81,7 +81,7 @@ r570_fbsr_init(struct nvkm_gsp *gsp, struct sg_table *sgt, u64 size)
ctrl->hClient = gsp->internal.client.object.handle;
ctrl->hSysMem = memlist.handle;
ctrl->sysmemAddrOfSuspendResumeData = gsp->sr.meta.addr;
ctrl->bEnteringGcoffState = 1;
ctrl->bEnteringGcoffState = runtime ? 1 : 0;
ret = nvkm_gsp_rm_ctrl_wr(&gsp->internal.device.subdevice, ctrl);
if (ret)
@ -92,7 +92,7 @@ r570_fbsr_init(struct nvkm_gsp *gsp, struct sg_table *sgt, u64 size)
}
static int
r570_fbsr_suspend(struct nvkm_gsp *gsp)
r570_fbsr_suspend(struct nvkm_gsp *gsp, bool runtime)
{
struct nvkm_subdev *subdev = &gsp->subdev;
struct nvkm_device *device = subdev->device;
@ -133,7 +133,7 @@ r570_fbsr_suspend(struct nvkm_gsp *gsp)
return ret;
/* Initialise FBSR on RM. */
ret = r570_fbsr_init(gsp, &gsp->sr.fbsr, size);
ret = r570_fbsr_init(gsp, &gsp->sr.fbsr, size, runtime);
if (ret) {
nvkm_gsp_sg_free(device, &gsp->sr.fbsr);
return ret;

2
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r570/gsp.c
View File

@ -176,7 +176,7 @@ r570_gsp_set_system_info(struct nvkm_gsp *gsp)
info->bIsPrimary = video_is_primary_device(device->dev);
info->bPreserveVideoMemoryAllocations = false;
return nvkm_gsp_rpc_wr(gsp, info, NVKM_GSP_RPC_REPLY_NOWAIT);
return nvkm_gsp_rpc_wr(gsp, info, NVKM_GSP_RPC_REPLY_NOSEQ);
}
static void

2
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/rm.h
View File

@ -78,7 +78,7 @@ struct nvkm_rm_api {
} *device;
const struct nvkm_rm_api_fbsr {
int (*suspend)(struct nvkm_gsp *);
int (*suspend)(struct nvkm_gsp *, bool runtime);
void (*resume)(struct nvkm_gsp *);
} *fbsr;

2
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/tu102.c
View File

@ -161,7 +161,7 @@ tu102_gsp_reset(struct nvkm_gsp *gsp)
}
int
tu102_gsp_fini(struct nvkm_gsp *gsp, bool suspend)
tu102_gsp_fini(struct nvkm_gsp *gsp, enum nvkm_suspend_state suspend)
{
u32 mbox0 = 0xff, mbox1 = 0xff;
int ret;

2
drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c
View File

@ -135,7 +135,7 @@ nvkm_i2c_intr(struct nvkm_subdev *subdev)
}
static int
nvkm_i2c_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_i2c_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_i2c *i2c = nvkm_i2c(subdev);
struct nvkm_i2c_pad *pad;

2
drivers/gpu/drm/nouveau/nvkm/subdev/instmem/base.c
View File

@ -176,7 +176,7 @@ nvkm_instmem_boot(struct nvkm_instmem *imem)
}
static int
nvkm_instmem_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_instmem_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_instmem *imem = nvkm_instmem(subdev);
int ret;

2
drivers/gpu/drm/nouveau/nvkm/subdev/pci/base.c
View File

@ -74,7 +74,7 @@ nvkm_pci_rom_shadow(struct nvkm_pci *pci, bool shadow)
}
static int
nvkm_pci_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_pci_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_pci *pci = nvkm_pci(subdev);

2
drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c
View File

@ -77,7 +77,7 @@ nvkm_pmu_intr(struct nvkm_subdev *subdev)
}
static int
nvkm_pmu_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_pmu_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_pmu *pmu = nvkm_pmu(subdev);

6
drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c
View File

@ -341,15 +341,15 @@ nvkm_therm_intr(struct nvkm_subdev *subdev)
}
static int
nvkm_therm_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_therm_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_therm *therm = nvkm_therm(subdev);
if (therm->func->fini)
therm->func->fini(therm);
nvkm_therm_fan_fini(therm, suspend);
nvkm_therm_sensor_fini(therm, suspend);
nvkm_therm_fan_fini(therm, suspend != NVKM_POWEROFF);
nvkm_therm_sensor_fini(therm, suspend != NVKM_POWEROFF);
if (suspend) {
therm->suspend = therm->mode;

2
drivers/gpu/drm/nouveau/nvkm/subdev/timer/base.c
View File

@ -149,7 +149,7 @@ nvkm_timer_intr(struct nvkm_subdev *subdev)
}
static int
nvkm_timer_fini(struct nvkm_subdev *subdev, bool suspend)
nvkm_timer_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend)
{
struct nvkm_timer *tmr = nvkm_timer(subdev);
tmr->func->alarm_fini(tmr);