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

nouveau: add a third state to the fini handler.

Browse Source 
This is just refactoring to allow the lower layers to distinguish
between suspend and runtime suspend.

GSP 570 needs to set a flag with the GPU is going into GCOFF,
this flag taken from the opengpu driver is set whenever runtime
suspend is enterning GCOFF but not for normal suspend paths.

This just refactors the code, a subsequent patch use the information.

Fixes: 53dac06238 ("drm/nouveau/gsp: add support for 570.144")
Cc: <stable@vger.kernel.org>
Reviewed-by: Lyude Paul <lyude@redhat.com>
Tested-by: Lyude Paul <lyude@redhat.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
Link: https://patch.msgid.link/20260203052431.2219998-3-airlied@gmail.com
This commit is contained in:
Dave Airlie 2026-02-03 15:21:12 +10:00
parent 90caca3b72
commit 8f8a4dce64
56 changed files with 139 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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/gsp.c
View File

@ -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;

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);