Commit | Line | Data |
---|---|---|
181d6902 ID |
1 | /* |
2 | Copyright (C) 2004 - 2008 rt2x00 SourceForge Project | |
3 | <http://rt2x00.serialmonkey.com> | |
4 | ||
5 | This program is free software; you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
7 | the Free Software Foundation; either version 2 of the License, or | |
8 | (at your option) any later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program; if not, write to the | |
17 | Free Software Foundation, Inc., | |
18 | 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
19 | */ | |
20 | ||
21 | /* | |
22 | Module: rt2x00 | |
23 | Abstract: rt2x00 queue datastructures and routines | |
24 | */ | |
25 | ||
26 | #ifndef RT2X00QUEUE_H | |
27 | #define RT2X00QUEUE_H | |
28 | ||
29 | #include <linux/prefetch.h> | |
30 | ||
31 | /** | |
32 | * DOC: Entrie frame size | |
33 | * | |
34 | * Ralink PCI devices demand the Frame size to be a multiple of 128 bytes, | |
35 | * for USB devices this restriction does not apply, but the value of | |
36 | * 2432 makes sense since it is big enough to contain the maximum fragment | |
37 | * size according to the ieee802.11 specs. | |
38 | */ | |
39 | #define DATA_FRAME_SIZE 2432 | |
40 | #define MGMT_FRAME_SIZE 256 | |
41 | ||
42 | /** | |
43 | * DOC: Number of entries per queue | |
44 | * | |
45 | * After research it was concluded that 12 entries in a RX and TX | |
46 | * queue would be sufficient. Although this is almost one third of | |
47 | * the amount the legacy driver allocated, the queues aren't getting | |
48 | * filled to the maximum even when working with the maximum rate. | |
181d6902 ID |
49 | */ |
50 | #define RX_ENTRIES 12 | |
51 | #define TX_ENTRIES 12 | |
52 | #define BEACON_ENTRIES 1 | |
53 | #define ATIM_ENTRIES 1 | |
54 | ||
55 | /** | |
56 | * enum data_queue_qid: Queue identification | |
57 | */ | |
58 | enum data_queue_qid { | |
59 | QID_AC_BE = 0, | |
60 | QID_AC_BK = 1, | |
61 | QID_AC_VI = 2, | |
62 | QID_AC_VO = 3, | |
63 | QID_HCCA = 4, | |
64 | QID_MGMT = 13, | |
65 | QID_RX = 14, | |
66 | QID_OTHER = 15, | |
67 | }; | |
68 | ||
5957da4c ID |
69 | /** |
70 | * enum rt2x00_bcn_queue: Beacon queue index | |
71 | * | |
72 | * Start counting with a high offset, this because this enumeration | |
73 | * supplements &enum ieee80211_tx_queue and we should prevent value | |
74 | * conflicts. | |
75 | * | |
76 | * @RT2X00_BCN_QUEUE_BEACON: Beacon queue | |
77 | * @RT2X00_BCN_QUEUE_ATIM: Atim queue (sends frame after beacon) | |
78 | */ | |
79 | enum rt2x00_bcn_queue { | |
80 | RT2X00_BCN_QUEUE_BEACON = 100, | |
81 | RT2X00_BCN_QUEUE_ATIM = 101, | |
82 | }; | |
83 | ||
baf26a7e ID |
84 | /** |
85 | * enum skb_frame_desc_flags: Flags for &struct skb_frame_desc | |
86 | * | |
87 | * @FRAME_DESC_DRIVER_GENERATED: Frame was generated inside driver | |
88 | * and should not be reported back to mac80211 during txdone. | |
89 | */ | |
90 | enum skb_frame_desc_flags { | |
91 | FRAME_DESC_DRIVER_GENERATED = 1 << 0, | |
92 | }; | |
93 | ||
181d6902 ID |
94 | /** |
95 | * struct skb_frame_desc: Descriptor information for the skb buffer | |
96 | * | |
97 | * This structure is placed over the skb->cb array, this means that | |
98 | * this structure should not exceed the size of that array (48 bytes). | |
99 | * | |
baf26a7e | 100 | * @flags: Frame flags, see &enum skb_frame_desc_flags. |
181d6902 ID |
101 | * @frame_type: Frame type, see &enum rt2x00_dump_type. |
102 | * @data: Pointer to data part of frame (Start of ieee80211 header). | |
103 | * @desc: Pointer to descriptor part of the frame. | |
104 | * Note that this pointer could point to something outside | |
105 | * of the scope of the skb->data pointer. | |
106 | * @data_len: Length of the frame data. | |
107 | * @desc_len: Length of the frame descriptor. | |
108 | ||
109 | * @entry: The entry to which this sk buffer belongs. | |
110 | */ | |
111 | struct skb_frame_desc { | |
112 | unsigned int flags; | |
113 | ||
114 | unsigned int frame_type; | |
115 | ||
116 | void *data; | |
117 | void *desc; | |
118 | ||
119 | unsigned int data_len; | |
120 | unsigned int desc_len; | |
121 | ||
122 | struct queue_entry *entry; | |
123 | }; | |
124 | ||
125 | static inline struct skb_frame_desc* get_skb_frame_desc(struct sk_buff *skb) | |
126 | { | |
127 | BUILD_BUG_ON(sizeof(struct skb_frame_desc) > sizeof(skb->cb)); | |
128 | return (struct skb_frame_desc *)&skb->cb[0]; | |
129 | } | |
130 | ||
131 | /** | |
132 | * struct rxdone_entry_desc: RX Entry descriptor | |
133 | * | |
134 | * Summary of information that has been read from the RX frame descriptor. | |
135 | * | |
136 | * @signal: Signal of the received frame. | |
89993890 ID |
137 | * @signal_plcp: Does the signal field contain the plcp value, |
138 | * or does it contain the bitrate itself. | |
181d6902 ID |
139 | * @rssi: RSSI of the received frame. |
140 | * @ofdm: Was frame send with an OFDM rate. | |
141 | * @size: Data size of the received frame. | |
142 | * @flags: MAC80211 receive flags (See &enum mac80211_rx_flags). | |
143 | * @my_bss: Does this frame originate from device's BSS. | |
144 | */ | |
145 | struct rxdone_entry_desc { | |
146 | int signal; | |
89993890 | 147 | int signal_plcp; |
181d6902 ID |
148 | int rssi; |
149 | int ofdm; | |
150 | int size; | |
151 | int flags; | |
152 | int my_bss; | |
153 | }; | |
154 | ||
155 | /** | |
156 | * struct txdone_entry_desc: TX done entry descriptor | |
157 | * | |
158 | * Summary of information that has been read from the TX frame descriptor | |
159 | * after the device is done with transmission. | |
160 | * | |
161 | * @control: Control structure which was used to transmit the frame. | |
162 | * @status: TX status (See &enum tx_status). | |
163 | * @retry: Retry count. | |
164 | */ | |
165 | struct txdone_entry_desc { | |
166 | struct ieee80211_tx_control *control; | |
167 | int status; | |
168 | int retry; | |
169 | }; | |
170 | ||
171 | /** | |
172 | * enum txentry_desc_flags: Status flags for TX entry descriptor | |
173 | * | |
174 | * @ENTRY_TXD_RTS_FRAME: This frame is a RTS frame. | |
175 | * @ENTRY_TXD_OFDM_RATE: This frame is send out with an OFDM rate. | |
176 | * @ENTRY_TXD_MORE_FRAG: This frame is followed by another fragment. | |
177 | * @ENTRY_TXD_REQ_TIMESTAMP: Require timestamp to be inserted. | |
178 | * @ENTRY_TXD_BURST: This frame belongs to the same burst event. | |
179 | * @ENTRY_TXD_ACK: An ACK is required for this frame. | |
180 | */ | |
181 | enum txentry_desc_flags { | |
182 | ENTRY_TXD_RTS_FRAME, | |
183 | ENTRY_TXD_OFDM_RATE, | |
184 | ENTRY_TXD_MORE_FRAG, | |
185 | ENTRY_TXD_REQ_TIMESTAMP, | |
186 | ENTRY_TXD_BURST, | |
187 | ENTRY_TXD_ACK, | |
188 | }; | |
189 | ||
190 | /** | |
191 | * struct txentry_desc: TX Entry descriptor | |
192 | * | |
193 | * Summary of information for the frame descriptor before sending a TX frame. | |
194 | * | |
195 | * @flags: Descriptor flags (See &enum queue_entry_flags). | |
196 | * @queue: Queue identification (See &enum data_queue_qid). | |
197 | * @length_high: PLCP length high word. | |
198 | * @length_low: PLCP length low word. | |
199 | * @signal: PLCP signal. | |
200 | * @service: PLCP service. | |
201 | * @aifs: AIFS value. | |
202 | * @ifs: IFS value. | |
203 | * @cw_min: cwmin value. | |
204 | * @cw_max: cwmax value. | |
205 | */ | |
206 | struct txentry_desc { | |
207 | unsigned long flags; | |
208 | ||
209 | enum data_queue_qid queue; | |
210 | ||
211 | u16 length_high; | |
212 | u16 length_low; | |
213 | u16 signal; | |
214 | u16 service; | |
215 | ||
216 | int aifs; | |
217 | int ifs; | |
218 | int cw_min; | |
219 | int cw_max; | |
220 | }; | |
221 | ||
222 | /** | |
223 | * enum queue_entry_flags: Status flags for queue entry | |
224 | * | |
225 | * @ENTRY_BCN_ASSIGNED: This entry has been assigned to an interface. | |
226 | * As long as this bit is set, this entry may only be touched | |
227 | * through the interface structure. | |
228 | * @ENTRY_OWNER_DEVICE_DATA: This entry is owned by the device for data | |
229 | * transfer (either TX or RX depending on the queue). The entry should | |
230 | * only be touched after the device has signaled it is done with it. | |
231 | * @ENTRY_OWNER_DEVICE_CRYPTO: This entry is owned by the device for data | |
232 | * encryption or decryption. The entry should only be touched after | |
233 | * the device has signaled it is done with it. | |
234 | */ | |
235 | ||
236 | enum queue_entry_flags { | |
237 | ENTRY_BCN_ASSIGNED, | |
238 | ENTRY_OWNER_DEVICE_DATA, | |
239 | ENTRY_OWNER_DEVICE_CRYPTO, | |
240 | }; | |
241 | ||
242 | /** | |
243 | * struct queue_entry: Entry inside the &struct data_queue | |
244 | * | |
245 | * @flags: Entry flags, see &enum queue_entry_flags. | |
246 | * @queue: The data queue (&struct data_queue) to which this entry belongs. | |
247 | * @skb: The buffer which is currently being transmitted (for TX queue), | |
248 | * or used to directly recieve data in (for RX queue). | |
249 | * @entry_idx: The entry index number. | |
250 | * @priv_data: Private data belonging to this queue entry. The pointer | |
251 | * points to data specific to a particular driver and queue type. | |
252 | */ | |
253 | struct queue_entry { | |
254 | unsigned long flags; | |
255 | ||
256 | struct data_queue *queue; | |
257 | ||
258 | struct sk_buff *skb; | |
259 | ||
260 | unsigned int entry_idx; | |
261 | ||
262 | void *priv_data; | |
263 | }; | |
264 | ||
265 | /** | |
266 | * enum queue_index: Queue index type | |
267 | * | |
268 | * @Q_INDEX: Index pointer to the current entry in the queue, if this entry is | |
269 | * owned by the hardware then the queue is considered to be full. | |
270 | * @Q_INDEX_DONE: Index pointer to the next entry which will be completed by | |
271 | * the hardware and for which we need to run the txdone handler. If this | |
272 | * entry is not owned by the hardware the queue is considered to be empty. | |
273 | * @Q_INDEX_CRYPTO: Index pointer to the next entry which encryption/decription | |
274 | * will be completed by the hardware next. | |
275 | * @Q_INDEX_MAX: Keep last, used in &struct data_queue to determine the size | |
276 | * of the index array. | |
277 | */ | |
278 | enum queue_index { | |
279 | Q_INDEX, | |
280 | Q_INDEX_DONE, | |
281 | Q_INDEX_CRYPTO, | |
282 | Q_INDEX_MAX, | |
283 | }; | |
284 | ||
285 | /** | |
286 | * struct data_queue: Data queue | |
287 | * | |
288 | * @rt2x00dev: Pointer to main &struct rt2x00dev where this queue belongs to. | |
289 | * @entries: Base address of the &struct queue_entry which are | |
290 | * part of this queue. | |
291 | * @qid: The queue identification, see &enum data_queue_qid. | |
292 | * @lock: Spinlock to protect index handling. Whenever @index, @index_done or | |
293 | * @index_crypt needs to be changed this lock should be grabbed to prevent | |
294 | * index corruption due to concurrency. | |
295 | * @count: Number of frames handled in the queue. | |
296 | * @limit: Maximum number of entries in the queue. | |
297 | * @length: Number of frames in queue. | |
298 | * @index: Index pointers to entry positions in the queue, | |
299 | * use &enum queue_index to get a specific index field. | |
300 | * @aifs: The aifs value for outgoing frames (field ignored in RX queue). | |
301 | * @cw_min: The cw min value for outgoing frames (field ignored in RX queue). | |
302 | * @cw_max: The cw max value for outgoing frames (field ignored in RX queue). | |
303 | * @data_size: Maximum data size for the frames in this queue. | |
304 | * @desc_size: Hardware descriptor size for the data in this queue. | |
305 | */ | |
306 | struct data_queue { | |
307 | struct rt2x00_dev *rt2x00dev; | |
308 | struct queue_entry *entries; | |
309 | ||
310 | enum data_queue_qid qid; | |
311 | ||
312 | spinlock_t lock; | |
313 | unsigned int count; | |
314 | unsigned short limit; | |
315 | unsigned short length; | |
316 | unsigned short index[Q_INDEX_MAX]; | |
317 | ||
318 | unsigned short aifs; | |
319 | unsigned short cw_min; | |
320 | unsigned short cw_max; | |
321 | ||
322 | unsigned short data_size; | |
323 | unsigned short desc_size; | |
324 | }; | |
325 | ||
326 | /** | |
327 | * struct data_queue_desc: Data queue description | |
328 | * | |
329 | * The information in this structure is used by drivers | |
330 | * to inform rt2x00lib about the creation of the data queue. | |
331 | * | |
332 | * @entry_num: Maximum number of entries for a queue. | |
333 | * @data_size: Maximum data size for the frames in this queue. | |
334 | * @desc_size: Hardware descriptor size for the data in this queue. | |
335 | * @priv_size: Size of per-queue_entry private data. | |
336 | */ | |
337 | struct data_queue_desc { | |
338 | unsigned short entry_num; | |
339 | unsigned short data_size; | |
340 | unsigned short desc_size; | |
341 | unsigned short priv_size; | |
342 | }; | |
343 | ||
344 | /** | |
345 | * queue_end - Return pointer to the last queue (HELPER MACRO). | |
346 | * @__dev: Pointer to &struct rt2x00_dev | |
347 | * | |
348 | * Using the base rx pointer and the maximum number of available queues, | |
349 | * this macro will return the address of 1 position beyond the end of the | |
350 | * queues array. | |
351 | */ | |
352 | #define queue_end(__dev) \ | |
353 | &(__dev)->rx[(__dev)->data_queues] | |
354 | ||
355 | /** | |
356 | * tx_queue_end - Return pointer to the last TX queue (HELPER MACRO). | |
357 | * @__dev: Pointer to &struct rt2x00_dev | |
358 | * | |
359 | * Using the base tx pointer and the maximum number of available TX | |
360 | * queues, this macro will return the address of 1 position beyond | |
361 | * the end of the TX queue array. | |
362 | */ | |
363 | #define tx_queue_end(__dev) \ | |
364 | &(__dev)->tx[(__dev)->hw->queues] | |
365 | ||
366 | /** | |
367 | * queue_loop - Loop through the queues within a specific range (HELPER MACRO). | |
368 | * @__entry: Pointer where the current queue entry will be stored in. | |
369 | * @__start: Start queue pointer. | |
370 | * @__end: End queue pointer. | |
371 | * | |
372 | * This macro will loop through all queues between &__start and &__end. | |
373 | */ | |
374 | #define queue_loop(__entry, __start, __end) \ | |
375 | for ((__entry) = (__start); \ | |
376 | prefetch(&(__entry)[1]), (__entry) != (__end); \ | |
377 | (__entry) = &(__entry)[1]) | |
378 | ||
379 | /** | |
380 | * queue_for_each - Loop through all queues | |
381 | * @__dev: Pointer to &struct rt2x00_dev | |
382 | * @__entry: Pointer where the current queue entry will be stored in. | |
383 | * | |
384 | * This macro will loop through all available queues. | |
385 | */ | |
386 | #define queue_for_each(__dev, __entry) \ | |
387 | queue_loop(__entry, (__dev)->rx, queue_end(__dev)) | |
388 | ||
389 | /** | |
390 | * tx_queue_for_each - Loop through the TX queues | |
391 | * @__dev: Pointer to &struct rt2x00_dev | |
392 | * @__entry: Pointer where the current queue entry will be stored in. | |
393 | * | |
394 | * This macro will loop through all TX related queues excluding | |
395 | * the Beacon and Atim queues. | |
396 | */ | |
397 | #define tx_queue_for_each(__dev, __entry) \ | |
398 | queue_loop(__entry, (__dev)->tx, tx_queue_end(__dev)) | |
399 | ||
400 | /** | |
401 | * txall_queue_for_each - Loop through all TX related queues | |
402 | * @__dev: Pointer to &struct rt2x00_dev | |
403 | * @__entry: Pointer where the current queue entry will be stored in. | |
404 | * | |
405 | * This macro will loop through all TX related queues including | |
406 | * the Beacon and Atim queues. | |
407 | */ | |
408 | #define txall_queue_for_each(__dev, __entry) \ | |
409 | queue_loop(__entry, (__dev)->tx, queue_end(__dev)) | |
410 | ||
411 | /** | |
412 | * rt2x00queue_empty - Check if the queue is empty. | |
413 | * @queue: Queue to check if empty. | |
414 | */ | |
415 | static inline int rt2x00queue_empty(struct data_queue *queue) | |
416 | { | |
417 | return queue->length == 0; | |
418 | } | |
419 | ||
420 | /** | |
421 | * rt2x00queue_full - Check if the queue is full. | |
422 | * @queue: Queue to check if full. | |
423 | */ | |
424 | static inline int rt2x00queue_full(struct data_queue *queue) | |
425 | { | |
426 | return queue->length == queue->limit; | |
427 | } | |
428 | ||
429 | /** | |
430 | * rt2x00queue_free - Check the number of available entries in queue. | |
431 | * @queue: Queue to check. | |
432 | */ | |
433 | static inline int rt2x00queue_available(struct data_queue *queue) | |
434 | { | |
435 | return queue->limit - queue->length; | |
436 | } | |
437 | ||
438 | /** | |
439 | * rt2x00_desc_read - Read a word from the hardware descriptor. | |
440 | * @desc: Base descriptor address | |
441 | * @word: Word index from where the descriptor should be read. | |
442 | * @value: Address where the descriptor value should be written into. | |
443 | */ | |
444 | static inline void rt2x00_desc_read(__le32 *desc, const u8 word, u32 *value) | |
445 | { | |
446 | *value = le32_to_cpu(desc[word]); | |
447 | } | |
448 | ||
449 | /** | |
450 | * rt2x00_desc_write - wrote a word to the hardware descriptor. | |
451 | * @desc: Base descriptor address | |
452 | * @word: Word index from where the descriptor should be written. | |
453 | * @value: Value that should be written into the descriptor. | |
454 | */ | |
455 | static inline void rt2x00_desc_write(__le32 *desc, const u8 word, u32 value) | |
456 | { | |
457 | desc[word] = cpu_to_le32(value); | |
458 | } | |
459 | ||
460 | #endif /* RT2X00QUEUE_H */ |