#define nvkm_engine_destroy(p)                                              \
        nvkm_subdev_destroy(&(p)->subdev)
-#define nvkm_engine_init(p)                                                 \
+#define nvkm_engine_init_old(p)                                                \
        nvkm_subdev_init_old(&(p)->subdev)
-#define nvkm_engine_fini(p,s)                                               \
+#define nvkm_engine_fini_old(p,s)                                              \
        nvkm_subdev_fini_old(&(p)->subdev, (s))
 
 int nvkm_engine_create_(struct nvkm_object *, struct nvkm_object *,
 
 #define nvkm_fifo_create(o,e,c,fc,lc,d)                                     \
        nvkm_fifo_create_((o), (e), (c), (fc), (lc), sizeof(**d), (void **)d)
 #define nvkm_fifo_init(p)                                                   \
-       nvkm_engine_init(&(p)->engine)
+       nvkm_engine_init_old(&(p)->engine)
 #define nvkm_fifo_fini(p,s)                                                 \
-       nvkm_engine_fini(&(p)->engine, (s))
+       nvkm_engine_fini_old(&(p)->engine, (s))
 
 int nvkm_fifo_create_(struct nvkm_object *, struct nvkm_object *,
                         struct nvkm_oclass *, int min, int max,
 
 #define nvkm_gr_destroy(d)                                               \
        nvkm_engine_destroy(&(d)->engine)
 #define nvkm_gr_init(d)                                                  \
-       nvkm_engine_init(&(d)->engine)
+       nvkm_engine_init_old(&(d)->engine)
 #define nvkm_gr_fini(d,s)                                                \
-       nvkm_engine_fini(&(d)->engine, (s))
+       nvkm_engine_fini_old(&(d)->engine, (s))
 
 #define _nvkm_gr_dtor _nvkm_engine_dtor
 #define _nvkm_gr_init _nvkm_engine_init
 
 #define nvkm_mpeg_destroy(d)                                                \
        nvkm_engine_destroy(&(d)->engine)
 #define nvkm_mpeg_init(d)                                                   \
-       nvkm_engine_init(&(d)->engine)
+       nvkm_engine_init_old(&(d)->engine)
 #define nvkm_mpeg_fini(d,s)                                                 \
-       nvkm_engine_fini(&(d)->engine, (s))
+       nvkm_engine_fini_old(&(d)->engine, (s))
 
 #define _nvkm_mpeg_dtor _nvkm_engine_dtor
 #define _nvkm_mpeg_init _nvkm_engine_init
 
 #define nvkm_sw_destroy(d)                                            \
        nvkm_engine_destroy(&(d)->engine)
 #define nvkm_sw_init(d)                                               \
-       nvkm_engine_init(&(d)->engine)
+       nvkm_engine_init_old(&(d)->engine)
 #define nvkm_sw_fini(d,s)                                             \
-       nvkm_engine_fini(&(d)->engine, (s))
+       nvkm_engine_fini_old(&(d)->engine, (s))
 
 #define _nvkm_sw_dtor _nvkm_engine_dtor
 #define _nvkm_sw_init _nvkm_engine_init
 
        struct nvkm_device *device = cipher->subdev.device;
        int ret;
 
-       ret = nvkm_engine_init(cipher);
+       ret = nvkm_engine_init_old(cipher);
        if (ret)
                return ret;
 
 
                nvkm_connector_fini(conn);
        }
 
-       return nvkm_engine_fini(&disp->engine, suspend);
+       return nvkm_engine_fini_old(&disp->engine, suspend);
 }
 
 int
        struct nvkm_output *outp;
        int ret;
 
-       ret = nvkm_engine_init(&disp->engine);
+       ret = nvkm_engine_init_old(&disp->engine);
        if (ret)
                return ret;
 
 
        u32 caps;
 
        /* enable engine, and determine its capabilities */
-       ret = nvkm_engine_init(&falcon->engine);
+       ret = nvkm_engine_init_old(&falcon->engine);
        if (ret)
                return ret;
 
        nvkm_mask(device, base + 0x048, 0x00000003, 0x00000000);
        nvkm_wr32(device, base + 0x014, 0xffffffff);
 
-       return nvkm_engine_fini(&falcon->engine, suspend);
+       return nvkm_engine_fini_old(&falcon->engine, suspend);
 }
 
 int
 
 _nvkm_pm_fini(struct nvkm_object *object, bool suspend)
 {
        struct nvkm_pm *pm = (void *)object;
-       return nvkm_engine_fini(&pm->engine, suspend);
+       return nvkm_engine_fini_old(&pm->engine, suspend);
 }
 
 int
 _nvkm_pm_init(struct nvkm_object *object)
 {
        struct nvkm_pm *pm = (void *)object;
-       return nvkm_engine_init(&pm->engine);
+       return nvkm_engine_init_old(&pm->engine);
 }
 
 void
 
        int i, ret;
        u32 tmp;
 
-       ret = nvkm_engine_init(&xtensa->engine);
+       ret = nvkm_engine_init_old(&xtensa->engine);
        if (ret)
                return ret;
 
        if (!suspend)
                nvkm_gpuobj_ref(NULL, &xtensa->gpu_fw);
 
-       return nvkm_engine_fini(&xtensa->engine, suspend);
+       return nvkm_engine_fini_old(&xtensa->engine, suspend);
 }