?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-next' into for-linus
[linux-2.6/x86.git] / drivers / net / wireless / zd1211rw / zd_mac.c
bloba22a192031208547627ce594b256a315ebc5d390
1 /* ZD1211 USB-WLAN driver for Linux
2 *
3 * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
4 * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
5 * Copyright (C) 2006-2007 Michael Wu <flamingice@sourmilk.net>
6 * Copyright (C) 2007-2008 Luis R. Rodriguez <mcgrof@winlab.rutgers.edu>
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 as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include <linux/netdevice.h>
24 #include <linux/etherdevice.h>
25 #include <linux/usb.h>
26 #include <linux/jiffies.h>
27 #include <net/ieee80211_radiotap.h>
28
29 #include "zd_def.h"
30 #include "zd_chip.h"
31 #include "zd_mac.h"
32 #include "zd_rf.h"
33
34 struct zd_reg_alpha2_map {
35 u32 reg;
36 char alpha2[2];
37 };
38
39 static struct zd_reg_alpha2_map reg_alpha2_map[] = {
40 { ZD_REGDOMAIN_FCC, "US" },
41 { ZD_REGDOMAIN_IC, "CA" },
42 { ZD_REGDOMAIN_ETSI, "DE" }, /* Generic ETSI, use most restrictive */
43 { ZD_REGDOMAIN_JAPAN, "JP" },
44 { ZD_REGDOMAIN_JAPAN_ADD, "JP" },
45 { ZD_REGDOMAIN_SPAIN, "ES" },
46 { ZD_REGDOMAIN_FRANCE, "FR" },
47 };
48
49 /* This table contains the hardware specific values for the modulation rates. */
50 static const struct ieee80211_rate zd_rates[] = {
51 { .bitrate = 10,
52 .hw_value = ZD_CCK_RATE_1M, },
53 { .bitrate = 20,
54 .hw_value = ZD_CCK_RATE_2M,
55 .hw_value_short = ZD_CCK_RATE_2M | ZD_CCK_PREA_SHORT,
56 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
57 { .bitrate = 55,
58 .hw_value = ZD_CCK_RATE_5_5M,
59 .hw_value_short = ZD_CCK_RATE_5_5M | ZD_CCK_PREA_SHORT,
60 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
61 { .bitrate = 110,
62 .hw_value = ZD_CCK_RATE_11M,
63 .hw_value_short = ZD_CCK_RATE_11M | ZD_CCK_PREA_SHORT,
64 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
65 { .bitrate = 60,
66 .hw_value = ZD_OFDM_RATE_6M,
67 .flags = 0 },
68 { .bitrate = 90,
69 .hw_value = ZD_OFDM_RATE_9M,
70 .flags = 0 },
71 { .bitrate = 120,
72 .hw_value = ZD_OFDM_RATE_12M,
73 .flags = 0 },
74 { .bitrate = 180,
75 .hw_value = ZD_OFDM_RATE_18M,
76 .flags = 0 },
77 { .bitrate = 240,
78 .hw_value = ZD_OFDM_RATE_24M,
79 .flags = 0 },
80 { .bitrate = 360,
81 .hw_value = ZD_OFDM_RATE_36M,
82 .flags = 0 },
83 { .bitrate = 480,
84 .hw_value = ZD_OFDM_RATE_48M,
85 .flags = 0 },
86 { .bitrate = 540,
87 .hw_value = ZD_OFDM_RATE_54M,
88 .flags = 0 },
89 };
90
91 /*
92 * Zydas retry rates table. Each line is listed in the same order as
93 * in zd_rates[] and contains all the rate used when a packet is sent
94 * starting with a given rates. Let's consider an example :
95 *
96 * "11 Mbits : 4, 3, 2, 1, 0" means :
97 * - packet is sent using 4 different rates
98 * - 1st rate is index 3 (ie 11 Mbits)
99 * - 2nd rate is index 2 (ie 5.5 Mbits)
100 * - 3rd rate is index 1 (ie 2 Mbits)
101 * - 4th rate is index 0 (ie 1 Mbits)
102 */
103
104 static const struct tx_retry_rate zd_retry_rates[] = {
105 { /* 1 Mbits */ 1, { 0 }},
106 { /* 2 Mbits */ 2, { 1, 0 }},
107 { /* 5.5 Mbits */ 3, { 2, 1, 0 }},
108 { /* 11 Mbits */ 4, { 3, 2, 1, 0 }},
109 { /* 6 Mbits */ 5, { 4, 3, 2, 1, 0 }},
110 { /* 9 Mbits */ 6, { 5, 4, 3, 2, 1, 0}},
111 { /* 12 Mbits */ 5, { 6, 3, 2, 1, 0 }},
112 { /* 18 Mbits */ 6, { 7, 6, 3, 2, 1, 0 }},
113 { /* 24 Mbits */ 6, { 8, 6, 3, 2, 1, 0 }},
114 { /* 36 Mbits */ 7, { 9, 8, 6, 3, 2, 1, 0 }},
115 { /* 48 Mbits */ 8, {10, 9, 8, 6, 3, 2, 1, 0 }},
116 { /* 54 Mbits */ 9, {11, 10, 9, 8, 6, 3, 2, 1, 0 }}
117 };
118
119 static const struct ieee80211_channel zd_channels[] = {
120 { .center_freq = 2412, .hw_value = 1 },
121 { .center_freq = 2417, .hw_value = 2 },
122 { .center_freq = 2422, .hw_value = 3 },
123 { .center_freq = 2427, .hw_value = 4 },
124 { .center_freq = 2432, .hw_value = 5 },
125 { .center_freq = 2437, .hw_value = 6 },
126 { .center_freq = 2442, .hw_value = 7 },
127 { .center_freq = 2447, .hw_value = 8 },
128 { .center_freq = 2452, .hw_value = 9 },
129 { .center_freq = 2457, .hw_value = 10 },
130 { .center_freq = 2462, .hw_value = 11 },
131 { .center_freq = 2467, .hw_value = 12 },
132 { .center_freq = 2472, .hw_value = 13 },
133 { .center_freq = 2484, .hw_value = 14 },
134 };
135
136 static void housekeeping_init(struct zd_mac *mac);
137 static void housekeeping_enable(struct zd_mac *mac);
138 static void housekeeping_disable(struct zd_mac *mac);
139
140 static int zd_reg2alpha2(u8 regdomain, char *alpha2)
141 {
142 unsigned int i;
143 struct zd_reg_alpha2_map *reg_map;
144 for (i = 0; i < ARRAY_SIZE(reg_alpha2_map); i++) {
145 reg_map = &reg_alpha2_map[i];
146 if (regdomain == reg_map->reg) {
147 alpha2[0] = reg_map->alpha2[0];
148 alpha2[1] = reg_map->alpha2[1];
149 return 0;
150 }
151 }
152 return 1;
153 }
154
155 int zd_mac_preinit_hw(struct ieee80211_hw *hw)
156 {
157 int r;
158 u8 addr[ETH_ALEN];
159 struct zd_mac *mac = zd_hw_mac(hw);
160
161 r = zd_chip_read_mac_addr_fw(&mac->chip, addr);
162 if (r)
163 return r;
164
165 SET_IEEE80211_PERM_ADDR(hw, addr);
166
167 return 0;
168 }
169
170 int zd_mac_init_hw(struct ieee80211_hw *hw)
171 {
172 int r;
173 struct zd_mac *mac = zd_hw_mac(hw);
174 struct zd_chip *chip = &mac->chip;
175 char alpha2[2];
176 u8 default_regdomain;
177
178 r = zd_chip_enable_int(chip);
179 if (r)
180 goto out;
181 r = zd_chip_init_hw(chip);
182 if (r)
183 goto disable_int;
184
185 ZD_ASSERT(!irqs_disabled());
186
187 r = zd_read_regdomain(chip, &default_regdomain);
188 if (r)
189 goto disable_int;
190 spin_lock_irq(&mac->lock);
191 mac->regdomain = mac->default_regdomain = default_regdomain;
192 spin_unlock_irq(&mac->lock);
193
194 /* We must inform the device that we are doing encryption/decryption in
195 * software at the moment. */
196 r = zd_set_encryption_type(chip, ENC_SNIFFER);
197 if (r)
198 goto disable_int;
199
200 r = zd_reg2alpha2(mac->regdomain, alpha2);
201 if (r)
202 goto disable_int;
203
204 r = regulatory_hint(hw->wiphy, alpha2);
205 disable_int:
206 zd_chip_disable_int(chip);
207 out:
208 return r;
209 }
210
211 void zd_mac_clear(struct zd_mac *mac)
212 {
213 flush_workqueue(zd_workqueue);
214 zd_chip_clear(&mac->chip);
215 ZD_ASSERT(!spin_is_locked(&mac->lock));
216 ZD_MEMCLEAR(mac, sizeof(struct zd_mac));
217 }
218
219 static int set_rx_filter(struct zd_mac *mac)
220 {
221 unsigned long flags;
222 u32 filter = STA_RX_FILTER;
223
224 spin_lock_irqsave(&mac->lock, flags);
225 if (mac->pass_ctrl)
226 filter |= RX_FILTER_CTRL;
227 spin_unlock_irqrestore(&mac->lock, flags);
228
229 return zd_iowrite32(&mac->chip, CR_RX_FILTER, filter);
230 }
231
232 static int set_mc_hash(struct zd_mac *mac)
233 {
234 struct zd_mc_hash hash;
235 zd_mc_clear(&hash);
236 return zd_chip_set_multicast_hash(&mac->chip, &hash);
237 }
238
239 static int zd_op_start(struct ieee80211_hw *hw)
240 {
241 struct zd_mac *mac = zd_hw_mac(hw);
242 struct zd_chip *chip = &mac->chip;
243 struct zd_usb *usb = &chip->usb;
244 int r;
245
246 if (!usb->initialized) {
247 r = zd_usb_init_hw(usb);
248 if (r)
249 goto out;
250 }
251
252 r = zd_chip_enable_int(chip);
253 if (r < 0)
254 goto out;
255
256 r = zd_chip_set_basic_rates(chip, CR_RATES_80211B | CR_RATES_80211G);
257 if (r < 0)
258 goto disable_int;
259 r = set_rx_filter(mac);
260 if (r)
261 goto disable_int;
262 r = set_mc_hash(mac);
263 if (r)
264 goto disable_int;
265 r = zd_chip_switch_radio_on(chip);
266 if (r < 0)
267 goto disable_int;
268 r = zd_chip_enable_rxtx(chip);
269 if (r < 0)
270 goto disable_radio;
271 r = zd_chip_enable_hwint(chip);
272 if (r < 0)
273 goto disable_rxtx;
274
275 housekeeping_enable(mac);
276 return 0;
277 disable_rxtx:
278 zd_chip_disable_rxtx(chip);
279 disable_radio:
280 zd_chip_switch_radio_off(chip);
281 disable_int:
282 zd_chip_disable_int(chip);
283 out:
284 return r;
285 }
286
287 static void zd_op_stop(struct ieee80211_hw *hw)
288 {
289 struct zd_mac *mac = zd_hw_mac(hw);
290 struct zd_chip *chip = &mac->chip;
291 struct sk_buff *skb;
292 struct sk_buff_head *ack_wait_queue = &mac->ack_wait_queue;
293
294 /* The order here deliberately is a little different from the open()
295 * method, since we need to make sure there is no opportunity for RX
296 * frames to be processed by mac80211 after we have stopped it.
297 */
298
299 zd_chip_disable_rxtx(chip);
300 housekeeping_disable(mac);
301 flush_workqueue(zd_workqueue);
302
303 zd_chip_disable_hwint(chip);
304 zd_chip_switch_radio_off(chip);
305 zd_chip_disable_int(chip);
306
307
308 while ((skb = skb_dequeue(ack_wait_queue)))
309 dev_kfree_skb_any(skb);
310 }
311
312 /**
313 * zd_mac_tx_status - reports tx status of a packet if required
314 * @hw - a &struct ieee80211_hw pointer
315 * @skb - a sk-buffer
316 * @flags: extra flags to set in the TX status info
317 * @ackssi: ACK signal strength
318 * @success - True for successful transmission of the frame
319 *
320 * This information calls ieee80211_tx_status_irqsafe() if required by the
321 * control information. It copies the control information into the status
322 * information.
323 *
324 * If no status information has been requested, the skb is freed.
325 */
326 static void zd_mac_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb,
327 int ackssi, struct tx_status *tx_status)
328 {
329 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
330 int i;
331 int success = 1, retry = 1;
332 int first_idx;
333 const struct tx_retry_rate *retries;
334
335 ieee80211_tx_info_clear_status(info);
336
337 if (tx_status) {
338 success = !tx_status->failure;
339 retry = tx_status->retry + success;
340 }
341
342 if (success) {
343 /* success */
344 info->flags |= IEEE80211_TX_STAT_ACK;
345 } else {
346 /* failure */
347 info->flags &= ~IEEE80211_TX_STAT_ACK;
348 }
349
350 first_idx = info->status.rates[0].idx;
351 ZD_ASSERT(0<=first_idx && first_idx<ARRAY_SIZE(zd_retry_rates));
352 retries = &zd_retry_rates[first_idx];
353 ZD_ASSERT(0<=retry && retry<=retries->count);
354
355 info->status.rates[0].idx = retries->rate[0];
356 info->status.rates[0].count = 1; // (retry > 1 ? 2 : 1);
357
358 for (i=1; i<IEEE80211_TX_MAX_RATES-1 && i<retry; i++) {
359 info->status.rates[i].idx = retries->rate[i];
360 info->status.rates[i].count = 1; // ((i==retry-1) && success ? 1:2);
361 }
362 for (; i<IEEE80211_TX_MAX_RATES && i<retry; i++) {
363 info->status.rates[i].idx = retries->rate[retry-1];
364 info->status.rates[i].count = 1; // (success ? 1:2);
365 }
366 if (i<IEEE80211_TX_MAX_RATES)
367 info->status.rates[i].idx = -1; /* terminate */
368
369 info->status.ack_signal = ackssi;
370 ieee80211_tx_status_irqsafe(hw, skb);
371 }
372
373 /**
374 * zd_mac_tx_failed - callback for failed frames
375 * @dev: the mac80211 wireless device
376 *
377 * This function is called if a frame couldn't be successfully
378 * transferred. The first frame from the tx queue, will be selected and
379 * reported as error to the upper layers.
380 */
381 void zd_mac_tx_failed(struct urb *urb)
382 {
383 struct ieee80211_hw * hw = zd_usb_to_hw(urb->context);
384 struct zd_mac *mac = zd_hw_mac(hw);
385 struct sk_buff_head *q = &mac->ack_wait_queue;
386 struct sk_buff *skb;
387 struct tx_status *tx_status = (struct tx_status *)urb->transfer_buffer;
388 unsigned long flags;
389 int success = !tx_status->failure;
390 int retry = tx_status->retry + success;
391 int found = 0;
392 int i, position = 0;
393
394 q = &mac->ack_wait_queue;
395 spin_lock_irqsave(&q->lock, flags);
396
397 skb_queue_walk(q, skb) {
398 struct ieee80211_hdr *tx_hdr;
399 struct ieee80211_tx_info *info;
400 int first_idx, final_idx;
401 const struct tx_retry_rate *retries;
402 u8 final_rate;
403
404 position ++;
405
406 /* if the hardware reports a failure and we had a 802.11 ACK
407 * pending, then we skip the first skb when searching for a
408 * matching frame */
409 if (tx_status->failure && mac->ack_pending &&
410 skb_queue_is_first(q, skb)) {
411 continue;
412 }
413
414 tx_hdr = (struct ieee80211_hdr *)skb->data;
415
416 /* we skip all frames not matching the reported destination */
417 if (unlikely(memcmp(tx_hdr->addr1, tx_status->mac, ETH_ALEN))) {
418 continue;
419 }
420
421 /* we skip all frames not matching the reported final rate */
422
423 info = IEEE80211_SKB_CB(skb);
424 first_idx = info->status.rates[0].idx;
425 ZD_ASSERT(0<=first_idx && first_idx<ARRAY_SIZE(zd_retry_rates));
426 retries = &zd_retry_rates[first_idx];
427 if (retry < 0 || retry > retries->count) {
428 continue;
429 }
430
431 ZD_ASSERT(0<=retry && retry<=retries->count);
432 final_idx = retries->rate[retry-1];
433 final_rate = zd_rates[final_idx].hw_value;
434
435 if (final_rate != tx_status->rate) {
436 continue;
437 }
438
439 found = 1;
440 break;
441 }
442
443 if (found) {
444 for (i=1; i<=position; i++) {
445 skb = __skb_dequeue(q);
446 zd_mac_tx_status(hw, skb,
447 mac->ack_pending ? mac->ack_signal : 0,
448 i == position ? tx_status : NULL);
449 mac->ack_pending = 0;
450 }
451 }
452
453 spin_unlock_irqrestore(&q->lock, flags);
454 }
455
456 /**
457 * zd_mac_tx_to_dev - callback for USB layer
458 * @skb: a &sk_buff pointer
459 * @error: error value, 0 if transmission successful
460 *
461 * Informs the MAC layer that the frame has successfully transferred to the
462 * device. If an ACK is required and the transfer to the device has been
463 * successful, the packets are put on the @ack_wait_queue with
464 * the control set removed.
465 */
466 void zd_mac_tx_to_dev(struct sk_buff *skb, int error)
467 {
468 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
469 struct ieee80211_hw *hw = info->rate_driver_data[0];
470 struct zd_mac *mac = zd_hw_mac(hw);
471
472 ieee80211_tx_info_clear_status(info);
473
474 skb_pull(skb, sizeof(struct zd_ctrlset));
475 if (unlikely(error ||
476 (info->flags & IEEE80211_TX_CTL_NO_ACK))) {
477 /*
478 * FIXME : do we need to fill in anything ?
479 */
480 ieee80211_tx_status_irqsafe(hw, skb);
481 } else {
482 struct sk_buff_head *q = &mac->ack_wait_queue;
483
484 skb_queue_tail(q, skb);
485 while (skb_queue_len(q) > ZD_MAC_MAX_ACK_WAITERS) {
486 zd_mac_tx_status(hw, skb_dequeue(q),
487 mac->ack_pending ? mac->ack_signal : 0,
488 NULL);
489 mac->ack_pending = 0;
490 }
491 }
492 }
493
494 static int zd_calc_tx_length_us(u8 *service, u8 zd_rate, u16 tx_length)
495 {
496 /* ZD_PURE_RATE() must be used to remove the modulation type flag of
497 * the zd-rate values.
498 */
499 static const u8 rate_divisor[] = {
500 [ZD_PURE_RATE(ZD_CCK_RATE_1M)] = 1,
501 [ZD_PURE_RATE(ZD_CCK_RATE_2M)] = 2,
502 /* Bits must be doubled. */
503 [ZD_PURE_RATE(ZD_CCK_RATE_5_5M)] = 11,
504 [ZD_PURE_RATE(ZD_CCK_RATE_11M)] = 11,
505 [ZD_PURE_RATE(ZD_OFDM_RATE_6M)] = 6,
506 [ZD_PURE_RATE(ZD_OFDM_RATE_9M)] = 9,
507 [ZD_PURE_RATE(ZD_OFDM_RATE_12M)] = 12,
508 [ZD_PURE_RATE(ZD_OFDM_RATE_18M)] = 18,
509 [ZD_PURE_RATE(ZD_OFDM_RATE_24M)] = 24,
510 [ZD_PURE_RATE(ZD_OFDM_RATE_36M)] = 36,
511 [ZD_PURE_RATE(ZD_OFDM_RATE_48M)] = 48,
512 [ZD_PURE_RATE(ZD_OFDM_RATE_54M)] = 54,
513 };
514
515 u32 bits = (u32)tx_length * 8;
516 u32 divisor;
517
518 divisor = rate_divisor[ZD_PURE_RATE(zd_rate)];
519 if (divisor == 0)
520 return -EINVAL;
521
522 switch (zd_rate) {
523 case ZD_CCK_RATE_5_5M:
524 bits = (2*bits) + 10; /* round up to the next integer */
525 break;
526 case ZD_CCK_RATE_11M:
527 if (service) {
528 u32 t = bits % 11;
529 *service &= ~ZD_PLCP_SERVICE_LENGTH_EXTENSION;
530 if (0 < t && t <= 3) {
531 *service |= ZD_PLCP_SERVICE_LENGTH_EXTENSION;
532 }
533 }
534 bits += 10; /* round up to the next integer */
535 break;
536 }
537
538 return bits/divisor;
539 }
540
541 static void cs_set_control(struct zd_mac *mac, struct zd_ctrlset *cs,
542 struct ieee80211_hdr *header,
543 struct ieee80211_tx_info *info)
544 {
545 /*
546 * CONTROL TODO:
547 * - if backoff needed, enable bit 0
548 * - if burst (backoff not needed) disable bit 0
549 */
550
551 cs->control = 0;
552
553 /* First fragment */
554 if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
555 cs->control |= ZD_CS_NEED_RANDOM_BACKOFF;
556
557 /* No ACK expected (multicast, etc.) */
558 if (info->flags & IEEE80211_TX_CTL_NO_ACK)
559 cs->control |= ZD_CS_NO_ACK;
560
561 /* PS-POLL */
562 if (ieee80211_is_pspoll(header->frame_control))
563 cs->control |= ZD_CS_PS_POLL_FRAME;
564
565 if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
566 cs->control |= ZD_CS_RTS;
567
568 if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
569 cs->control |= ZD_CS_SELF_CTS;
570
571 /* FIXME: Management frame? */
572 }
573
574 static int zd_mac_config_beacon(struct ieee80211_hw *hw, struct sk_buff *beacon)
575 {
576 struct zd_mac *mac = zd_hw_mac(hw);
577 int r;
578 u32 tmp, j = 0;
579 /* 4 more bytes for tail CRC */
580 u32 full_len = beacon->len + 4;
581
582 r = zd_iowrite32(&mac->chip, CR_BCN_FIFO_SEMAPHORE, 0);
583 if (r < 0)
584 return r;
585 r = zd_ioread32(&mac->chip, CR_BCN_FIFO_SEMAPHORE, &tmp);
586 if (r < 0)
587 return r;
588
589 while (tmp & 0x2) {
590 r = zd_ioread32(&mac->chip, CR_BCN_FIFO_SEMAPHORE, &tmp);
591 if (r < 0)
592 return r;
593 if ((++j % 100) == 0) {
594 printk(KERN_ERR "CR_BCN_FIFO_SEMAPHORE not ready\n");
595 if (j >= 500) {
596 printk(KERN_ERR "Giving up beacon config.\n");
597 return -ETIMEDOUT;
598 }
599 }
600 msleep(1);
601 }
602
603 r = zd_iowrite32(&mac->chip, CR_BCN_FIFO, full_len - 1);
604 if (r < 0)
605 return r;
606 if (zd_chip_is_zd1211b(&mac->chip)) {
607 r = zd_iowrite32(&mac->chip, CR_BCN_LENGTH, full_len - 1);
608 if (r < 0)
609 return r;
610 }
611
612 for (j = 0 ; j < beacon->len; j++) {
613 r = zd_iowrite32(&mac->chip, CR_BCN_FIFO,
614 *((u8 *)(beacon->data + j)));
615 if (r < 0)
616 return r;
617 }
618
619 for (j = 0; j < 4; j++) {
620 r = zd_iowrite32(&mac->chip, CR_BCN_FIFO, 0x0);
621 if (r < 0)
622 return r;
623 }
624
625 r = zd_iowrite32(&mac->chip, CR_BCN_FIFO_SEMAPHORE, 1);
626 if (r < 0)
627 return r;
628
629 /* 802.11b/g 2.4G CCK 1Mb
630 * 802.11a, not yet implemented, uses different values (see GPL vendor
631 * driver)
632 */
633 return zd_iowrite32(&mac->chip, CR_BCN_PLCP_CFG, 0x00000400 |
634 (full_len << 19));
635 }
636
637 static int fill_ctrlset(struct zd_mac *mac,
638 struct sk_buff *skb)
639 {
640 int r;
641 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
642 unsigned int frag_len = skb->len + FCS_LEN;
643 unsigned int packet_length;
644 struct ieee80211_rate *txrate;
645 struct zd_ctrlset *cs = (struct zd_ctrlset *)
646 skb_push(skb, sizeof(struct zd_ctrlset));
647 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
648
649 ZD_ASSERT(frag_len <= 0xffff);
650
651 txrate = ieee80211_get_tx_rate(mac->hw, info);
652
653 cs->modulation = txrate->hw_value;
654 if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
655 cs->modulation = txrate->hw_value_short;
656
657 cs->tx_length = cpu_to_le16(frag_len);
658
659 cs_set_control(mac, cs, hdr, info);
660
661 packet_length = frag_len + sizeof(struct zd_ctrlset) + 10;
662 ZD_ASSERT(packet_length <= 0xffff);
663 /* ZD1211B: Computing the length difference this way, gives us
664 * flexibility to compute the packet length.
665 */
666 cs->packet_length = cpu_to_le16(zd_chip_is_zd1211b(&mac->chip) ?
667 packet_length - frag_len : packet_length);
668
669 /*
670 * CURRENT LENGTH:
671 * - transmit frame length in microseconds
672 * - seems to be derived from frame length
673 * - see Cal_Us_Service() in zdinlinef.h
674 * - if macp->bTxBurstEnable is enabled, then multiply by 4
675 * - bTxBurstEnable is never set in the vendor driver
676 *
677 * SERVICE:
678 * - "for PLCP configuration"
679 * - always 0 except in some situations at 802.11b 11M
680 * - see line 53 of zdinlinef.h
681 */
682 cs->service = 0;
683 r = zd_calc_tx_length_us(&cs->service, ZD_RATE(cs->modulation),
684 le16_to_cpu(cs->tx_length));
685 if (r < 0)
686 return r;
687 cs->current_length = cpu_to_le16(r);
688 cs->next_frame_length = 0;
689
690 return 0;
691 }
692
693 /**
694 * zd_op_tx - transmits a network frame to the device
695 *
696 * @dev: mac80211 hardware device
697 * @skb: socket buffer
698 * @control: the control structure
699 *
700 * This function transmit an IEEE 802.11 network frame to the device. The
701 * control block of the skbuff will be initialized. If necessary the incoming
702 * mac80211 queues will be stopped.
703 */
704 static int zd_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
705 {
706 struct zd_mac *mac = zd_hw_mac(hw);
707 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
708 int r;
709
710 r = fill_ctrlset(mac, skb);
711 if (r)
712 goto fail;
713
714 info->rate_driver_data[0] = hw;
715
716 r = zd_usb_tx(&mac->chip.usb, skb);
717 if (r)
718 goto fail;
719 return 0;
720
721 fail:
722 dev_kfree_skb(skb);
723 return 0;
724 }
725
726 /**
727 * filter_ack - filters incoming packets for acknowledgements
728 * @dev: the mac80211 device
729 * @rx_hdr: received header
730 * @stats: the status for the received packet
731 *
732 * This functions looks for ACK packets and tries to match them with the
733 * frames in the tx queue. If a match is found the frame will be dequeued and
734 * the upper layers is informed about the successful transmission. If
735 * mac80211 queues have been stopped and the number of frames still to be
736 * transmitted is low the queues will be opened again.
737 *
738 * Returns 1 if the frame was an ACK, 0 if it was ignored.
739 */
740 static int filter_ack(struct ieee80211_hw *hw, struct ieee80211_hdr *rx_hdr,
741 struct ieee80211_rx_status *stats)
742 {
743 struct zd_mac *mac = zd_hw_mac(hw);
744 struct sk_buff *skb;
745 struct sk_buff_head *q;
746 unsigned long flags;
747 int found = 0;
748 int i, position = 0;
749
750 if (!ieee80211_is_ack(rx_hdr->frame_control))
751 return 0;
752
753 q = &mac->ack_wait_queue;
754 spin_lock_irqsave(&q->lock, flags);
755 skb_queue_walk(q, skb) {
756 struct ieee80211_hdr *tx_hdr;
757
758 position ++;
759
760 if (mac->ack_pending && skb_queue_is_first(q, skb))
761 continue;
762
763 tx_hdr = (struct ieee80211_hdr *)skb->data;
764 if (likely(!memcmp(tx_hdr->addr2, rx_hdr->addr1, ETH_ALEN)))
765 {
766 found = 1;
767 break;
768 }
769 }
770
771 if (found) {
772 for (i=1; i<position; i++) {
773 skb = __skb_dequeue(q);
774 zd_mac_tx_status(hw, skb,
775 mac->ack_pending ? mac->ack_signal : 0,
776 NULL);
777 mac->ack_pending = 0;
778 }
779
780 mac->ack_pending = 1;
781 mac->ack_signal = stats->signal;
782 }
783
784 spin_unlock_irqrestore(&q->lock, flags);
785 return 1;
786 }
787
788 int zd_mac_rx(struct ieee80211_hw *hw, const u8 *buffer, unsigned int length)
789 {
790 struct zd_mac *mac = zd_hw_mac(hw);
791 struct ieee80211_rx_status stats;
792 const struct rx_status *status;
793 struct sk_buff *skb;
794 int bad_frame = 0;
795 __le16 fc;
796 int need_padding;
797 int i;
798 u8 rate;
799
800 if (length < ZD_PLCP_HEADER_SIZE + 10 /* IEEE80211_1ADDR_LEN */ +
801 FCS_LEN + sizeof(struct rx_status))
802 return -EINVAL;
803
804 memset(&stats, 0, sizeof(stats));
805
806 /* Note about pass_failed_fcs and pass_ctrl access below:
807 * mac locking intentionally omitted here, as this is the only unlocked
808 * reader and the only writer is configure_filter. Plus, if there were
809 * any races accessing these variables, it wouldn't really matter.
810 * If mac80211 ever provides a way for us to access filter flags
811 * from outside configure_filter, we could improve on this. Also, this
812 * situation may change once we implement some kind of DMA-into-skb
813 * RX path. */
814
815 /* Caller has to ensure that length >= sizeof(struct rx_status). */
816 status = (struct rx_status *)
817 (buffer + (length - sizeof(struct rx_status)));
818 if (status->frame_status & ZD_RX_ERROR) {
819 if (mac->pass_failed_fcs &&
820 (status->frame_status & ZD_RX_CRC32_ERROR)) {
821 stats.flag |= RX_FLAG_FAILED_FCS_CRC;
822 bad_frame = 1;
823 } else {
824 return -EINVAL;
825 }
826 }
827
828 stats.freq = zd_channels[_zd_chip_get_channel(&mac->chip) - 1].center_freq;
829 stats.band = IEEE80211_BAND_2GHZ;
830 stats.signal = status->signal_strength;
831
832 rate = zd_rx_rate(buffer, status);
833
834 /* todo: return index in the big switches in zd_rx_rate instead */
835 for (i = 0; i < mac->band.n_bitrates; i++)
836 if (rate == mac->band.bitrates[i].hw_value)
837 stats.rate_idx = i;
838
839 length -= ZD_PLCP_HEADER_SIZE + sizeof(struct rx_status);
840 buffer += ZD_PLCP_HEADER_SIZE;
841
842 /* Except for bad frames, filter each frame to see if it is an ACK, in
843 * which case our internal TX tracking is updated. Normally we then
844 * bail here as there's no need to pass ACKs on up to the stack, but
845 * there is also the case where the stack has requested us to pass
846 * control frames on up (pass_ctrl) which we must consider. */
847 if (!bad_frame &&
848 filter_ack(hw, (struct ieee80211_hdr *)buffer, &stats)
849 && !mac->pass_ctrl)
850 return 0;
851
852 fc = get_unaligned((__le16*)buffer);
853 need_padding = ieee80211_is_data_qos(fc) ^ ieee80211_has_a4(fc);
854
855 skb = dev_alloc_skb(length + (need_padding ? 2 : 0));
856 if (skb == NULL)
857 return -ENOMEM;
858 if (need_padding) {
859 /* Make sure the the payload data is 4 byte aligned. */
860 skb_reserve(skb, 2);
861 }
862
863 /* FIXME : could we avoid this big memcpy ? */
864 memcpy(skb_put(skb, length), buffer, length);
865
866 memcpy(IEEE80211_SKB_RXCB(skb), &stats, sizeof(stats));
867 ieee80211_rx_irqsafe(hw, skb);
868 return 0;
869 }
870
871 static int zd_op_add_interface(struct ieee80211_hw *hw,
872 struct ieee80211_vif *vif)
873 {
874 struct zd_mac *mac = zd_hw_mac(hw);
875
876 /* using NL80211_IFTYPE_UNSPECIFIED to indicate no mode selected */
877 if (mac->type != NL80211_IFTYPE_UNSPECIFIED)
878 return -EOPNOTSUPP;
879
880 switch (vif->type) {
881 case NL80211_IFTYPE_MONITOR:
882 case NL80211_IFTYPE_MESH_POINT:
883 case NL80211_IFTYPE_STATION:
884 case NL80211_IFTYPE_ADHOC:
885 mac->type = vif->type;
886 break;
887 default:
888 return -EOPNOTSUPP;
889 }
890
891 return zd_write_mac_addr(&mac->chip, vif->addr);
892 }
893
894 static void zd_op_remove_interface(struct ieee80211_hw *hw,
895 struct ieee80211_vif *vif)
896 {
897 struct zd_mac *mac = zd_hw_mac(hw);
898 mac->type = NL80211_IFTYPE_UNSPECIFIED;
899 zd_set_beacon_interval(&mac->chip, 0);
900 zd_write_mac_addr(&mac->chip, NULL);
901 }
902
903 static int zd_op_config(struct ieee80211_hw *hw, u32 changed)
904 {
905 struct zd_mac *mac = zd_hw_mac(hw);
906 struct ieee80211_conf *conf = &hw->conf;
907
908 return zd_chip_set_channel(&mac->chip, conf->channel->hw_value);
909 }
910
911 static void zd_process_intr(struct work_struct *work)
912 {
913 u16 int_status;
914 struct zd_mac *mac = container_of(work, struct zd_mac, process_intr);
915
916 int_status = le16_to_cpu(*(__le16 *)(mac->intr_buffer+4));
917 if (int_status & INT_CFG_NEXT_BCN)
918 dev_dbg_f_limit(zd_mac_dev(mac), "INT_CFG_NEXT_BCN\n");
919 else
920 dev_dbg_f(zd_mac_dev(mac), "Unsupported interrupt\n");
921
922 zd_chip_enable_hwint(&mac->chip);
923 }
924
925
926 static void set_multicast_hash_handler(struct work_struct *work)
927 {
928 struct zd_mac *mac =
929 container_of(work, struct zd_mac, set_multicast_hash_work);
930 struct zd_mc_hash hash;
931
932 spin_lock_irq(&mac->lock);
933 hash = mac->multicast_hash;
934 spin_unlock_irq(&mac->lock);
935
936 zd_chip_set_multicast_hash(&mac->chip, &hash);
937 }
938
939 static void set_rx_filter_handler(struct work_struct *work)
940 {
941 struct zd_mac *mac =
942 container_of(work, struct zd_mac, set_rx_filter_work);
943 int r;
944
945 dev_dbg_f(zd_mac_dev(mac), "\n");
946 r = set_rx_filter(mac);
947 if (r)
948 dev_err(zd_mac_dev(mac), "set_rx_filter_handler error %d\n", r);
949 }
950
951 static u64 zd_op_prepare_multicast(struct ieee80211_hw *hw,
952 int mc_count, struct dev_addr_list *mclist)
953 {
954 struct zd_mac *mac = zd_hw_mac(hw);
955 struct zd_mc_hash hash;
956 int i;
957
958 zd_mc_clear(&hash);
959
960 for (i = 0; i < mc_count; i++) {
961 if (!mclist)
962 break;
963 dev_dbg_f(zd_mac_dev(mac), "mc addr %pM\n", mclist->dmi_addr);
964 zd_mc_add_addr(&hash, mclist->dmi_addr);
965 mclist = mclist->next;
966 }
967
968 return hash.low | ((u64)hash.high << 32);
969 }
970
971 #define SUPPORTED_FIF_FLAGS \
972 (FIF_PROMISC_IN_BSS | FIF_ALLMULTI | FIF_FCSFAIL | FIF_CONTROL | \
973 FIF_OTHER_BSS | FIF_BCN_PRBRESP_PROMISC)
974 static void zd_op_configure_filter(struct ieee80211_hw *hw,
975 unsigned int changed_flags,
976 unsigned int *new_flags,
977 u64 multicast)
978 {
979 struct zd_mc_hash hash = {
980 .low = multicast,
981 .high = multicast >> 32,
982 };
983 struct zd_mac *mac = zd_hw_mac(hw);
984 unsigned long flags;
985
986 /* Only deal with supported flags */
987 changed_flags &= SUPPORTED_FIF_FLAGS;
988 *new_flags &= SUPPORTED_FIF_FLAGS;
989
990 /*
991 * If multicast parameter (as returned by zd_op_prepare_multicast)
992 * has changed, no bit in changed_flags is set. To handle this
993 * situation, we do not return if changed_flags is 0. If we do so,
994 * we will have some issue with IPv6 which uses multicast for link
995 * layer address resolution.
996 */
997 if (*new_flags & (FIF_PROMISC_IN_BSS | FIF_ALLMULTI))
998 zd_mc_add_all(&hash);
999
1000 spin_lock_irqsave(&mac->lock, flags);
1001 mac->pass_failed_fcs = !!(*new_flags & FIF_FCSFAIL);
1002 mac->pass_ctrl = !!(*new_flags & FIF_CONTROL);
1003 mac->multicast_hash = hash;
1004 spin_unlock_irqrestore(&mac->lock, flags);
1005
1006 /* XXX: these can be called here now, can sleep now! */
1007 queue_work(zd_workqueue, &mac->set_multicast_hash_work);
1008
1009 if (changed_flags & FIF_CONTROL)
1010 queue_work(zd_workqueue, &mac->set_rx_filter_work);
1011
1012 /* no handling required for FIF_OTHER_BSS as we don't currently
1013 * do BSSID filtering */
1014 /* FIXME: in future it would be nice to enable the probe response
1015 * filter (so that the driver doesn't see them) until
1016 * FIF_BCN_PRBRESP_PROMISC is set. however due to atomicity here, we'd
1017 * have to schedule work to enable prbresp reception, which might
1018 * happen too late. For now we'll just listen and forward them all the
1019 * time. */
1020 }
1021
1022 static void set_rts_cts_work(struct work_struct *work)
1023 {
1024 struct zd_mac *mac =
1025 container_of(work, struct zd_mac, set_rts_cts_work);
1026 unsigned long flags;
1027 unsigned int short_preamble;
1028
1029 mutex_lock(&mac->chip.mutex);
1030
1031 spin_lock_irqsave(&mac->lock, flags);
1032 mac->updating_rts_rate = 0;
1033 short_preamble = mac->short_preamble;
1034 spin_unlock_irqrestore(&mac->lock, flags);
1035
1036 zd_chip_set_rts_cts_rate_locked(&mac->chip, short_preamble);
1037 mutex_unlock(&mac->chip.mutex);
1038 }
1039
1040 static void zd_op_bss_info_changed(struct ieee80211_hw *hw,
1041 struct ieee80211_vif *vif,
1042 struct ieee80211_bss_conf *bss_conf,
1043 u32 changes)
1044 {
1045 struct zd_mac *mac = zd_hw_mac(hw);
1046 unsigned long flags;
1047 int associated;
1048
1049 dev_dbg_f(zd_mac_dev(mac), "changes: %x\n", changes);
1050
1051 if (mac->type == NL80211_IFTYPE_MESH_POINT ||
1052 mac->type == NL80211_IFTYPE_ADHOC) {
1053 associated = true;
1054 if (changes & BSS_CHANGED_BEACON) {
1055 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1056
1057 if (beacon) {
1058 zd_mac_config_beacon(hw, beacon);
1059 kfree_skb(beacon);
1060 }
1061 }
1062
1063 if (changes & BSS_CHANGED_BEACON_ENABLED) {
1064 u32 interval;
1065
1066 if (bss_conf->enable_beacon)
1067 interval = BCN_MODE_IBSS |
1068 bss_conf->beacon_int;
1069 else
1070 interval = 0;
1071
1072 zd_set_beacon_interval(&mac->chip, interval);
1073 }
1074 } else
1075 associated = is_valid_ether_addr(bss_conf->bssid);
1076
1077 spin_lock_irq(&mac->lock);
1078 mac->associated = associated;
1079 spin_unlock_irq(&mac->lock);
1080
1081 /* TODO: do hardware bssid filtering */
1082
1083 if (changes & BSS_CHANGED_ERP_PREAMBLE) {
1084 spin_lock_irqsave(&mac->lock, flags);
1085 mac->short_preamble = bss_conf->use_short_preamble;
1086 if (!mac->updating_rts_rate) {
1087 mac->updating_rts_rate = 1;
1088 /* FIXME: should disable TX here, until work has
1089 * completed and RTS_CTS reg is updated */
1090 queue_work(zd_workqueue, &mac->set_rts_cts_work);
1091 }
1092 spin_unlock_irqrestore(&mac->lock, flags);
1093 }
1094 }
1095
1096 static u64 zd_op_get_tsf(struct ieee80211_hw *hw)
1097 {
1098 struct zd_mac *mac = zd_hw_mac(hw);
1099 return zd_chip_get_tsf(&mac->chip);
1100 }
1101
1102 static const struct ieee80211_ops zd_ops = {
1103 .tx = zd_op_tx,
1104 .start = zd_op_start,
1105 .stop = zd_op_stop,
1106 .add_interface = zd_op_add_interface,
1107 .remove_interface = zd_op_remove_interface,
1108 .config = zd_op_config,
1109 .prepare_multicast = zd_op_prepare_multicast,
1110 .configure_filter = zd_op_configure_filter,
1111 .bss_info_changed = zd_op_bss_info_changed,
1112 .get_tsf = zd_op_get_tsf,
1113 };
1114
1115 struct ieee80211_hw *zd_mac_alloc_hw(struct usb_interface *intf)
1116 {
1117 struct zd_mac *mac;
1118 struct ieee80211_hw *hw;
1119
1120 hw = ieee80211_alloc_hw(sizeof(struct zd_mac), &zd_ops);
1121 if (!hw) {
1122 dev_dbg_f(&intf->dev, "out of memory\n");
1123 return NULL;
1124 }
1125
1126 mac = zd_hw_mac(hw);
1127
1128 memset(mac, 0, sizeof(*mac));
1129 spin_lock_init(&mac->lock);
1130 mac->hw = hw;
1131
1132 mac->type = NL80211_IFTYPE_UNSPECIFIED;
1133
1134 memcpy(mac->channels, zd_channels, sizeof(zd_channels));
1135 memcpy(mac->rates, zd_rates, sizeof(zd_rates));
1136 mac->band.n_bitrates = ARRAY_SIZE(zd_rates);
1137 mac->band.bitrates = mac->rates;
1138 mac->band.n_channels = ARRAY_SIZE(zd_channels);
1139 mac->band.channels = mac->channels;
1140
1141 hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &mac->band;
1142
1143 hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
1144 IEEE80211_HW_SIGNAL_UNSPEC;
1145
1146 hw->wiphy->interface_modes =
1147 BIT(NL80211_IFTYPE_MESH_POINT) |
1148 BIT(NL80211_IFTYPE_STATION) |
1149 BIT(NL80211_IFTYPE_ADHOC);
1150
1151 hw->max_signal = 100;
1152 hw->queues = 1;
1153 hw->extra_tx_headroom = sizeof(struct zd_ctrlset);
1154
1155 /*
1156 * Tell mac80211 that we support multi rate retries
1157 */
1158 hw->max_rates = IEEE80211_TX_MAX_RATES;
1159 hw->max_rate_tries = 18; /* 9 rates * 2 retries/rate */
1160
1161 skb_queue_head_init(&mac->ack_wait_queue);
1162 mac->ack_pending = 0;
1163
1164 zd_chip_init(&mac->chip, hw, intf);
1165 housekeeping_init(mac);
1166 INIT_WORK(&mac->set_multicast_hash_work, set_multicast_hash_handler);
1167 INIT_WORK(&mac->set_rts_cts_work, set_rts_cts_work);
1168 INIT_WORK(&mac->set_rx_filter_work, set_rx_filter_handler);
1169 INIT_WORK(&mac->process_intr, zd_process_intr);
1170
1171 SET_IEEE80211_DEV(hw, &intf->dev);
1172 return hw;
1173 }
1174
1175 #define LINK_LED_WORK_DELAY HZ
1176
1177 static void link_led_handler(struct work_struct *work)
1178 {
1179 struct zd_mac *mac =
1180 container_of(work, struct zd_mac, housekeeping.link_led_work.work);
1181 struct zd_chip *chip = &mac->chip;
1182 int is_associated;
1183 int r;
1184
1185 spin_lock_irq(&mac->lock);
1186 is_associated = mac->associated;
1187 spin_unlock_irq(&mac->lock);
1188
1189 r = zd_chip_control_leds(chip,
1190 is_associated ? ZD_LED_ASSOCIATED : ZD_LED_SCANNING);
1191 if (r)
1192 dev_dbg_f(zd_mac_dev(mac), "zd_chip_control_leds error %d\n", r);
1193
1194 queue_delayed_work(zd_workqueue, &mac->housekeeping.link_led_work,
1195 LINK_LED_WORK_DELAY);
1196 }
1197
1198 static void housekeeping_init(struct zd_mac *mac)
1199 {
1200 INIT_DELAYED_WORK(&mac->housekeeping.link_led_work, link_led_handler);
1201 }
1202
1203 static void housekeeping_enable(struct zd_mac *mac)
1204 {
1205 dev_dbg_f(zd_mac_dev(mac), "\n");
1206 queue_delayed_work(zd_workqueue, &mac->housekeeping.link_led_work,
1207 0);
1208 }
1209
1210 static void housekeeping_disable(struct zd_mac *mac)
1211 {
1212 dev_dbg_f(zd_mac_dev(mac), "\n");
1213 cancel_rearming_delayed_workqueue(zd_workqueue,
1214 &mac->housekeeping.link_led_work);
1215 zd_chip_control_leds(&mac->chip, ZD_LED_OFF);
1216 }
x86 "subsystem" repository