drivers/net/wireless/eswin/slave_log_buf.c

   1 #include "slave_log_buf.h"
   2
   3 spinlock_t lock;
   4
   5 uint32_t ring_buffer_init(struct ring_buffer* ring_buf, uint32_t size)
   6 {
   7     if(ring_buf== NULL)
   8         return false;
   9
  10     if (!is_power_of_2(size))
  11     {
  12         printk("size must be power of 2.\n");
  13         return false;
  14     }
  15
  16     memset(ring_buf, 0, sizeof(struct ring_buffer));
  17     spin_lock_init(&lock);
  18     ring_buf->buffer = kmalloc(size,GFP_KERNEL);
  19     ring_buf->size = size;
  20     ring_buf->write_point = 0;
  21     ring_buf->read_point = 0;
  22     ring_buf->f_lock = &lock;
  23     ring_buf->init = true;
  24     ring_buf->cover = false;
  25     ring_buf->show = false;
  26     return true;
  27 }
  28
  29 void ring_buffer_deinit(struct ring_buffer *ring_buf)
  30 {
  31     memset(ring_buf, 0, sizeof(struct ring_buffer));
  32     if(ring_buf->buffer != NULL)
  33     {
  34         kfree(ring_buf->buffer);
  35         ring_buf->buffer = NULL;
  36     }
  37
  38 }
  39
  40
  41 uint32_t __ring_buffer_len(const struct ring_buffer *ring_buf)
  42 {
  43     if(ring_buf->cover == false)
  44     {
  45         return ring_buf->write_point;
  46     }
  47     if(ring_buf->show == true)
  48     {
  49         if(ring_buf->write_point < ring_buf->read_point)
  50             return (ring_buf->write_point + ring_buf->size - ring_buf->read_point);
  51         else
  52             return (ring_buf->write_point - ring_buf->read_point);
  53     }
  54
  55     return  ring_buf->size;
  56 }
  57
  58
  59 uint32_t __ring_buffer_get(struct ring_buffer *ring_buf, void * buffer, uint32_t size)
  60 {
  61     if((ring_buf== NULL) || (buffer== NULL))
  62         return 0;
  63
  64     uint32_t copy_len = 0;
  65     uint32_t read_len = 0;
  66     if(ring_buf->write_point < ring_buf->read_point)
  67         read_len = (ring_buf->write_point + ring_buf->size - ring_buf->read_point);
  68     else
  69         read_len = (ring_buf->write_point - ring_buf->read_point);
  70
  71     size  = min(size, read_len);
  72     /* first get the data from fifo->read_point until the end of the buffer */
  73     copy_len = min(size, ring_buf->size - ring_buf->read_point);
  74     memcpy(buffer, ring_buf->buffer + ring_buf->read_point, copy_len);
  75     /* then get the rest (if any) from the beginning of the buffer */
  76     if(size - copy_len > 0)
  77     {
  78         memcpy(buffer + copy_len, ring_buf->buffer, size - copy_len);
  79     }
  80
  81     ring_buf->read_point += size;
  82     ring_buf->read_point = (ring_buf->read_point & (ring_buf->size - 1));
  83
  84     return size;
  85 }
  86 //Ïò»º³åÇøÖÐ´æ·ÅÊý¾Ý
  87 uint32_t __ring_buffer_put(struct ring_buffer *ring_buf, void *buffer, uint32_t size)
  88 {
  89     if((ring_buf == NULL) || (buffer == NULL))
  90     {
  91         return 0;
  92     }
  93     uint32_t copy_len = 0;
  94
  95     /* first put the data starting from fifo->write_point to buffer end */
  96     copy_len  = min(size, ring_buf->size - ring_buf->write_point);
  97
  98     memcpy(ring_buf->buffer + ring_buf->write_point, buffer, copy_len);
  99     /* then put the rest (if any) at the beginning of the buffer */
 100     if(size - copy_len > 0)
 101     {
 102         memcpy(ring_buf->buffer, buffer + copy_len, size - copy_len);
 103         ring_buf->cover = true;
 104     }
 105
 106     ring_buf->write_point += size;
 107     ring_buf->write_point = (ring_buf->write_point & (ring_buf->size - 1));
 108     return size;
 109 }
 110
 111 uint32_t ring_buffer_len(const struct ring_buffer *ring_buf)
 112 {
 113     uint32_t len = 0;
 114     spin_lock_irq(ring_buf->f_lock);
 115     len = __ring_buffer_len(ring_buf);
 116     spin_unlock_irq(ring_buf->f_lock);
 117     return len;
 118 }
 119
 120 uint32_t ring_buffer_get(struct ring_buffer *ring_buf, void *buffer, uint32_t size)
 121 {
 122     uint32_t ret;
 123     spin_lock_irq(ring_buf->f_lock);
 124     ret = __ring_buffer_get(ring_buf, buffer, size);
 125     spin_unlock_irq(ring_buf->f_lock);
 126     return ret;
 127 }
 128
 129 uint32_t ring_buffer_put(struct ring_buffer *ring_buf, void *buffer, uint32_t size)
 130 {
 131     uint32_t ret;
 132     spin_lock_irq(ring_buf->f_lock);
 133     ret = __ring_buffer_put(ring_buf, buffer, size);
 134     spin_unlock_irq(ring_buf->f_lock);
 135     return ret;
 136 }
 137 uint32_t ring_buffer_scrolling_display(struct ring_buffer *ring_buf, char show)
 138 {
 139     uint32_t ret = true;
 140     spin_lock_irq(ring_buf->f_lock);
 141     ring_buf->show = show;
 142     if((ring_buf->cover == true)&&(show == true))
 143     {
 144         ring_buf->read_point = (ring_buf->write_point & (ring_buf->size - 1)) + 1;
 145     }
 146     spin_unlock_irq(ring_buf->f_lock);
 147     return ret;
 148 }
 149