drivers/cmmb/cmmb_ringbuffer.c

   1 /*
   2  *
   3  * dvb_ringbuffer.c: ring buffer implementation for the dvb driver
   4  *
   5  * Copyright (C) 2003 Oliver Endriss
   6  * Copyright (C) 2004 Andrew de Quincey
   7  *
   8  * based on code originally found in av7110.c & dvb_ci.c:
   9  * Copyright (C) 1999-2003 Ralph  Metzler
  10  *                       & Marcus Metzler for convergence integrated media GmbH
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public License
  14  * as published by the Free Software Foundation; either version 2.1
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25  */
  26
  27
  28
  29 #include <linux/errno.h>
  30 #include <linux/kernel.h>
  31 #include <linux/module.h>
  32 #include <linux/sched.h>
  33 #include <linux/string.h>
  34 #include <asm/uaccess.h>
  35
  36 #include "cmmb_ringbuffer.h"
  37
  38
  39 void cmmb_ringbuffer_init(struct dvb_ringbuffer *rbuf, void *data, size_t len)
  40 {
  41         rbuf->pread=rbuf->pwrite=0;
  42         rbuf->data=data;
  43         rbuf->size=len;
  44         rbuf->error=0;
  45
  46         init_waitqueue_head(&rbuf->queue);
  47
  48         spin_lock_init(&(rbuf->lock));
  49
  50 }
  51
  52
  53
  54 int cmmb_ringbuffer_empty(struct dvb_ringbuffer *rbuf)
  55 {
  56         return (rbuf->pread==rbuf->pwrite);
  57 }
  58
  59
  60
  61 ssize_t cmmb_ringbuffer_free(struct dvb_ringbuffer *rbuf)
  62 {
  63         ssize_t free;
  64
  65         free = rbuf->pread - rbuf->pwrite;
  66         if (free <= 0)
  67                 free += rbuf->size;
  68         return free-1;
  69 }
  70
  71
  72
  73 ssize_t cmmb_ringbuffer_avail(struct dvb_ringbuffer *rbuf)
  74 {
  75         ssize_t avail;
  76
  77         avail = rbuf->pwrite - rbuf->pread;
  78         if (avail < 0)
  79                 avail += rbuf->size;
  80         return avail;
  81 }
  82
  83
  84
  85 void cmmb_ringbuffer_flush(struct dvb_ringbuffer *rbuf)
  86 {
  87         rbuf->pread = rbuf->pwrite;
  88         rbuf->error = 0;
  89 }
  90
  91
  92
  93 void cmmb_ringbuffer_flush_spinlock_wakeup(struct dvb_ringbuffer *rbuf)
  94 {
  95         unsigned long flags;
  96
  97         spin_lock_irqsave(&rbuf->lock, flags);
  98         cmmb_ringbuffer_flush(rbuf);
  99         spin_unlock_irqrestore(&rbuf->lock, flags);
 100
 101         wake_up(&rbuf->queue);
 102 }
 103
 104
 105
 106 ssize_t cmmb_ringbuffer_read(struct dvb_ringbuffer *rbuf, u8 *buf, size_t len, int usermem)
 107 {
 108         size_t todo = len;
 109         size_t split;
 110
 111         split = (rbuf->pread + len > rbuf->size) ? rbuf->size - rbuf->pread : 0;
 112         if (split > 0) {
 113                 if (!usermem)
 114                         memcpy(buf, rbuf->data+rbuf->pread, split);
 115                 else
 116                         if (copy_to_user(buf, rbuf->data+rbuf->pread, split))
 117                                 return -EFAULT;
 118                 buf += split;
 119                 todo -= split;
 120                 rbuf->pread = 0;
 121         }
 122         if (!usermem)
 123                 memcpy(buf, rbuf->data+rbuf->pread, todo);
 124         else
 125                 if (copy_to_user(buf, rbuf->data+rbuf->pread, todo))
 126                         return -EFAULT;
 127
 128         rbuf->pread = (rbuf->pread + todo) % rbuf->size;
 129
 130         return len;
 131 }
 132
 133
 134
 135 ssize_t cmmb_ringbuffer_write(struct dvb_ringbuffer *rbuf, const u8 *buf, size_t len)
 136 {
 137         size_t todo = len;
 138         size_t split;
 139
 140         split = (rbuf->pwrite + len > rbuf->size) ? rbuf->size - rbuf->pwrite : 0;
 141
 142         if (split > 0) {
 143                 memcpy(rbuf->data+rbuf->pwrite, buf, split);
 144                 buf += split;
 145                 todo -= split;
 146                 rbuf->pwrite = 0;
 147         }
 148         memcpy(rbuf->data+rbuf->pwrite, buf, todo);
 149         rbuf->pwrite = (rbuf->pwrite + todo) % rbuf->size;
 150
 151         return len;
 152 }
 153
 154
 155
 156
 157 EXPORT_SYMBOL(cmmb_ringbuffer_init);
 158 EXPORT_SYMBOL(cmmb_ringbuffer_empty);
 159 EXPORT_SYMBOL(cmmb_ringbuffer_free);
 160 EXPORT_SYMBOL(cmmb_ringbuffer_avail);
 161 EXPORT_SYMBOL(cmmb_ringbuffer_flush_spinlock_wakeup);
 162 EXPORT_SYMBOL(cmmb_ringbuffer_read);
 163 EXPORT_SYMBOL(cmmb_ringbuffer_write);