prepare_to_wait(&s->waitq, &wait, TASK_INTERRUPTIBLE);
                /* New buffers might have become available before we were added
                   to the waitqueue */
-               if (!atomic_read(&s->q_full.buffers))
+               if (!atomic_read(&s->q_full.depth))
                        schedule();
                finish_wait(&s->waitq, &wait);
                if (signal_pending(current)) {
        CX18_DEBUG_HI_FILE("Encoder poll\n");
        poll_wait(filp, &s->waitq, wait);
 
-       if (atomic_read(&s->q_full.buffers))
+       if (atomic_read(&s->q_full.depth))
                return POLLIN | POLLRDNORM;
        if (eof)
                return POLLHUP;
 
                        continue;
                CX18_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n",
                          s->name, s->s_flags,
-                         atomic_read(&s->q_full.buffers) * 100 / s->buffers,
+                         atomic_read(&s->q_full.depth) * 100 / s->buffers,
                          (s->buffers * s->buf_size) / 1024, s->buffers);
        }
        CX18_INFO("Read MPEG/VBI: %lld/%lld bytes\n",
 
 void cx18_queue_init(struct cx18_queue *q)
 {
        INIT_LIST_HEAD(&q->list);
-       atomic_set(&q->buffers, 0);
+       atomic_set(&q->depth, 0);
        q->bytesused = 0;
 }
 
 
        /* q_busy is restricted to a max buffer count imposed by firmware */
        if (q == &s->q_busy &&
-           atomic_read(&q->buffers) >= CX18_MAX_FW_MDLS_PER_STREAM)
+           atomic_read(&q->depth) >= CX18_MAX_FW_MDLS_PER_STREAM)
                q = &s->q_free;
 
        spin_lock(&q->lock);
        else
                list_add_tail(&buf->list, &q->list); /* FIFO */
        q->bytesused += buf->bytesused - buf->readpos;
-       atomic_inc(&q->buffers);
+       atomic_inc(&q->depth);
 
        spin_unlock(&q->lock);
        return q;
                list_del_init(&buf->list);
                q->bytesused -= buf->bytesused - buf->readpos;
                buf->skipped = 0;
-               atomic_dec(&q->buffers);
+               atomic_dec(&q->depth);
        }
        spin_unlock(&q->lock);
        return buf;
                 */
                if (buf->id != id) {
                        buf->skipped++;
-                       if (buf->skipped >= atomic_read(&s->q_busy.buffers)-1) {
+                       if (buf->skipped >= atomic_read(&s->q_busy.depth)-1) {
                                /* buffer must have fallen out of rotation */
                                CX18_WARN("Skipped %s, buffer %d, %d "
                                          "times - it must have dropped out of "
                                          buf->skipped);
                                /* Sweep it up to put it back into rotation */
                                list_move_tail(&buf->list, &sweep_up);
-                               atomic_dec(&s->q_busy.buffers);
+                               atomic_dec(&s->q_busy.depth);
                        }
                        continue;
                }
                 * will have to put it back on a queue later.
                 */
                list_del_init(&buf->list);
-               atomic_dec(&s->q_busy.buffers);
+               atomic_dec(&s->q_busy.depth);
                ret = buf;
                break;
        }
                buf = list_first_entry(&q->list, struct cx18_buffer, list);
                list_move_tail(&buf->list, &s->q_free.list);
                buf->bytesused = buf->readpos = buf->b_flags = buf->skipped = 0;
-               atomic_inc(&s->q_free.buffers);
+               atomic_inc(&s->q_free.depth);
        }
        cx18_queue_init(q);
        spin_unlock(&q->lock);
 
        struct cx18_queue *q;
        struct cx18_buffer *buf;
 
-       if (atomic_read(&s->q_free.buffers) == 0 ||
-           atomic_read(&s->q_busy.buffers) >= CX18_MAX_FW_MDLS_PER_STREAM)
+       if (atomic_read(&s->q_free.depth) == 0 ||
+           atomic_read(&s->q_busy.depth) >= CX18_MAX_FW_MDLS_PER_STREAM)
                return;
 
        /* Move from q_free to q_busy notifying the firmware, until the limit */
                if (buf == NULL)
                        break;
                q = _cx18_stream_put_buf_fw(s, buf);
-       } while (atomic_read(&s->q_busy.buffers) < CX18_MAX_FW_MDLS_PER_STREAM
+       } while (atomic_read(&s->q_busy.depth) < CX18_MAX_FW_MDLS_PER_STREAM
                 && q == &s->q_busy);
 }