nvkm_subdev.mutex is going away.
Signed-off-by: Ben Skeggs <bskeggs@redhat.com>
Reviewed-by: Lyude Paul <lyude@redhat.com>
        int nr;
        struct list_head chan;
        spinlock_t lock;
+       struct mutex mutex;
 
        struct nvkm_event uevent; /* async user trigger */
        struct nvkm_event cevent; /* channel creation event */
 
        nvkm_event_fini(&fifo->kevent);
        nvkm_event_fini(&fifo->cevent);
        nvkm_event_fini(&fifo->uevent);
+       mutex_destroy(&fifo->mutex);
        return data;
 }
 
        fifo->func = func;
        INIT_LIST_HEAD(&fifo->chan);
        spin_lock_init(&fifo->lock);
+       mutex_init(&fifo->mutex);
 
        if (WARN_ON(fifo->nr > NVKM_FIFO_CHID_NR))
                fifo->nr = NVKM_FIFO_CHID_NR;
 
        struct nv04_fifo_chan *chan = nv04_fifo_chan(base);
        struct nvkm_instmem *imem = chan->fifo->base.engine.subdev.device->imem;
 
-       mutex_lock(&chan->fifo->base.engine.subdev.mutex);
+       mutex_lock(&chan->fifo->base.mutex);
        nvkm_ramht_remove(imem->ramht, cookie);
-       mutex_unlock(&chan->fifo->base.engine.subdev.mutex);
+       mutex_unlock(&chan->fifo->base.mutex);
 }
 
 static int
                return -EINVAL;
        }
 
-       mutex_lock(&chan->fifo->base.engine.subdev.mutex);
+       mutex_lock(&chan->fifo->base.mutex);
        hash = nvkm_ramht_insert(imem->ramht, object, chan->base.chid, 4,
                                 handle, context);
-       mutex_unlock(&chan->fifo->base.engine.subdev.mutex);
+       mutex_unlock(&chan->fifo->base.mutex);
        return hash;
 }
 
 
                return -EINVAL;
        }
 
-       mutex_lock(&chan->fifo->base.engine.subdev.mutex);
+       mutex_lock(&chan->fifo->base.mutex);
        hash = nvkm_ramht_insert(imem->ramht, object, chan->base.chid, 4,
                                 handle, context);
-       mutex_unlock(&chan->fifo->base.engine.subdev.mutex);
+       mutex_unlock(&chan->fifo->base.mutex);
        return hash;
 }
 
 
        int nr = 0;
        int target;
 
-       mutex_lock(&subdev->mutex);
+       mutex_lock(&fifo->base.mutex);
        cur = fifo->runlist.mem[fifo->runlist.active];
        fifo->runlist.active = !fifo->runlist.active;
 
        case NVKM_MEM_TARGET_VRAM: target = 0; break;
        case NVKM_MEM_TARGET_NCOH: target = 3; break;
        default:
-               mutex_unlock(&subdev->mutex);
+               mutex_unlock(&fifo->base.mutex);
                WARN_ON(1);
                return;
        }
                               !(nvkm_rd32(device, 0x00227c) & 0x00100000),
                               msecs_to_jiffies(2000)) == 0)
                nvkm_error(subdev, "runlist update timeout\n");
-       mutex_unlock(&subdev->mutex);
+       mutex_unlock(&fifo->base.mutex);
 }
 
 void
 gf100_fifo_runlist_remove(struct gf100_fifo *fifo, struct gf100_fifo_chan *chan)
 {
-       mutex_lock(&fifo->base.engine.subdev.mutex);
+       mutex_lock(&fifo->base.mutex);
        list_del_init(&chan->head);
-       mutex_unlock(&fifo->base.engine.subdev.mutex);
+       mutex_unlock(&fifo->base.mutex);
 }
 
 void
 gf100_fifo_runlist_insert(struct gf100_fifo *fifo, struct gf100_fifo_chan *chan)
 {
-       mutex_lock(&fifo->base.engine.subdev.mutex);
+       mutex_lock(&fifo->base.mutex);
        list_add_tail(&chan->head, &fifo->chan);
-       mutex_unlock(&fifo->base.engine.subdev.mutex);
+       mutex_unlock(&fifo->base.mutex);
 }
 
 static inline int
 
 {
        const struct gk104_fifo_runlist_func *func = fifo->func->runlist;
        struct gk104_fifo_chan *chan;
-       struct nvkm_subdev *subdev = &fifo->base.engine.subdev;
        struct nvkm_memory *mem;
        struct nvkm_fifo_cgrp *cgrp;
        int nr = 0;
 
-       mutex_lock(&subdev->mutex);
+       mutex_lock(&fifo->base.mutex);
        mem = fifo->runlist[runl].mem[fifo->runlist[runl].next];
        fifo->runlist[runl].next = !fifo->runlist[runl].next;
 
        nvkm_done(mem);
 
        func->commit(fifo, runl, mem, nr);
-       mutex_unlock(&subdev->mutex);
+       mutex_unlock(&fifo->base.mutex);
 }
 
 void
 gk104_fifo_runlist_remove(struct gk104_fifo *fifo, struct gk104_fifo_chan *chan)
 {
        struct nvkm_fifo_cgrp *cgrp = chan->cgrp;
-       mutex_lock(&fifo->base.engine.subdev.mutex);
+       mutex_lock(&fifo->base.mutex);
        if (!list_empty(&chan->head)) {
                list_del_init(&chan->head);
                if (cgrp && !--cgrp->chan_nr)
                        list_del_init(&cgrp->head);
        }
-       mutex_unlock(&fifo->base.engine.subdev.mutex);
+       mutex_unlock(&fifo->base.mutex);
 }
 
 void
 gk104_fifo_runlist_insert(struct gk104_fifo *fifo, struct gk104_fifo_chan *chan)
 {
        struct nvkm_fifo_cgrp *cgrp = chan->cgrp;
-       mutex_lock(&fifo->base.engine.subdev.mutex);
+       mutex_lock(&fifo->base.mutex);
        if (cgrp) {
                if (!cgrp->chan_nr++)
                        list_add_tail(&cgrp->head, &fifo->runlist[chan->runl].cgrp);
        } else {
                list_add_tail(&chan->head, &fifo->runlist[chan->runl].chan);
        }
-       mutex_unlock(&fifo->base.engine.subdev.mutex);
+       mutex_unlock(&fifo->base.mutex);
 }
 
 void
 
        struct nvkm_gpuobj *inst = chan->base.inst;
        int ret = 0;
 
-       mutex_lock(&subdev->mutex);
+       mutex_lock(&chan->fifo->base.mutex);
        nvkm_wr32(device, 0x002634, chan->base.chid);
        if (nvkm_msec(device, 2000,
                if (nvkm_rd32(device, 0x002634) == chan->base.chid)
                           chan->base.chid, chan->base.object.client->name);
                ret = -ETIMEDOUT;
        }
-       mutex_unlock(&subdev->mutex);
+       mutex_unlock(&chan->fifo->base.mutex);
 
        if (ret && suspend)
                return ret;
 
 gk104_fifo_gpfifo_kick(struct gk104_fifo_chan *chan)
 {
        int ret;
-       mutex_lock(&chan->base.fifo->engine.subdev.mutex);
+       mutex_lock(&chan->base.fifo->mutex);
        ret = gk104_fifo_gpfifo_kick_locked(chan);
-       mutex_unlock(&chan->base.fifo->engine.subdev.mutex);
+       mutex_unlock(&chan->base.fifo->mutex);
        return ret;
 }
 
 
        int ret;
 
        /* Block runlist to prevent the channel from being rescheduled. */
-       mutex_lock(&subdev->mutex);
+       mutex_lock(&chan->fifo->base.mutex);
        nvkm_mask(device, 0x002630, BIT(chan->runl), BIT(chan->runl));
 
        /* Preempt the channel. */
 
        /* Resume runlist. */
        nvkm_mask(device, 0x002630, BIT(chan->runl), 0);
-       mutex_unlock(&subdev->mutex);
+       mutex_unlock(&chan->fifo->base.mutex);
        return ret;
 }
 
 
 void
 nv50_fifo_runlist_update(struct nv50_fifo *fifo)
 {
-       mutex_lock(&fifo->base.engine.subdev.mutex);
+       mutex_lock(&fifo->base.mutex);
        nv50_fifo_runlist_update_locked(fifo);
-       mutex_unlock(&fifo->base.engine.subdev.mutex);
+       mutex_unlock(&fifo->base.mutex);
 }
 
 int