size_t size;
 
        /* actual size of vring (in bytes) */
-       size = PAGE_ALIGN(vring_size(rvring->len, rvring->align));
+       size = PAGE_ALIGN(vring_size(rvring->num, rvring->align));
 
        rsc = (void *)rproc->table_ptr + rvdev->rsc_offset;
 
                return -EINVAL;
        }
 
-       rvring->len = vring->num;
+       rvring->num = vring->num;
        rvring->align = vring->align;
        rvring->rvdev = rvdev;
 
 
        struct fw_rsc_vdev *rsc;
        struct virtqueue *vq;
        void *addr;
-       int len, size;
+       int num, size;
 
        /* we're temporarily limited to two virtqueues per rvdev */
        if (id >= ARRAY_SIZE(rvdev->vring))
 
        rvring = &rvdev->vring[id];
        addr = mem->va;
-       len = rvring->len;
+       num = rvring->num;
 
        /* zero vring */
-       size = vring_size(len, rvring->align);
+       size = vring_size(num, rvring->align);
        memset(addr, 0, size);
 
        dev_dbg(dev, "vring%d: va %pK qsz %d notifyid %d\n",
-               id, addr, len, rvring->notifyid);
+               id, addr, num, rvring->notifyid);
 
        /*
         * Create the new vq, and tell virtio we're not interested in
         * the 'weak' smp barriers, since we're talking with a real device.
         */
-       vq = vring_new_virtqueue(id, len, rvring->align, vdev, false, ctx,
+       vq = vring_new_virtqueue(id, num, rvring->align, vdev, false, ctx,
                                 addr, rproc_virtio_notify, callback, name);
        if (!vq) {
                dev_err(dev, "vring_new_virtqueue %s failed\n", name);
 
 /**
  * struct rproc_vring - remoteproc vring state
  * @va:        virtual address
- * @len: length, in bytes
+ * @num: vring size
  * @da: device address
  * @align: vring alignment
  * @notifyid: rproc-specific unique vring index
  */
 struct rproc_vring {
        void *va;
-       int len;
+       int num;
        u32 da;
        u32 align;
        int notifyid;