nouveau: add a third state to the fini handler.

tjh.dev / kernel

fork atom

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

fork atom

nouveau: add a third state to the fini handler.

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: 53dac0623853 ("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

Dave Airlie 2 months ago 8f8a4dce 90caca3b

+139 -84

56 changed files

expand all collapse all

drivers

gpu

drm

nouveau

include

nvif

client.h

driver.h

nvkm

core

device.h

engine.h

object.h

oproxy.h

subdev.h

suspend_state.h

nouveau_drm.c

nouveau_nvif.c

nvif

client.c

nvkm

core

engine.c

ioctl.c

object.c

oproxy.c

subdev.c

uevent.c

engine

ga100.c

priv.h

device

base.c

pci.c

priv.h

user.c

disp

base.c

chan.c

falcon.c

fifo

base.c

uchan.c

base.c

gf100.c

nv04.c

nv10.c

nv20.c

nv20.h

nv40.c

mpeg

nv44.c

sec2

base.c

xtensa.c

subdev

acr

base.c

bar

base.c

clk

base.c

devinit

base.c

fault

base.c

user.c

gpio

base.c

gsp

base.c

gh100.c

priv.h

r535

gsp.c

tu102.c

i2c

base.c

instmem

base.c

pci

base.c

pmu

base.c

therm

base.c

timer

base.c

+1 -1

drivers/gpu/drm/nouveau/include/nvif/client.h

reviewed

··· 11 11 12 12 int nvif_client_ctor(struct nvif_client *parent, const char *name, struct nvif_client *); 13 13 void nvif_client_dtor(struct nvif_client *); 14 14 - int nvif_client_suspend(struct nvif_client *); 14 14 + int nvif_client_suspend(struct nvif_client *, bool); 15 15 int nvif_client_resume(struct nvif_client *); 16 16 17 17 /*XXX*/

+1 -1

drivers/gpu/drm/nouveau/include/nvif/driver.h

reviewed

··· 8 8 const char *name; 9 9 int (*init)(const char *name, u64 device, const char *cfg, 10 10 const char *dbg, void **priv); 11 11 - int (*suspend)(void *priv); 11 11 + int (*suspend)(void *priv, bool runtime); 12 12 int (*resume)(void *priv); 13 13 int (*ioctl)(void *priv, void *data, u32 size, void **hack); 14 14 void __iomem *(*map)(void *priv, u64 handle, u32 size);

+2 -1

drivers/gpu/drm/nouveau/include/nvkm/core/device.h

reviewed

··· 2 2 #ifndef __NVKM_DEVICE_H__ 3 3 #define __NVKM_DEVICE_H__ 4 4 #include <core/oclass.h> 5 5 + #include <core/suspend_state.h> 5 6 #include <core/intr.h> 6 7 enum nvkm_subdev_type; 7 8 ··· 94 93 void *(*dtor)(struct nvkm_device *); 95 94 int (*preinit)(struct nvkm_device *); 96 95 int (*init)(struct nvkm_device *); 97 97 - void (*fini)(struct nvkm_device *, bool suspend); 96 96 + void (*fini)(struct nvkm_device *, enum nvkm_suspend_state suspend); 98 97 int (*irq)(struct nvkm_device *); 99 98 resource_size_t (*resource_addr)(struct nvkm_device *, enum nvkm_bar_id); 100 99 resource_size_t (*resource_size)(struct nvkm_device *, enum nvkm_bar_id);

+1 -1

drivers/gpu/drm/nouveau/include/nvkm/core/engine.h

reviewed

··· 20 20 int (*oneinit)(struct nvkm_engine *); 21 21 int (*info)(struct nvkm_engine *, u64 mthd, u64 *data); 22 22 int (*init)(struct nvkm_engine *); 23 23 - int (*fini)(struct nvkm_engine *, bool suspend); 23 23 + int (*fini)(struct nvkm_engine *, enum nvkm_suspend_state suspend); 24 24 int (*reset)(struct nvkm_engine *); 25 25 int (*nonstall)(struct nvkm_engine *); 26 26 void (*intr)(struct nvkm_engine *);

+3 -2

drivers/gpu/drm/nouveau/include/nvkm/core/object.h

reviewed

··· 2 2 #ifndef __NVKM_OBJECT_H__ 3 3 #define __NVKM_OBJECT_H__ 4 4 #include <core/oclass.h> 5 5 + #include <core/suspend_state.h> 5 6 struct nvkm_event; 6 7 struct nvkm_gpuobj; 7 8 struct nvkm_uevent; ··· 28 27 struct nvkm_object_func { 29 28 void *(*dtor)(struct nvkm_object *); 30 29 int (*init)(struct nvkm_object *); 31 31 - int (*fini)(struct nvkm_object *, bool suspend); 30 30 + int (*fini)(struct nvkm_object *, enum nvkm_suspend_state suspend); 32 31 int (*mthd)(struct nvkm_object *, u32 mthd, void *data, u32 size); 33 32 int (*ntfy)(struct nvkm_object *, u32 mthd, struct nvkm_event **); 34 33 int (*map)(struct nvkm_object *, void *argv, u32 argc, ··· 50 49 void nvkm_object_del(struct nvkm_object **); 51 50 void *nvkm_object_dtor(struct nvkm_object *); 52 51 int nvkm_object_init(struct nvkm_object *); 53 53 - int nvkm_object_fini(struct nvkm_object *, bool suspend); 52 52 + int nvkm_object_fini(struct nvkm_object *, enum nvkm_suspend_state); 54 53 int nvkm_object_mthd(struct nvkm_object *, u32 mthd, void *data, u32 size); 55 54 int nvkm_object_ntfy(struct nvkm_object *, u32 mthd, struct nvkm_event **); 56 55 int nvkm_object_map(struct nvkm_object *, void *argv, u32 argc,

+1 -1

drivers/gpu/drm/nouveau/include/nvkm/core/oproxy.h

reviewed

··· 13 13 struct nvkm_oproxy_func { 14 14 void (*dtor[2])(struct nvkm_oproxy *); 15 15 int (*init[2])(struct nvkm_oproxy *); 16 16 - int (*fini[2])(struct nvkm_oproxy *, bool suspend); 16 16 + int (*fini[2])(struct nvkm_oproxy *, enum nvkm_suspend_state suspend); 17 17 }; 18 18 19 19 void nvkm_oproxy_ctor(const struct nvkm_oproxy_func *,

+2 -2

drivers/gpu/drm/nouveau/include/nvkm/core/subdev.h

reviewed

··· 40 40 int (*oneinit)(struct nvkm_subdev *); 41 41 int (*info)(struct nvkm_subdev *, u64 mthd, u64 *data); 42 42 int (*init)(struct nvkm_subdev *); 43 43 - int (*fini)(struct nvkm_subdev *, bool suspend); 43 43 + int (*fini)(struct nvkm_subdev *, enum nvkm_suspend_state suspend); 44 44 void (*intr)(struct nvkm_subdev *); 45 45 }; 46 46 ··· 65 65 int nvkm_subdev_preinit(struct nvkm_subdev *); 66 66 int nvkm_subdev_oneinit(struct nvkm_subdev *); 67 67 int nvkm_subdev_init(struct nvkm_subdev *); 68 68 - int nvkm_subdev_fini(struct nvkm_subdev *, bool suspend); 68 68 + int nvkm_subdev_fini(struct nvkm_subdev *, enum nvkm_suspend_state suspend); 69 69 int nvkm_subdev_info(struct nvkm_subdev *, u64, u64 *); 70 70 void nvkm_subdev_intr(struct nvkm_subdev *); 71 71

+11

drivers/gpu/drm/nouveau/include/nvkm/core/suspend_state.h

reviewed

··· 1 1 + /* SPDX-License-Identifier: MIT */ 2 2 + #ifndef __NVKM_SUSPEND_STATE_H__ 3 3 + #define __NVKM_SUSPEND_STATE_H__ 4 4 + 5 5 + enum nvkm_suspend_state { 6 6 + NVKM_POWEROFF, 7 7 + NVKM_SUSPEND, 8 8 + NVKM_RUNTIME_SUSPEND, 9 9 + }; 10 10 + 11 11 + #endif

+1 -1

drivers/gpu/drm/nouveau/nouveau_drm.c

reviewed

··· 983 983 } 984 984 985 985 NV_DEBUG(drm, "suspending object tree...\n"); 986 986 - ret = nvif_client_suspend(&drm->_client); 986 986 + ret = nvif_client_suspend(&drm->_client, runtime); 987 987 if (ret) 988 988 goto fail_client; 989 989

+8 -2

drivers/gpu/drm/nouveau/nouveau_nvif.c

reviewed

··· 62 62 } 63 63 64 64 static int 65 65 - nvkm_client_suspend(void *priv) 65 65 + nvkm_client_suspend(void *priv, bool runtime) 66 66 { 67 67 struct nvkm_client *client = priv; 68 68 - return nvkm_object_fini(&client->object, true); 68 68 + enum nvkm_suspend_state state; 69 69 + 70 70 + if (runtime) 71 71 + state = NVKM_RUNTIME_SUSPEND; 72 72 + else 73 73 + state = NVKM_SUSPEND; 74 74 + return nvkm_object_fini(&client->object, state); 69 75 } 70 76 71 77 static int

+2 -2

drivers/gpu/drm/nouveau/nvif/client.c

reviewed

··· 30 30 #include <nvif/if0000.h> 31 31 32 32 int 33 33 - nvif_client_suspend(struct nvif_client *client) 33 33 + nvif_client_suspend(struct nvif_client *client, bool runtime) 34 34 { 35 35 - return client->driver->suspend(client->object.priv); 35 35 + return client->driver->suspend(client->object.priv, runtime); 36 36 } 37 37 38 38 int

+2 -2

drivers/gpu/drm/nouveau/nvkm/core/engine.c

reviewed

··· 41 41 if (engine->func->reset) 42 42 return engine->func->reset(engine); 43 43 44 44 - nvkm_subdev_fini(&engine->subdev, false); 44 44 + nvkm_subdev_fini(&engine->subdev, NVKM_POWEROFF); 45 45 return nvkm_subdev_init(&engine->subdev); 46 46 } 47 47 ··· 98 98 } 99 99 100 100 static int 101 101 - nvkm_engine_fini(struct nvkm_subdev *subdev, bool suspend) 101 101 + nvkm_engine_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 102 102 { 103 103 struct nvkm_engine *engine = nvkm_engine(subdev); 104 104 if (engine->func->fini)

+2 -2

drivers/gpu/drm/nouveau/nvkm/core/ioctl.c

reviewed

··· 141 141 } 142 142 ret = -EEXIST; 143 143 } 144 144 - nvkm_object_fini(object, false); 144 144 + nvkm_object_fini(object, NVKM_POWEROFF); 145 145 } 146 146 147 147 nvkm_object_del(&object); ··· 160 160 nvif_ioctl(object, "delete size %d\n", size); 161 161 if (!(ret = nvif_unvers(ret, &data, &size, args->none))) { 162 162 nvif_ioctl(object, "delete\n"); 163 163 - nvkm_object_fini(object, false); 163 163 + nvkm_object_fini(object, NVKM_POWEROFF); 164 164 nvkm_object_del(&object); 165 165 } 166 166

+16 -4

drivers/gpu/drm/nouveau/nvkm/core/object.c

reviewed

··· 142 142 } 143 143 144 144 int 145 145 - nvkm_object_fini(struct nvkm_object *object, bool suspend) 145 145 + nvkm_object_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 146 146 { 147 147 - const char *action = suspend ? "suspend" : "fini"; 147 147 + const char *action; 148 148 struct nvkm_object *child; 149 149 s64 time; 150 150 int ret; 151 151 152 152 + switch (suspend) { 153 153 + case NVKM_POWEROFF: 154 154 + default: 155 155 + action = "fini"; 156 156 + break; 157 157 + case NVKM_SUSPEND: 158 158 + action = "suspend"; 159 159 + break; 160 160 + case NVKM_RUNTIME_SUSPEND: 161 161 + action = "runtime"; 162 162 + break; 163 163 + } 152 164 nvif_debug(object, "%s children...\n", action); 153 165 time = ktime_to_us(ktime_get()); 154 166 list_for_each_entry_reverse(child, &object->tree, head) { ··· 224 212 225 213 fail_child: 226 214 list_for_each_entry_continue_reverse(child, &object->tree, head) 227 227 - nvkm_object_fini(child, false); 215 215 + nvkm_object_fini(child, NVKM_POWEROFF); 228 216 fail: 229 217 nvif_error(object, "init failed with %d\n", ret); 230 218 if (object->func->fini) 231 231 - object->func->fini(object, false); 219 219 + object->func->fini(object, NVKM_POWEROFF); 232 220 return ret; 233 221 } 234 222

+1 -1

drivers/gpu/drm/nouveau/nvkm/core/oproxy.c

reviewed

··· 87 87 } 88 88 89 89 static int 90 90 - nvkm_oproxy_fini(struct nvkm_object *object, bool suspend) 90 90 + nvkm_oproxy_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 91 91 { 92 92 struct nvkm_oproxy *oproxy = nvkm_oproxy(object); 93 93 int ret;

+15 -3

drivers/gpu/drm/nouveau/nvkm/core/subdev.c

reviewed

··· 51 51 } 52 52 53 53 int 54 54 - nvkm_subdev_fini(struct nvkm_subdev *subdev, bool suspend) 54 54 + nvkm_subdev_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 55 55 { 56 56 struct nvkm_device *device = subdev->device; 57 57 - const char *action = suspend ? "suspend" : subdev->use.enabled ? "fini" : "reset"; 57 57 + const char *action; 58 58 s64 time; 59 59 60 60 + switch (suspend) { 61 61 + case NVKM_POWEROFF: 62 62 + default: 63 63 + action = subdev->use.enabled ? "fini" : "reset"; 64 64 + break; 65 65 + case NVKM_SUSPEND: 66 66 + action = "suspend"; 67 67 + break; 68 68 + case NVKM_RUNTIME_SUSPEND: 69 69 + action = "runtime"; 70 70 + break; 71 71 + } 60 72 nvkm_trace(subdev, "%s running...\n", action); 61 73 time = ktime_to_us(ktime_get()); 62 74 ··· 198 186 nvkm_subdev_unref(struct nvkm_subdev *subdev) 199 187 { 200 188 if (refcount_dec_and_mutex_lock(&subdev->use.refcount, &subdev->use.mutex)) { 201 201 - nvkm_subdev_fini(subdev, false); 189 189 + nvkm_subdev_fini(subdev, NVKM_POWEROFF); 202 190 mutex_unlock(&subdev->use.mutex); 203 191 } 204 192 }

+1 -1

drivers/gpu/drm/nouveau/nvkm/core/uevent.c

reviewed

··· 73 73 } 74 74 75 75 static int 76 76 - nvkm_uevent_fini(struct nvkm_object *object, bool suspend) 76 76 + nvkm_uevent_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 77 77 { 78 78 struct nvkm_uevent *uevent = nvkm_uevent(object); 79 79

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/ce/ga100.c

reviewed

··· 46 46 } 47 47 48 48 int 49 49 - ga100_ce_fini(struct nvkm_engine *engine, bool suspend) 49 49 + ga100_ce_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend) 50 50 { 51 51 nvkm_inth_block(&engine->subdev.inth); 52 52 return 0;

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/ce/priv.h

reviewed

··· 14 14 15 15 int ga100_ce_oneinit(struct nvkm_engine *); 16 16 int ga100_ce_init(struct nvkm_engine *); 17 17 - int ga100_ce_fini(struct nvkm_engine *, bool); 17 17 + int ga100_ce_fini(struct nvkm_engine *, enum nvkm_suspend_state); 18 18 int ga100_ce_nonstall(struct nvkm_engine *); 19 19 20 20 u32 gb202_ce_grce_mask(struct nvkm_device *);

+17 -5

drivers/gpu/drm/nouveau/nvkm/engine/device/base.c

reviewed

··· 2936 2936 } 2937 2937 2938 2938 int 2939 2939 - nvkm_device_fini(struct nvkm_device *device, bool suspend) 2939 2939 + nvkm_device_fini(struct nvkm_device *device, enum nvkm_suspend_state suspend) 2940 2940 { 2941 2941 - const char *action = suspend ? "suspend" : "fini"; 2941 2941 + const char *action; 2942 2942 struct nvkm_subdev *subdev; 2943 2943 int ret; 2944 2944 s64 time; 2945 2945 2946 2946 + switch (suspend) { 2947 2947 + case NVKM_POWEROFF: 2948 2948 + default: 2949 2949 + action = "fini"; 2950 2950 + break; 2951 2951 + case NVKM_SUSPEND: 2952 2952 + action = "suspend"; 2953 2953 + break; 2954 2954 + case NVKM_RUNTIME_SUSPEND: 2955 2955 + action = "runtime"; 2956 2956 + break; 2957 2957 + } 2946 2958 nvdev_trace(device, "%s running...\n", action); 2947 2959 time = ktime_to_us(ktime_get()); 2948 2960 ··· 3044 3032 if (ret) 3045 3033 return ret; 3046 3034 3047 3047 - nvkm_device_fini(device, false); 3035 3035 + nvkm_device_fini(device, NVKM_POWEROFF); 3048 3036 3049 3037 nvdev_trace(device, "init running...\n"); 3050 3038 time = ktime_to_us(ktime_get()); ··· 3072 3060 3073 3061 fail_subdev: 3074 3062 list_for_each_entry_from(subdev, &device->subdev, head) 3075 3075 - nvkm_subdev_fini(subdev, false); 3063 3063 + nvkm_subdev_fini(subdev, NVKM_POWEROFF); 3076 3064 fail: 3077 3077 - nvkm_device_fini(device, false); 3065 3065 + nvkm_device_fini(device, NVKM_POWEROFF); 3078 3066 3079 3067 nvdev_error(device, "init failed with %d\n", ret); 3080 3068 return ret;

+2 -2

drivers/gpu/drm/nouveau/nvkm/engine/device/pci.c

reviewed

··· 1605 1605 } 1606 1606 1607 1607 static void 1608 1608 - nvkm_device_pci_fini(struct nvkm_device *device, bool suspend) 1608 1608 + nvkm_device_pci_fini(struct nvkm_device *device, enum nvkm_suspend_state suspend) 1609 1609 { 1610 1610 struct nvkm_device_pci *pdev = nvkm_device_pci(device); 1611 1611 - if (suspend) { 1611 1611 + if (suspend != NVKM_POWEROFF) { 1612 1612 pci_disable_device(pdev->pdev); 1613 1613 pdev->suspend = true; 1614 1614 }

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/device/priv.h

reviewed

··· 56 56 const char *name, const char *cfg, const char *dbg, 57 57 struct nvkm_device *); 58 58 int nvkm_device_init(struct nvkm_device *); 59 59 - int nvkm_device_fini(struct nvkm_device *, bool suspend); 59 59 + int nvkm_device_fini(struct nvkm_device *, enum nvkm_suspend_state suspend); 60 60 #endif

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/device/user.c

reviewed

··· 218 218 } 219 219 220 220 static int 221 221 - nvkm_udevice_fini(struct nvkm_object *object, bool suspend) 221 221 + nvkm_udevice_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 222 222 { 223 223 struct nvkm_udevice *udev = nvkm_udevice(object); 224 224 struct nvkm_device *device = udev->device;

+2 -2

drivers/gpu/drm/nouveau/nvkm/engine/disp/base.c

reviewed

··· 99 99 } 100 100 101 101 static int 102 102 - nvkm_disp_fini(struct nvkm_engine *engine, bool suspend) 102 102 + nvkm_disp_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend) 103 103 { 104 104 struct nvkm_disp *disp = nvkm_disp(engine); 105 105 struct nvkm_outp *outp; 106 106 107 107 if (disp->func->fini) 108 108 - disp->func->fini(disp, suspend); 108 108 + disp->func->fini(disp, suspend != NVKM_POWEROFF); 109 109 110 110 list_for_each_entry(outp, &disp->outps, head) { 111 111 if (outp->func->fini)

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/disp/chan.c

reviewed

··· 128 128 } 129 129 130 130 static int 131 131 - nvkm_disp_chan_fini(struct nvkm_object *object, bool suspend) 131 131 + nvkm_disp_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 132 132 { 133 133 struct nvkm_disp_chan *chan = nvkm_disp_chan(object); 134 134

+2 -2

drivers/gpu/drm/nouveau/nvkm/engine/falcon.c

reviewed

··· 93 93 } 94 94 95 95 static int 96 96 - nvkm_falcon_fini(struct nvkm_engine *engine, bool suspend) 96 96 + nvkm_falcon_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend) 97 97 { 98 98 struct nvkm_falcon *falcon = nvkm_falcon(engine); 99 99 struct nvkm_device *device = falcon->engine.subdev.device; 100 100 const u32 base = falcon->addr; 101 101 102 102 - if (!suspend) { 102 102 + if (suspend == NVKM_POWEROFF) { 103 103 nvkm_memory_unref(&falcon->core); 104 104 if (falcon->external) { 105 105 vfree(falcon->data.data);

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/fifo/base.c

reviewed

··· 122 122 } 123 123 124 124 static int 125 125 - nvkm_fifo_fini(struct nvkm_engine *engine, bool suspend) 125 125 + nvkm_fifo_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend) 126 126 { 127 127 struct nvkm_fifo *fifo = nvkm_fifo(engine); 128 128 struct nvkm_runl *runl;

+3 -3

drivers/gpu/drm/nouveau/nvkm/engine/fifo/uchan.c

reviewed

··· 72 72 }; 73 73 74 74 static int 75 75 - nvkm_uchan_object_fini_1(struct nvkm_oproxy *oproxy, bool suspend) 75 75 + nvkm_uchan_object_fini_1(struct nvkm_oproxy *oproxy, enum nvkm_suspend_state suspend) 76 76 { 77 77 struct nvkm_uobj *uobj = container_of(oproxy, typeof(*uobj), oproxy); 78 78 struct nvkm_chan *chan = uobj->chan; ··· 87 87 nvkm_chan_cctx_bind(chan, ectx->engn, NULL); 88 88 89 89 if (refcount_dec_and_test(&ectx->uses)) 90 90 - nvkm_object_fini(ectx->object, false); 90 90 + nvkm_object_fini(ectx->object, NVKM_POWEROFF); 91 91 mutex_unlock(&chan->cgrp->mutex); 92 92 } 93 93 ··· 269 269 } 270 270 271 271 static int 272 272 - nvkm_uchan_fini(struct nvkm_object *object, bool suspend) 272 272 + nvkm_uchan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 273 273 { 274 274 struct nvkm_chan *chan = nvkm_uchan(object)->chan; 275 275

+2 -2

drivers/gpu/drm/nouveau/nvkm/engine/gr/base.c

reviewed

··· 168 168 } 169 169 170 170 static int 171 171 - nvkm_gr_fini(struct nvkm_engine *engine, bool suspend) 171 171 + nvkm_gr_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend) 172 172 { 173 173 struct nvkm_gr *gr = nvkm_gr(engine); 174 174 if (gr->func->fini) 175 175 - return gr->func->fini(gr, suspend); 175 175 + return gr->func->fini(gr, suspend != NVKM_POWEROFF); 176 176 return 0; 177 177 } 178 178

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.c

reviewed

··· 2330 2330 2331 2331 WARN_ON(gf100_gr_fecs_halt_pipeline(gr)); 2332 2332 2333 2333 - subdev->func->fini(subdev, false); 2333 2333 + subdev->func->fini(subdev, NVKM_POWEROFF); 2334 2334 nvkm_mc_disable(device, subdev->type, subdev->inst); 2335 2335 if (gr->func->gpccs.reset) 2336 2336 gr->func->gpccs.reset(gr);

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv04.c

reviewed

··· 1158 1158 } 1159 1159 1160 1160 static int 1161 1161 - nv04_gr_chan_fini(struct nvkm_object *object, bool suspend) 1161 1161 + nv04_gr_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 1162 1162 { 1163 1163 struct nv04_gr_chan *chan = nv04_gr_chan(object); 1164 1164 struct nv04_gr *gr = chan->gr;

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv10.c

reviewed

··· 951 951 } 952 952 953 953 static int 954 954 - nv10_gr_chan_fini(struct nvkm_object *object, bool suspend) 954 954 + nv10_gr_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 955 955 { 956 956 struct nv10_gr_chan *chan = nv10_gr_chan(object); 957 957 struct nv10_gr *gr = chan->gr;

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv20.c

reviewed

··· 27 27 } 28 28 29 29 int 30 30 - nv20_gr_chan_fini(struct nvkm_object *object, bool suspend) 30 30 + nv20_gr_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 31 31 { 32 32 struct nv20_gr_chan *chan = nv20_gr_chan(object); 33 33 struct nv20_gr *gr = chan->gr;

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv20.h

reviewed

··· 31 31 32 32 void *nv20_gr_chan_dtor(struct nvkm_object *); 33 33 int nv20_gr_chan_init(struct nvkm_object *); 34 34 - int nv20_gr_chan_fini(struct nvkm_object *, bool); 34 34 + int nv20_gr_chan_fini(struct nvkm_object *, enum nvkm_suspend_state); 35 35 #endif

+2 -2

drivers/gpu/drm/nouveau/nvkm/engine/gr/nv40.c

reviewed

··· 89 89 } 90 90 91 91 static int 92 92 - nv40_gr_chan_fini(struct nvkm_object *object, bool suspend) 92 92 + nv40_gr_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 93 93 { 94 94 struct nv40_gr_chan *chan = nv40_gr_chan(object); 95 95 struct nv40_gr *gr = chan->gr; ··· 101 101 nvkm_mask(device, 0x400720, 0x00000001, 0x00000000); 102 102 103 103 if (nvkm_rd32(device, 0x40032c) == inst) { 104 104 - if (suspend) { 104 104 + if (suspend != NVKM_POWEROFF) { 105 105 nvkm_wr32(device, 0x400720, 0x00000000); 106 106 nvkm_wr32(device, 0x400784, inst); 107 107 nvkm_mask(device, 0x400310, 0x00000020, 0x00000020);

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/mpeg/nv44.c

reviewed

··· 65 65 } 66 66 67 67 static int 68 68 - nv44_mpeg_chan_fini(struct nvkm_object *object, bool suspend) 68 68 + nv44_mpeg_chan_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 69 69 { 70 70 71 71 struct nv44_mpeg_chan *chan = nv44_mpeg_chan(object);

+1 -1

drivers/gpu/drm/nouveau/nvkm/engine/sec2/base.c

reviewed

··· 37 37 } 38 38 39 39 static int 40 40 - nvkm_sec2_fini(struct nvkm_engine *engine, bool suspend) 40 40 + nvkm_sec2_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend) 41 41 { 42 42 struct nvkm_sec2 *sec2 = nvkm_sec2(engine); 43 43 struct nvkm_subdev *subdev = &sec2->engine.subdev;

+2 -2

drivers/gpu/drm/nouveau/nvkm/engine/xtensa.c

reviewed

··· 76 76 } 77 77 78 78 static int 79 79 - nvkm_xtensa_fini(struct nvkm_engine *engine, bool suspend) 79 79 + nvkm_xtensa_fini(struct nvkm_engine *engine, enum nvkm_suspend_state suspend) 80 80 { 81 81 struct nvkm_xtensa *xtensa = nvkm_xtensa(engine); 82 82 struct nvkm_device *device = xtensa->engine.subdev.device; ··· 85 85 nvkm_wr32(device, base + 0xd84, 0); /* INTR_EN */ 86 86 nvkm_wr32(device, base + 0xd94, 0); /* FIFO_CTRL */ 87 87 88 88 - if (!suspend) 88 88 + if (suspend == NVKM_POWEROFF) 89 89 nvkm_memory_unref(&xtensa->gpu_fw); 90 90 return 0; 91 91 }

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/acr/base.c

reviewed

··· 182 182 } 183 183 184 184 static int 185 185 - nvkm_acr_fini(struct nvkm_subdev *subdev, bool suspend) 185 185 + nvkm_acr_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 186 186 { 187 187 if (!subdev->use.enabled) 188 188 return 0;

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/bar/base.c

reviewed

··· 90 90 } 91 91 92 92 static int 93 93 - nvkm_bar_fini(struct nvkm_subdev *subdev, bool suspend) 93 93 + nvkm_bar_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 94 94 { 95 95 struct nvkm_bar *bar = nvkm_bar(subdev); 96 96

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/clk/base.c

reviewed

··· 577 577 } 578 578 579 579 static int 580 580 - nvkm_clk_fini(struct nvkm_subdev *subdev, bool suspend) 580 580 + nvkm_clk_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 581 581 { 582 582 struct nvkm_clk *clk = nvkm_clk(subdev); 583 583 flush_work(&clk->work);

+2 -2

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/base.c

reviewed

··· 67 67 } 68 68 69 69 static int 70 70 - nvkm_devinit_fini(struct nvkm_subdev *subdev, bool suspend) 70 70 + nvkm_devinit_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 71 71 { 72 72 struct nvkm_devinit *init = nvkm_devinit(subdev); 73 73 /* force full reinit on resume */ 74 74 - if (suspend) 74 74 + if (suspend != NVKM_POWEROFF) 75 75 init->post = true; 76 76 return 0; 77 77 }

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/fault/base.c

reviewed

··· 51 51 } 52 52 53 53 static int 54 54 - nvkm_fault_fini(struct nvkm_subdev *subdev, bool suspend) 54 54 + nvkm_fault_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 55 55 { 56 56 struct nvkm_fault *fault = nvkm_fault(subdev); 57 57 if (fault->func->fini)

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/fault/user.c

reviewed

··· 56 56 } 57 57 58 58 static int 59 59 - nvkm_ufault_fini(struct nvkm_object *object, bool suspend) 59 59 + nvkm_ufault_fini(struct nvkm_object *object, enum nvkm_suspend_state suspend) 60 60 { 61 61 struct nvkm_fault_buffer *buffer = nvkm_fault_buffer(object); 62 62 buffer->fault->func->buffer.fini(buffer);

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/gpio/base.c

reviewed

··· 144 144 } 145 145 146 146 static int 147 147 - nvkm_gpio_fini(struct nvkm_subdev *subdev, bool suspend) 147 147 + nvkm_gpio_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 148 148 { 149 149 struct nvkm_gpio *gpio = nvkm_gpio(subdev); 150 150 u32 mask = (1ULL << gpio->func->lines) - 1;

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/base.c

reviewed

··· 48 48 } 49 49 50 50 static int 51 51 - nvkm_gsp_fini(struct nvkm_subdev *subdev, bool suspend) 51 51 + nvkm_gsp_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 52 52 { 53 53 struct nvkm_gsp *gsp = nvkm_gsp(subdev); 54 54

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/gh100.c

reviewed

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

+4 -4

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/priv.h

reviewed

··· 59 59 void (*dtor)(struct nvkm_gsp *); 60 60 int (*oneinit)(struct nvkm_gsp *); 61 61 int (*init)(struct nvkm_gsp *); 62 62 - int (*fini)(struct nvkm_gsp *, bool suspend); 62 62 + int (*fini)(struct nvkm_gsp *, enum nvkm_suspend_state suspend); 63 63 int (*reset)(struct nvkm_gsp *); 64 64 65 65 struct { ··· 75 75 void tu102_gsp_fwsec_sb_dtor(struct nvkm_gsp *); 76 76 int tu102_gsp_oneinit(struct nvkm_gsp *); 77 77 int tu102_gsp_init(struct nvkm_gsp *); 78 78 - int tu102_gsp_fini(struct nvkm_gsp *, bool suspend); 78 78 + int tu102_gsp_fini(struct nvkm_gsp *, enum nvkm_suspend_state suspend); 79 79 int tu102_gsp_reset(struct nvkm_gsp *); 80 80 u64 tu102_gsp_wpr_heap_size(struct nvkm_gsp *); 81 81 ··· 87 87 88 88 int gh100_gsp_oneinit(struct nvkm_gsp *); 89 89 int gh100_gsp_init(struct nvkm_gsp *); 90 90 - int gh100_gsp_fini(struct nvkm_gsp *, bool suspend); 90 90 + int gh100_gsp_fini(struct nvkm_gsp *, enum nvkm_suspend_state suspend); 91 91 92 92 void r535_gsp_dtor(struct nvkm_gsp *); 93 93 int r535_gsp_oneinit(struct nvkm_gsp *); 94 94 int r535_gsp_init(struct nvkm_gsp *); 95 95 - int r535_gsp_fini(struct nvkm_gsp *, bool suspend); 95 95 + int r535_gsp_fini(struct nvkm_gsp *, enum nvkm_suspend_state suspend); 96 96 97 97 int nvkm_gsp_new_(const struct nvkm_gsp_fwif *, struct nvkm_device *, enum nvkm_subdev_type, int, 98 98 struct nvkm_gsp **);

+1 -1

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

reviewed

··· 1721 1721 } 1722 1722 1723 1723 int 1724 1724 - r535_gsp_fini(struct nvkm_gsp *gsp, bool suspend) 1724 1724 + r535_gsp_fini(struct nvkm_gsp *gsp, enum nvkm_suspend_state suspend) 1725 1725 { 1726 1726 struct nvkm_rm *rm = gsp->rm; 1727 1727 int ret;

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/tu102.c

reviewed

··· 161 161 } 162 162 163 163 int 164 164 - tu102_gsp_fini(struct nvkm_gsp *gsp, bool suspend) 164 164 + tu102_gsp_fini(struct nvkm_gsp *gsp, enum nvkm_suspend_state suspend) 165 165 { 166 166 u32 mbox0 = 0xff, mbox1 = 0xff; 167 167 int ret;

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/i2c/base.c

reviewed

··· 135 135 } 136 136 137 137 static int 138 138 - nvkm_i2c_fini(struct nvkm_subdev *subdev, bool suspend) 138 138 + nvkm_i2c_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 139 139 { 140 140 struct nvkm_i2c *i2c = nvkm_i2c(subdev); 141 141 struct nvkm_i2c_pad *pad;

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/instmem/base.c

reviewed

··· 176 176 } 177 177 178 178 static int 179 179 - nvkm_instmem_fini(struct nvkm_subdev *subdev, bool suspend) 179 179 + nvkm_instmem_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 180 180 { 181 181 struct nvkm_instmem *imem = nvkm_instmem(subdev); 182 182 int ret;

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/pci/base.c

reviewed

··· 74 74 } 75 75 76 76 static int 77 77 - nvkm_pci_fini(struct nvkm_subdev *subdev, bool suspend) 77 77 + nvkm_pci_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 78 78 { 79 79 struct nvkm_pci *pci = nvkm_pci(subdev); 80 80

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/pmu/base.c

reviewed

··· 77 77 } 78 78 79 79 static int 80 80 - nvkm_pmu_fini(struct nvkm_subdev *subdev, bool suspend) 80 80 + nvkm_pmu_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 81 81 { 82 82 struct nvkm_pmu *pmu = nvkm_pmu(subdev); 83 83

+3 -3

drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c

reviewed

··· 341 341 } 342 342 343 343 static int 344 344 - nvkm_therm_fini(struct nvkm_subdev *subdev, bool suspend) 344 344 + nvkm_therm_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 345 345 { 346 346 struct nvkm_therm *therm = nvkm_therm(subdev); 347 347 348 348 if (therm->func->fini) 349 349 therm->func->fini(therm); 350 350 351 351 - nvkm_therm_fan_fini(therm, suspend); 352 352 - nvkm_therm_sensor_fini(therm, suspend); 351 351 + nvkm_therm_fan_fini(therm, suspend != NVKM_POWEROFF); 352 352 + nvkm_therm_sensor_fini(therm, suspend != NVKM_POWEROFF); 353 353 354 354 if (suspend) { 355 355 therm->suspend = therm->mode;

+1 -1

drivers/gpu/drm/nouveau/nvkm/subdev/timer/base.c

reviewed

··· 149 149 } 150 150 151 151 static int 152 152 - nvkm_timer_fini(struct nvkm_subdev *subdev, bool suspend) 152 152 + nvkm_timer_fini(struct nvkm_subdev *subdev, enum nvkm_suspend_state suspend) 153 153 { 154 154 struct nvkm_timer *tmr = nvkm_timer(subdev); 155 155 tmr->func->alarm_fini(tmr);