Add ar6000 wireless driver.
[kernel.git] / drivers / ar6000 / ar6000 / netbuf.c
1
2 /*
3  *
4  * Copyright (c) 2004-2007 Atheros Communications Inc.
5  * All rights reserved.
6  *
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License version 2 as
10  *  published by the Free Software Foundation;
11  *
12  *  Software distributed under the License is distributed on an "AS
13  *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
14  *  implied. See the License for the specific language governing
15  *  rights and limitations under the License.
16  *
17  *
18  *
19  */
20 #include <linux/kernel.h>
21 #include <linux/skbuff.h>
22 #include <a_config.h>
23 #include "athdefs.h"
24 #include "a_types.h"
25 #include "a_osapi.h"
26 #include "htc_packet.h"
27
28 #define AR6000_DATA_OFFSET    64
29
30 void a_netbuf_enqueue(A_NETBUF_QUEUE_T *q, void *pkt)
31 {
32     skb_queue_tail((struct sk_buff_head *) q, (struct sk_buff *) pkt);
33 }
34
35 void a_netbuf_prequeue(A_NETBUF_QUEUE_T *q, void *pkt)
36 {
37     skb_queue_head((struct sk_buff_head *) q, (struct sk_buff *) pkt);
38 }
39
40 void *a_netbuf_dequeue(A_NETBUF_QUEUE_T *q)
41 {
42     return((void *) skb_dequeue((struct sk_buff_head *) q));
43 }
44
45 int a_netbuf_queue_size(A_NETBUF_QUEUE_T *q)
46 {
47     return(skb_queue_len((struct sk_buff_head *) q));
48 }
49
50 int a_netbuf_queue_empty(A_NETBUF_QUEUE_T *q)
51 {
52     return(skb_queue_empty((struct sk_buff_head *) q));
53 }
54
55 void a_netbuf_queue_init(A_NETBUF_QUEUE_T *q)
56 {
57     skb_queue_head_init((struct sk_buff_head *) q);
58 }
59
60 void *
61 a_netbuf_alloc(int size)
62 {
63     struct sk_buff *skb;
64     skb = dev_alloc_skb(AR6000_DATA_OFFSET + sizeof(HTC_PACKET) + size);
65     skb_reserve(skb, AR6000_DATA_OFFSET + sizeof(HTC_PACKET));
66     return ((void *)skb);
67 }
68
69 /*
70  * Allocate an SKB w.o. any encapsulation requirement.
71  */
72 void *
73 a_netbuf_alloc_raw(int size)
74 {
75     struct sk_buff *skb;
76
77     skb = dev_alloc_skb(size);
78
79     return ((void *)skb);
80 }
81
82 void
83 a_netbuf_free(void *bufPtr)
84 {
85     struct sk_buff *skb = (struct sk_buff *)bufPtr;
86
87     dev_kfree_skb(skb);
88 }
89
90 A_UINT32
91 a_netbuf_to_len(void *bufPtr)
92 {
93     return (((struct sk_buff *)bufPtr)->len);
94 }
95
96 void *
97 a_netbuf_to_data(void *bufPtr)
98 {
99     return (((struct sk_buff *)bufPtr)->data);
100 }
101
102 /*
103  * Add len # of bytes to the beginning of the network buffer
104  * pointed to by bufPtr
105  */
106 A_STATUS
107 a_netbuf_push(void *bufPtr, A_INT32 len)
108 {
109     skb_push((struct sk_buff *)bufPtr, len);
110
111     return A_OK;
112 }
113
114 /*
115  * Add len # of bytes to the beginning of the network buffer
116  * pointed to by bufPtr and also fill with data
117  */
118 A_STATUS
119 a_netbuf_push_data(void *bufPtr, char *srcPtr, A_INT32 len)
120 {
121     skb_push((struct sk_buff *) bufPtr, len);
122     A_MEMCPY(((struct sk_buff *)bufPtr)->data, srcPtr, len);
123
124     return A_OK;
125 }
126
127 /*
128  * Add len # of bytes to the end of the network buffer
129  * pointed to by bufPtr
130  */
131 A_STATUS
132 a_netbuf_put(void *bufPtr, A_INT32 len)
133 {
134     skb_put((struct sk_buff *)bufPtr, len);
135
136     return A_OK;
137 }
138
139 /*
140  * Add len # of bytes to the end of the network buffer
141  * pointed to by bufPtr and also fill with data
142  */
143 A_STATUS
144 a_netbuf_put_data(void *bufPtr, char *srcPtr, A_INT32 len)
145 {
146     char *start = ((struct sk_buff *)bufPtr)->data +
147         ((struct sk_buff *)bufPtr)->len;
148     skb_put((struct sk_buff *)bufPtr, len);
149     A_MEMCPY(start, srcPtr, len);
150
151     return A_OK;
152 }
153
154
155 /*
156  * Trim the network buffer pointed to by bufPtr to len # of bytes
157  */
158 A_STATUS
159 a_netbuf_setlen(void *bufPtr, A_INT32 len)
160 {
161     skb_trim((struct sk_buff *)bufPtr, len);
162
163     return A_OK;
164 }
165
166 /*
167  * Chop of len # of bytes from the end of the buffer.
168  */
169 A_STATUS
170 a_netbuf_trim(void *bufPtr, A_INT32 len)
171 {
172     skb_trim((struct sk_buff *)bufPtr, ((struct sk_buff *)bufPtr)->len - len);
173
174     return A_OK;
175 }
176
177 /*
178  * Chop of len # of bytes from the end of the buffer and return the data.
179  */
180 A_STATUS
181 a_netbuf_trim_data(void *bufPtr, char *dstPtr, A_INT32 len)
182 {
183     char *start = ((struct sk_buff *)bufPtr)->data +
184         (((struct sk_buff *)bufPtr)->len - len);
185
186     A_MEMCPY(dstPtr, start, len);
187     skb_trim((struct sk_buff *)bufPtr, ((struct sk_buff *)bufPtr)->len - len);
188
189     return A_OK;
190 }
191
192
193 /*
194  * Returns the number of bytes available to a a_netbuf_push()
195  */
196 A_INT32
197 a_netbuf_headroom(void *bufPtr)
198 {
199     return (skb_headroom((struct sk_buff *)bufPtr));
200 }
201
202 /*
203  * Removes specified number of bytes from the beginning of the buffer
204  */
205 A_STATUS
206 a_netbuf_pull(void *bufPtr, A_INT32 len)
207 {
208     skb_pull((struct sk_buff *)bufPtr, len);
209
210     return A_OK;
211 }
212
213 /*
214  * Removes specified number of bytes from the beginning of the buffer
215  * and return the data
216  */
217 A_STATUS
218 a_netbuf_pull_data(void *bufPtr, char *dstPtr, A_INT32 len)
219 {
220     A_MEMCPY(dstPtr, ((struct sk_buff *)bufPtr)->data, len);
221     skb_pull((struct sk_buff *)bufPtr, len);
222
223     return A_OK;
224 }
225