void nvkm_falcon_msgq_init(struct nvkm_falcon_msgq *,
                           u32 index, u32 offset, u32 size);
 int nvkm_falcon_msgq_recv_initmsg(struct nvkm_falcon_msgq *, void *, u32 size);
+void nvkm_falcon_msgq_recv(struct nvkm_falcon_msgq *);
 #endif
 
 int nvkm_msgqueue_new(u32, struct nvkm_falcon *, const struct nvkm_secboot *,
                      struct nvkm_msgqueue **);
 void nvkm_msgqueue_del(struct nvkm_msgqueue **);
-void nvkm_msgqueue_recv(struct nvkm_msgqueue *);
 
 /* useful if we run a NVIDIA-signed firmware */
 void nvkm_msgqueue_write_cmdline(struct nvkm_msgqueue *, void *);
 
                sec2->initmsg_received = true;
        }
 
-       if (!sec2->queue) {
-               nvkm_warn(&sec2->engine.subdev,
-                         "recv function called while no firmware set!\n");
-               return;
-       }
-
-       nvkm_msgqueue_recv(sec2->queue);
+       nvkm_falcon_msgq_recv(sec2->msgq);
 }
 
 static void
 
 }
 
 void
-nvkm_msgqueue_process_msgs(struct nvkm_msgqueue *priv,
-                          struct nvkm_msgqueue_queue *queue)
+nvkm_falcon_msgq_recv(struct nvkm_falcon_msgq *queue)
 {
        /*
         * We are invoked from a worker thread, so normally we have plenty of
 
        }
 }
 
-void
-nvkm_msgqueue_recv(struct nvkm_msgqueue *queue)
-{
-       if (!queue->func || !queue->func->recv) {
-               const struct nvkm_subdev *subdev = queue->falcon->owner;
-
-               nvkm_warn(subdev, "missing msgqueue recv function\n");
-               return;
-       }
-
-       queue->func->recv(queue);
-}
-
 void
 nvkm_msgqueue_ctor(const struct nvkm_msgqueue_func *func,
                   struct nvkm_falcon *falcon,
 
 struct nvkm_msgqueue_func {
        const struct nvkm_msgqueue_init_func *init_func;
        void (*dtor)(struct nvkm_msgqueue *);
-       void (*recv)(struct nvkm_msgqueue *queue);
 };
 
 /**
 
 void nvkm_msgqueue_ctor(const struct nvkm_msgqueue_func *, struct nvkm_falcon *,
                        struct nvkm_msgqueue *);
-void nvkm_msgqueue_process_msgs(struct nvkm_msgqueue *,
-                               struct nvkm_msgqueue_queue *);
 
 int msgqueue_0137c63d_new(struct nvkm_falcon *, const struct nvkm_secboot *,
                          struct nvkm_msgqueue **);
 
        container_of(container_of(q, struct msgqueue_0137c63d, base), \
                     struct msgqueue_0137bca5, base);
 
-static void
-msgqueue_0137c63d_process_msgs(struct nvkm_msgqueue *queue)
-{
-       nvkm_msgqueue_process_msgs(queue, queue->falcon->owner->device->pmu->msgq);
-}
-
 /* Init unit */
 static void
 init_gen_cmdline(struct nvkm_msgqueue *queue, void *buf)
 static const struct nvkm_msgqueue_func
 msgqueue_0137c63d_func = {
        .init_func = &msgqueue_0137c63d_init_func,
-       .recv = msgqueue_0137c63d_process_msgs,
        .dtor = msgqueue_0137c63d_dtor,
 };
 
 static const struct nvkm_msgqueue_func
 msgqueue_0137bca5_func = {
        .init_func = &msgqueue_0137c63d_init_func,
-       .recv = msgqueue_0137c63d_process_msgs,
        .dtor = msgqueue_0137c63d_dtor,
 };
 
 
 #define msgqueue_0148cdec(q) \
        container_of(q, struct msgqueue_0148cdec, base)
 
-static void
-msgqueue_0148cdec_process_msgs(struct nvkm_msgqueue *queue)
-{
-       nvkm_msgqueue_process_msgs(queue, queue->falcon->owner->device->sec2->msgq);
-}
-
-
 static void
 init_gen_cmdline(struct nvkm_msgqueue *queue, void *buf)
 {
 const struct nvkm_msgqueue_func
 msgqueue_0148cdec_func = {
        .init_func = &msgqueue_0148cdec_init_func,
-       .recv = msgqueue_0148cdec_process_msgs,
        .dtor = msgqueue_0148cdec_dtor,
 };
 
 
                pmu->initmsg_received = true;
        }
 
-       if (!pmu->queue) {
-               nvkm_warn(&pmu->subdev,
-                         "recv function called while no firmware set!\n");
-               return;
-       }
-
-       nvkm_msgqueue_recv(pmu->queue);
+       nvkm_falcon_msgq_recv(pmu->msgq);
 }
 
 static const struct nvkm_pmu_func