1/*
2 * Copyright 2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
3 * Distributed under the terms of the MIT License.
4 */
5
6
7#include "packet_buffer.h"
8
9#include <util/ring_buffer.h>
10
11#include <stdlib.h>
12#include <string.h>
13
14
15packet_buffer*
16create_packet_buffer(size_t size)
17{
18	packet_buffer* buffer
19		= (packet_buffer *)malloc(sizeof(packet_buffer));
20	if (buffer == NULL)
21		return NULL;
22
23	buffer->buffer = create_ring_buffer(size);
24	if (buffer->buffer == NULL) {
25		free(buffer);
26		return NULL;
27	}
28	B_INITIALIZE_SPINLOCK(&buffer->lock);
29
30	return buffer;
31}
32
33
34void
35delete_packet_buffer(packet_buffer* buffer)
36{
37	delete_ring_buffer(buffer->buffer);
38	free(buffer);
39}
40
41
42void
43packet_buffer_clear(packet_buffer* buffer)
44{
45	cpu_status state = disable_interrupts();
46	acquire_spinlock(&buffer->lock);
47
48	ring_buffer_clear(buffer->buffer);
49
50	release_spinlock(&buffer->lock);
51	restore_interrupts(state);
52}
53
54
55size_t
56packet_buffer_readable(packet_buffer* buffer)
57{
58	cpu_status state = disable_interrupts();
59	acquire_spinlock(&buffer->lock);
60
61	size_t available = ring_buffer_readable(buffer->buffer);
62
63	release_spinlock(&buffer->lock);
64	restore_interrupts(state);
65
66	return available;
67}
68
69
70size_t
71packet_buffer_writable(packet_buffer* buffer)
72{
73	cpu_status state = disable_interrupts();
74	acquire_spinlock(&buffer->lock);
75
76	size_t left = ring_buffer_writable(buffer->buffer);
77
78	release_spinlock(&buffer->lock);
79	restore_interrupts(state);
80
81	return left;
82}
83
84
85void
86packet_buffer_flush(packet_buffer* buffer, size_t length)
87{
88	cpu_status state = disable_interrupts();
89	acquire_spinlock(&buffer->lock);
90
91	ring_buffer_flush(buffer->buffer, length);
92
93	release_spinlock(&buffer->lock);
94	restore_interrupts(state);
95}
96
97
98size_t
99packet_buffer_read(packet_buffer* buffer, uint8 *data, size_t length)
100{
101	cpu_status state = disable_interrupts();
102	acquire_spinlock(&buffer->lock);
103
104	size_t bytesRead = ring_buffer_read(buffer->buffer, data, length);
105
106	release_spinlock(&buffer->lock);
107	restore_interrupts(state);
108
109	return bytesRead;
110}
111
112
113size_t
114packet_buffer_write(packet_buffer* buffer, const uint8 *data,
115	size_t length)
116{
117	cpu_status state = disable_interrupts();
118	acquire_spinlock(&buffer->lock);
119
120	size_t bytesWritten = ring_buffer_write(buffer->buffer, data, length);
121
122	release_spinlock(&buffer->lock);
123	restore_interrupts(state);
124
125	return bytesWritten;
126}
127
128