struct nvif_client {
        struct nvif_object object;
        const struct nvif_driver *driver;
+       u64 version;
        u8 route;
        bool super;
 };
 
 #ifndef __NVIF_IOCTL_H__
 #define __NVIF_IOCTL_H__
 
+#define NVIF_VERSION_LATEST                               0x0000000000000000ULL
+
 struct nvif_ioctl_v0 {
        __u8  version;
 #define NVIF_IOCTL_V0_NOP                                                  0x00
        __u8  data[];           /* ioctl data (below) */
 };
 
-struct nvif_ioctl_nop {
+struct nvif_ioctl_nop_v0 {
+       __u64 version;
 };
 
 struct nvif_ioctl_sclass_v0 {
 
 nvif_client_init(const char *driver, const char *name, u64 device,
                 const char *cfg, const char *dbg, struct nvif_client *client)
 {
+       struct {
+               struct nvif_ioctl_v0 ioctl;
+               struct nvif_ioctl_nop_v0 nop;
+       } args = {};
        int ret, i;
 
        ret = nvif_object_init(NULL, 0, 0, NULL, 0, &client->object);
                }
        }
 
+       if (ret == 0) {
+               ret = nvif_client_ioctl(client, &args, sizeof(args));
+               client->version = args.nop.version;
+       }
+
        if (ret)
                nvif_client_fini(client);
        return ret;
 
 {
        struct nvkm_object *object = handle->object;
        union {
-               struct nvif_ioctl_nop none;
+               struct nvif_ioctl_nop_v0 v0;
        } *args = data;
        int ret;
 
        nvif_ioctl(object, "nop size %d\n", size);
-       if (nvif_unvers(args->none)) {
-               nvif_ioctl(object, "nop\n");
+       if (nvif_unpack(args->v0, 0, 0, false)) {
+               nvif_ioctl(object, "nop vers %lld\n", args->v0.version);
+               args->v0.version = NVIF_VERSION_LATEST;
        }
 
        return ret;