aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net
diff options
context:
space:
mode:
authorDaniel Drake <dsd@gentoo.org>2007-11-19 10:00:29 -0500
committerDavid S. Miller <davem@davemloft.net>2008-01-28 18:04:47 -0500
commit459c51ad6e1fc19e91a53798358433d3c08cd09d (patch)
treefb86feacf1b229cb4ab6b36b4d1deaf4983b1e45 /drivers/net
parent0765af4493193149505f118d04d9300f0a15c8f5 (diff)
zd1211rw: port to mac80211
This seems to be working smoothly now. Let's not hold back the mac80211 transition any further. This patch ports the existing driver from softmac to mac80211. Many thanks to everyone who helped out with the porting efforts. Signed-off-by: Daniel Drake <dsd@gentoo.org> Signed-off-by: John W. Linville <linville@tuxdriver.com>
Diffstat (limited to 'drivers/net')
-rw-r--r--drivers/net/wireless/zd1211rw/Kconfig7
-rw-r--r--drivers/net/wireless/zd1211rw/Makefile3
-rw-r--r--drivers/net/wireless/zd1211rw/zd_chip.c121
-rw-r--r--drivers/net/wireless/zd1211rw/zd_chip.h55
-rw-r--r--drivers/net/wireless/zd1211rw/zd_ieee80211.c191
-rw-r--r--drivers/net/wireless/zd1211rw/zd_ieee80211.h29
-rw-r--r--drivers/net/wireless/zd1211rw/zd_mac.c1536
-rw-r--r--drivers/net/wireless/zd1211rw/zd_mac.h112
-rw-r--r--drivers/net/wireless/zd1211rw/zd_netdev.c264
-rw-r--r--drivers/net/wireless/zd1211rw/zd_netdev.h45
-rw-r--r--drivers/net/wireless/zd1211rw/zd_usb.c282
-rw-r--r--drivers/net/wireless/zd1211rw/zd_usb.h31
12 files changed, 1008 insertions, 1668 deletions
diff --git a/drivers/net/wireless/zd1211rw/Kconfig b/drivers/net/wireless/zd1211rw/Kconfig
index d1ab24a95630..74b31eafe72d 100644
--- a/drivers/net/wireless/zd1211rw/Kconfig
+++ b/drivers/net/wireless/zd1211rw/Kconfig
@@ -1,14 +1,13 @@
1config ZD1211RW 1config ZD1211RW
2 tristate "ZyDAS ZD1211/ZD1211B USB-wireless support" 2 tristate "ZyDAS ZD1211/ZD1211B USB-wireless support"
3 depends on USB && IEEE80211_SOFTMAC && WLAN_80211 && EXPERIMENTAL 3 depends on USB && MAC80211 && WLAN_80211 && EXPERIMENTAL
4 select WIRELESS_EXT
5 select FW_LOADER 4 select FW_LOADER
6 ---help--- 5 ---help---
7 This is an experimental driver for the ZyDAS ZD1211/ZD1211B wireless 6 This is an experimental driver for the ZyDAS ZD1211/ZD1211B wireless
8 chip, present in many USB-wireless adapters. 7 chip, present in many USB-wireless adapters.
9 8
10 Device firmware is required alongside this driver. You can download the 9 Device firmware is required alongside this driver. You can download
11 firmware distribution from http://zd1211.ath.cx/get-firmware 10 the firmware distribution from http://zd1211.ath.cx/get-firmware
12 11
13config ZD1211RW_DEBUG 12config ZD1211RW_DEBUG
14 bool "ZyDAS ZD1211 debugging" 13 bool "ZyDAS ZD1211 debugging"
diff --git a/drivers/net/wireless/zd1211rw/Makefile b/drivers/net/wireless/zd1211rw/Makefile
index 7a2f2a98edab..cc36126cee88 100644
--- a/drivers/net/wireless/zd1211rw/Makefile
+++ b/drivers/net/wireless/zd1211rw/Makefile
@@ -1,7 +1,6 @@
1obj-$(CONFIG_ZD1211RW) += zd1211rw.o 1obj-$(CONFIG_ZD1211RW) += zd1211rw.o
2 2
3zd1211rw-objs := zd_chip.o zd_ieee80211.o \ 3zd1211rw-objs := zd_chip.o zd_ieee80211.o zd_mac.o \
4 zd_mac.o zd_netdev.o \
5 zd_rf_al2230.o zd_rf_rf2959.o \ 4 zd_rf_al2230.o zd_rf_rf2959.o \
6 zd_rf_al7230b.o zd_rf_uw2453.o \ 5 zd_rf_al7230b.o zd_rf_uw2453.o \
7 zd_rf.o zd_usb.o 6 zd_rf.o zd_usb.o
diff --git a/drivers/net/wireless/zd1211rw/zd_chip.c b/drivers/net/wireless/zd1211rw/zd_chip.c
index f831b68f1b9c..ef9527c978b7 100644
--- a/drivers/net/wireless/zd1211rw/zd_chip.c
+++ b/drivers/net/wireless/zd1211rw/zd_chip.c
@@ -30,12 +30,12 @@
30#include "zd_rf.h" 30#include "zd_rf.h"
31 31
32void zd_chip_init(struct zd_chip *chip, 32void zd_chip_init(struct zd_chip *chip,
33 struct net_device *netdev, 33 struct ieee80211_hw *hw,
34 struct usb_interface *intf) 34 struct usb_interface *intf)
35{ 35{
36 memset(chip, 0, sizeof(*chip)); 36 memset(chip, 0, sizeof(*chip));
37 mutex_init(&chip->mutex); 37 mutex_init(&chip->mutex);
38 zd_usb_init(&chip->usb, netdev, intf); 38 zd_usb_init(&chip->usb, hw, intf);
39 zd_rf_init(&chip->rf); 39 zd_rf_init(&chip->rf);
40} 40}
41 41
@@ -50,7 +50,7 @@ void zd_chip_clear(struct zd_chip *chip)
50 50
51static int scnprint_mac_oui(struct zd_chip *chip, char *buffer, size_t size) 51static int scnprint_mac_oui(struct zd_chip *chip, char *buffer, size_t size)
52{ 52{
53 u8 *addr = zd_usb_to_netdev(&chip->usb)->dev_addr; 53 u8 *addr = zd_mac_get_perm_addr(zd_chip_to_mac(chip));
54 return scnprintf(buffer, size, "%02x-%02x-%02x", 54 return scnprintf(buffer, size, "%02x-%02x-%02x",
55 addr[0], addr[1], addr[2]); 55 addr[0], addr[1], addr[2]);
56} 56}
@@ -378,15 +378,18 @@ int zd_write_mac_addr(struct zd_chip *chip, const u8 *mac_addr)
378 }; 378 };
379 DECLARE_MAC_BUF(mac); 379 DECLARE_MAC_BUF(mac);
380 380
381 reqs[0].value = (mac_addr[3] << 24) 381 if (mac_addr) {
382 | (mac_addr[2] << 16) 382 reqs[0].value = (mac_addr[3] << 24)
383 | (mac_addr[1] << 8) 383 | (mac_addr[2] << 16)
384 | mac_addr[0]; 384 | (mac_addr[1] << 8)
385 reqs[1].value = (mac_addr[5] << 8) 385 | mac_addr[0];
386 | mac_addr[4]; 386 reqs[1].value = (mac_addr[5] << 8)
387 387 | mac_addr[4];
388 dev_dbg_f(zd_chip_dev(chip), 388 dev_dbg_f(zd_chip_dev(chip),
389 "mac addr %s\n", print_mac(mac, mac_addr)); 389 "mac addr %s\n", print_mac(mac, mac_addr));
390 } else {
391 dev_dbg_f(zd_chip_dev(chip), "set NULL mac\n");
392 }
390 393
391 mutex_lock(&chip->mutex); 394 mutex_lock(&chip->mutex);
392 r = zd_iowrite32a_locked(chip, reqs, ARRAY_SIZE(reqs)); 395 r = zd_iowrite32a_locked(chip, reqs, ARRAY_SIZE(reqs));
@@ -980,7 +983,7 @@ static int print_fw_version(struct zd_chip *chip)
980 return 0; 983 return 0;
981} 984}
982 985
983static int set_mandatory_rates(struct zd_chip *chip, enum ieee80211_std std) 986static int set_mandatory_rates(struct zd_chip *chip, int mode)
984{ 987{
985 u32 rates; 988 u32 rates;
986 ZD_ASSERT(mutex_is_locked(&chip->mutex)); 989 ZD_ASSERT(mutex_is_locked(&chip->mutex));
@@ -988,11 +991,11 @@ static int set_mandatory_rates(struct zd_chip *chip, enum ieee80211_std std)
988 * that the device is supporting. Until further notice we should try 991 * that the device is supporting. Until further notice we should try
989 * to support 802.11g also for full speed USB. 992 * to support 802.11g also for full speed USB.
990 */ 993 */
991 switch (std) { 994 switch (mode) {
992 case IEEE80211B: 995 case MODE_IEEE80211B:
993 rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M; 996 rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M;
994 break; 997 break;
995 case IEEE80211G: 998 case MODE_IEEE80211G:
996 rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M| 999 rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M|
997 CR_RATE_6M|CR_RATE_12M|CR_RATE_24M; 1000 CR_RATE_6M|CR_RATE_12M|CR_RATE_24M;
998 break; 1001 break;
@@ -1003,24 +1006,17 @@ static int set_mandatory_rates(struct zd_chip *chip, enum ieee80211_std std)
1003} 1006}
1004 1007
1005int zd_chip_set_rts_cts_rate_locked(struct zd_chip *chip, 1008int zd_chip_set_rts_cts_rate_locked(struct zd_chip *chip,
1006 u8 rts_rate, int preamble) 1009 int preamble)
1007{ 1010{
1008 int rts_mod = ZD_RX_CCK;
1009 u32 value = 0; 1011 u32 value = 0;
1010 1012
1011 /* Modulation bit */ 1013 dev_dbg_f(zd_chip_dev(chip), "preamble=%x\n", preamble);
1012 if (ZD_MODULATION_TYPE(rts_rate) == ZD_OFDM)
1013 rts_mod = ZD_RX_OFDM;
1014
1015 dev_dbg_f(zd_chip_dev(chip), "rts_rate=%x preamble=%x\n",
1016 rts_rate, preamble);
1017
1018 value |= ZD_PURE_RATE(rts_rate) << RTSCTS_SH_RTS_RATE;
1019 value |= rts_mod << RTSCTS_SH_RTS_MOD_TYPE;
1020 value |= preamble << RTSCTS_SH_RTS_PMB_TYPE; 1014 value |= preamble << RTSCTS_SH_RTS_PMB_TYPE;
1021 value |= preamble << RTSCTS_SH_CTS_PMB_TYPE; 1015 value |= preamble << RTSCTS_SH_CTS_PMB_TYPE;
1022 1016
1023 /* We always send 11M self-CTS messages, like the vendor driver. */ 1017 /* We always send 11M RTS/self-CTS messages, like the vendor driver. */
1018 value |= ZD_PURE_RATE(ZD_CCK_RATE_11M) << RTSCTS_SH_RTS_RATE;
1019 value |= ZD_RX_CCK << RTSCTS_SH_RTS_MOD_TYPE;
1024 value |= ZD_PURE_RATE(ZD_CCK_RATE_11M) << RTSCTS_SH_CTS_RATE; 1020 value |= ZD_PURE_RATE(ZD_CCK_RATE_11M) << RTSCTS_SH_CTS_RATE;
1025 value |= ZD_RX_CCK << RTSCTS_SH_CTS_MOD_TYPE; 1021 value |= ZD_RX_CCK << RTSCTS_SH_CTS_MOD_TYPE;
1026 1022
@@ -1109,7 +1105,7 @@ int zd_chip_init_hw(struct zd_chip *chip)
1109 * It might be discussed, whether we should suppport pure b mode for 1105 * It might be discussed, whether we should suppport pure b mode for
1110 * full speed USB. 1106 * full speed USB.
1111 */ 1107 */
1112 r = set_mandatory_rates(chip, IEEE80211G); 1108 r = set_mandatory_rates(chip, MODE_IEEE80211G);
1113 if (r) 1109 if (r)
1114 goto out; 1110 goto out;
1115 /* Disabling interrupts is certainly a smart thing here. 1111 /* Disabling interrupts is certainly a smart thing here.
@@ -1320,12 +1316,17 @@ out:
1320 return r; 1316 return r;
1321} 1317}
1322 1318
1323int zd_chip_set_basic_rates_locked(struct zd_chip *chip, u16 cr_rates) 1319int zd_chip_set_basic_rates(struct zd_chip *chip, u16 cr_rates)
1324{ 1320{
1325 ZD_ASSERT((cr_rates & ~(CR_RATES_80211B | CR_RATES_80211G)) == 0); 1321 int r;
1326 dev_dbg_f(zd_chip_dev(chip), "%x\n", cr_rates); 1322
1323 if (cr_rates & ~(CR_RATES_80211B|CR_RATES_80211G))
1324 return -EINVAL;
1327 1325
1328 return zd_iowrite32_locked(chip, cr_rates, CR_BASIC_RATE_TBL); 1326 mutex_lock(&chip->mutex);
1327 r = zd_iowrite32_locked(chip, cr_rates, CR_BASIC_RATE_TBL);
1328 mutex_unlock(&chip->mutex);
1329 return r;
1329} 1330}
1330 1331
1331static int ofdm_qual_db(u8 status_quality, u8 zd_rate, unsigned int size) 1332static int ofdm_qual_db(u8 status_quality, u8 zd_rate, unsigned int size)
@@ -1468,56 +1469,44 @@ u8 zd_rx_qual_percent(const void *rx_frame, unsigned int size,
1468{ 1469{
1469 return (status->frame_status&ZD_RX_OFDM) ? 1470 return (status->frame_status&ZD_RX_OFDM) ?
1470 ofdm_qual_percent(status->signal_quality_ofdm, 1471 ofdm_qual_percent(status->signal_quality_ofdm,
1471 zd_rate_from_ofdm_plcp_header(rx_frame), 1472 zd_rate_from_ofdm_plcp_header(rx_frame),
1472 size) : 1473 size) :
1473 cck_qual_percent(status->signal_quality_cck); 1474 cck_qual_percent(status->signal_quality_cck);
1474} 1475}
1475 1476
1476u8 zd_rx_strength_percent(u8 rssi) 1477/**
1477{ 1478 * zd_rx_rate - report zd-rate
1478 int r = (rssi*100) / 41; 1479 * @rx_frame - received frame
1479 if (r > 100) 1480 * @rx_status - rx_status as given by the device
1480 r = 100; 1481 *
1481 return (u8) r; 1482 * This function converts the rate as encoded in the received packet to the
1482} 1483 * zd-rate, we are using on other places in the driver.
1483 1484 */
1484u16 zd_rx_rate(const void *rx_frame, const struct rx_status *status) 1485u8 zd_rx_rate(const void *rx_frame, const struct rx_status *status)
1485{ 1486{
1486 static const u16 ofdm_rates[] = { 1487 u8 zd_rate;
1487 [ZD_OFDM_PLCP_RATE_6M] = 60,
1488 [ZD_OFDM_PLCP_RATE_9M] = 90,
1489 [ZD_OFDM_PLCP_RATE_12M] = 120,
1490 [ZD_OFDM_PLCP_RATE_18M] = 180,
1491 [ZD_OFDM_PLCP_RATE_24M] = 240,
1492 [ZD_OFDM_PLCP_RATE_36M] = 360,
1493 [ZD_OFDM_PLCP_RATE_48M] = 480,
1494 [ZD_OFDM_PLCP_RATE_54M] = 540,
1495 };
1496 u16 rate;
1497 if (status->frame_status & ZD_RX_OFDM) { 1488 if (status->frame_status & ZD_RX_OFDM) {
1498 /* Deals with PLCP OFDM rate (not zd_rates) */ 1489 zd_rate = zd_rate_from_ofdm_plcp_header(rx_frame);
1499 u8 ofdm_rate = zd_ofdm_plcp_header_rate(rx_frame);
1500 rate = ofdm_rates[ofdm_rate & 0xf];
1501 } else { 1490 } else {
1502 switch (zd_cck_plcp_header_signal(rx_frame)) { 1491 switch (zd_cck_plcp_header_signal(rx_frame)) {
1503 case ZD_CCK_PLCP_SIGNAL_1M: 1492 case ZD_CCK_PLCP_SIGNAL_1M:
1504 rate = 10; 1493 zd_rate = ZD_CCK_RATE_1M;
1505 break; 1494 break;
1506 case ZD_CCK_PLCP_SIGNAL_2M: 1495 case ZD_CCK_PLCP_SIGNAL_2M:
1507 rate = 20; 1496 zd_rate = ZD_CCK_RATE_2M;
1508 break; 1497 break;
1509 case ZD_CCK_PLCP_SIGNAL_5M5: 1498 case ZD_CCK_PLCP_SIGNAL_5M5:
1510 rate = 55; 1499 zd_rate = ZD_CCK_RATE_5_5M;
1511 break; 1500 break;
1512 case ZD_CCK_PLCP_SIGNAL_11M: 1501 case ZD_CCK_PLCP_SIGNAL_11M:
1513 rate = 110; 1502 zd_rate = ZD_CCK_RATE_11M;
1514 break; 1503 break;
1515 default: 1504 default:
1516 rate = 0; 1505 zd_rate = 0;
1517 } 1506 }
1518 } 1507 }
1519 1508
1520 return rate; 1509 return zd_rate;
1521} 1510}
1522 1511
1523int zd_chip_switch_radio_on(struct zd_chip *chip) 1512int zd_chip_switch_radio_on(struct zd_chip *chip)
@@ -1557,20 +1546,22 @@ void zd_chip_disable_int(struct zd_chip *chip)
1557 mutex_unlock(&chip->mutex); 1546 mutex_unlock(&chip->mutex);
1558} 1547}
1559 1548
1560int zd_chip_enable_rx(struct zd_chip *chip) 1549int zd_chip_enable_rxtx(struct zd_chip *chip)
1561{ 1550{
1562 int r; 1551 int r;
1563 1552
1564 mutex_lock(&chip->mutex); 1553 mutex_lock(&chip->mutex);
1554 zd_usb_enable_tx(&chip->usb);
1565 r = zd_usb_enable_rx(&chip->usb); 1555 r = zd_usb_enable_rx(&chip->usb);
1566 mutex_unlock(&chip->mutex); 1556 mutex_unlock(&chip->mutex);
1567 return r; 1557 return r;
1568} 1558}
1569 1559
1570void zd_chip_disable_rx(struct zd_chip *chip) 1560void zd_chip_disable_rxtx(struct zd_chip *chip)
1571{ 1561{
1572 mutex_lock(&chip->mutex); 1562 mutex_lock(&chip->mutex);
1573 zd_usb_disable_rx(&chip->usb); 1563 zd_usb_disable_rx(&chip->usb);
1564 zd_usb_disable_tx(&chip->usb);
1574 mutex_unlock(&chip->mutex); 1565 mutex_unlock(&chip->mutex);
1575} 1566}
1576 1567
diff --git a/drivers/net/wireless/zd1211rw/zd_chip.h b/drivers/net/wireless/zd1211rw/zd_chip.h
index 8009b70213e2..a88a56932239 100644
--- a/drivers/net/wireless/zd1211rw/zd_chip.h
+++ b/drivers/net/wireless/zd1211rw/zd_chip.h
@@ -433,9 +433,10 @@ enum {
433#define CR_GROUP_HASH_P2 CTL_REG(0x0628) 433#define CR_GROUP_HASH_P2 CTL_REG(0x0628)
434 434
435#define CR_RX_TIMEOUT CTL_REG(0x062C) 435#define CR_RX_TIMEOUT CTL_REG(0x062C)
436
436/* Basic rates supported by the BSS. When producing ACK or CTS messages, the 437/* Basic rates supported by the BSS. When producing ACK or CTS messages, the
437 * device will use a rate in this table that is less than or equal to the rate 438 * device will use a rate in this table that is less than or equal to the rate
438 * of the incoming frame which prompted the response */ 439 * of the incoming frame which prompted the response. */
439#define CR_BASIC_RATE_TBL CTL_REG(0x0630) 440#define CR_BASIC_RATE_TBL CTL_REG(0x0630)
440#define CR_RATE_1M (1 << 0) /* 802.11b */ 441#define CR_RATE_1M (1 << 0) /* 802.11b */
441#define CR_RATE_2M (1 << 1) /* 802.11b */ 442#define CR_RATE_2M (1 << 1) /* 802.11b */
@@ -509,14 +510,37 @@ enum {
509#define CR_UNDERRUN_CNT CTL_REG(0x0688) 510#define CR_UNDERRUN_CNT CTL_REG(0x0688)
510 511
511#define CR_RX_FILTER CTL_REG(0x068c) 512#define CR_RX_FILTER CTL_REG(0x068c)
513#define RX_FILTER_ASSOC_REQUEST (1 << 0)
512#define RX_FILTER_ASSOC_RESPONSE (1 << 1) 514#define RX_FILTER_ASSOC_RESPONSE (1 << 1)
515#define RX_FILTER_REASSOC_REQUEST (1 << 2)
513#define RX_FILTER_REASSOC_RESPONSE (1 << 3) 516#define RX_FILTER_REASSOC_RESPONSE (1 << 3)
517#define RX_FILTER_PROBE_REQUEST (1 << 4)
514#define RX_FILTER_PROBE_RESPONSE (1 << 5) 518#define RX_FILTER_PROBE_RESPONSE (1 << 5)
519/* bits 6 and 7 reserved */
515#define RX_FILTER_BEACON (1 << 8) 520#define RX_FILTER_BEACON (1 << 8)
521#define RX_FILTER_ATIM (1 << 9)
516#define RX_FILTER_DISASSOC (1 << 10) 522#define RX_FILTER_DISASSOC (1 << 10)
517#define RX_FILTER_AUTH (1 << 11) 523#define RX_FILTER_AUTH (1 << 11)
518#define AP_RX_FILTER 0x0400feff 524#define RX_FILTER_DEAUTH (1 << 12)
519#define STA_RX_FILTER 0x0000ffff 525#define RX_FILTER_PSPOLL (1 << 26)
526#define RX_FILTER_RTS (1 << 27)
527#define RX_FILTER_CTS (1 << 28)
528#define RX_FILTER_ACK (1 << 29)
529#define RX_FILTER_CFEND (1 << 30)
530#define RX_FILTER_CFACK (1 << 31)
531
532/* Enable bits for all frames you are interested in. */
533#define STA_RX_FILTER (RX_FILTER_ASSOC_REQUEST | RX_FILTER_ASSOC_RESPONSE | \
534 RX_FILTER_REASSOC_REQUEST | RX_FILTER_REASSOC_RESPONSE | \
535 RX_FILTER_PROBE_REQUEST | RX_FILTER_PROBE_RESPONSE | \
536 (0x3 << 6) /* vendor driver sets these reserved bits */ | \
537 RX_FILTER_BEACON | RX_FILTER_ATIM | RX_FILTER_DISASSOC | \
538 RX_FILTER_AUTH | RX_FILTER_DEAUTH | \
539 (0x7 << 13) /* vendor driver sets these reserved bits */ | \
540 RX_FILTER_PSPOLL | RX_FILTER_ACK) /* 0x2400ffff */
541
542#define RX_FILTER_CTRL (RX_FILTER_RTS | RX_FILTER_CTS | \
543 RX_FILTER_CFEND | RX_FILTER_CFACK)
520 544
521/* Monitor mode sets filter to 0xfffff */ 545/* Monitor mode sets filter to 0xfffff */
522 546
@@ -730,7 +754,7 @@ static inline struct zd_chip *zd_rf_to_chip(struct zd_rf *rf)
730#define zd_chip_dev(chip) (&(chip)->usb.intf->dev) 754#define zd_chip_dev(chip) (&(chip)->usb.intf->dev)
731 755
732void zd_chip_init(struct zd_chip *chip, 756void zd_chip_init(struct zd_chip *chip,
733 struct net_device *netdev, 757 struct ieee80211_hw *hw,
734 struct usb_interface *intf); 758 struct usb_interface *intf);
735void zd_chip_clear(struct zd_chip *chip); 759void zd_chip_clear(struct zd_chip *chip);
736int zd_chip_read_mac_addr_fw(struct zd_chip *chip, u8 *addr); 760int zd_chip_read_mac_addr_fw(struct zd_chip *chip, u8 *addr);
@@ -835,14 +859,12 @@ int zd_chip_switch_radio_on(struct zd_chip *chip);
835int zd_chip_switch_radio_off(struct zd_chip *chip); 859int zd_chip_switch_radio_off(struct zd_chip *chip);
836int zd_chip_enable_int(struct zd_chip *chip); 860int zd_chip_enable_int(struct zd_chip *chip);
837void zd_chip_disable_int(struct zd_chip *chip); 861void zd_chip_disable_int(struct zd_chip *chip);
838int zd_chip_enable_rx(struct zd_chip *chip); 862int zd_chip_enable_rxtx(struct zd_chip *chip);
839void zd_chip_disable_rx(struct zd_chip *chip); 863void zd_chip_disable_rxtx(struct zd_chip *chip);
840int zd_chip_enable_hwint(struct zd_chip *chip); 864int zd_chip_enable_hwint(struct zd_chip *chip);
841int zd_chip_disable_hwint(struct zd_chip *chip); 865int zd_chip_disable_hwint(struct zd_chip *chip);
842int zd_chip_generic_patch_6m_band(struct zd_chip *chip, int channel); 866int zd_chip_generic_patch_6m_band(struct zd_chip *chip, int channel);
843 867int zd_chip_set_rts_cts_rate_locked(struct zd_chip *chip, int preamble);
844int zd_chip_set_rts_cts_rate_locked(struct zd_chip *chip,
845 u8 rts_rate, int preamble);
846 868
847static inline int zd_get_encryption_type(struct zd_chip *chip, u32 *type) 869static inline int zd_get_encryption_type(struct zd_chip *chip, u32 *type)
848{ 870{
@@ -859,17 +881,7 @@ static inline int zd_chip_get_basic_rates(struct zd_chip *chip, u16 *cr_rates)
859 return zd_ioread16(chip, CR_BASIC_RATE_TBL, cr_rates); 881 return zd_ioread16(chip, CR_BASIC_RATE_TBL, cr_rates);
860} 882}
861 883
862int zd_chip_set_basic_rates_locked(struct zd_chip *chip, u16 cr_rates); 884int zd_chip_set_basic_rates(struct zd_chip *chip, u16 cr_rates);
863
864static inline int zd_chip_set_basic_rates(struct zd_chip *chip, u16 cr_rates)
865{
866 int r;
867
868 mutex_lock(&chip->mutex);
869 r = zd_chip_set_basic_rates_locked(chip, cr_rates);
870 mutex_unlock(&chip->mutex);
871 return r;
872}
873 885
874int zd_chip_lock_phy_regs(struct zd_chip *chip); 886int zd_chip_lock_phy_regs(struct zd_chip *chip);
875int zd_chip_unlock_phy_regs(struct zd_chip *chip); 887int zd_chip_unlock_phy_regs(struct zd_chip *chip);
@@ -893,9 +905,8 @@ struct rx_status;
893 905
894u8 zd_rx_qual_percent(const void *rx_frame, unsigned int size, 906u8 zd_rx_qual_percent(const void *rx_frame, unsigned int size,
895 const struct rx_status *status); 907 const struct rx_status *status);
896u8 zd_rx_strength_percent(u8 rssi);
897 908
898u16 zd_rx_rate(const void *rx_frame, const struct rx_status *status); 909u8 zd_rx_rate(const void *rx_frame, const struct rx_status *status);
899 910
900struct zd_mc_hash { 911struct zd_mc_hash {
901 u32 low; 912 u32 low;
diff --git a/drivers/net/wireless/zd1211rw/zd_ieee80211.c b/drivers/net/wireless/zd1211rw/zd_ieee80211.c
index 189160efd2ae..77cfe5e78230 100644
--- a/drivers/net/wireless/zd1211rw/zd_ieee80211.c
+++ b/drivers/net/wireless/zd1211rw/zd_ieee80211.c
@@ -16,178 +16,85 @@
16 */ 16 */
17 17
18/* 18/*
19 * A lot of this code is generic and should be moved into the upper layers 19 * In the long term, we'll probably find a better way of handling regulatory
20 * at some point. 20 * requirements outside of the driver.
21 */ 21 */
22 22
23#include <linux/errno.h>
24#include <linux/wireless.h>
25#include <linux/kernel.h> 23#include <linux/kernel.h>
26#include <net/ieee80211.h> 24#include <net/mac80211.h>
27 25
28#include "zd_def.h"
29#include "zd_ieee80211.h" 26#include "zd_ieee80211.h"
30#include "zd_mac.h" 27#include "zd_mac.h"
31 28
29struct channel_range {
30 u8 regdomain;
31 u8 start;
32 u8 end; /* exclusive (channel must be less than end) */
33};
34
32static const struct channel_range channel_ranges[] = { 35static const struct channel_range channel_ranges[] = {
33 [0] = { 0, 0}, 36 { ZD_REGDOMAIN_FCC, 1, 12 },
34 [ZD_REGDOMAIN_FCC] = { 1, 12}, 37 { ZD_REGDOMAIN_IC, 1, 12 },
35 [ZD_REGDOMAIN_IC] = { 1, 12}, 38 { ZD_REGDOMAIN_ETSI, 1, 14 },
36 [ZD_REGDOMAIN_ETSI] = { 1, 14}, 39 { ZD_REGDOMAIN_JAPAN, 1, 14 },
37 [ZD_REGDOMAIN_JAPAN] = { 1, 14}, 40 { ZD_REGDOMAIN_SPAIN, 1, 14 },
38 [ZD_REGDOMAIN_SPAIN] = { 1, 14}, 41 { ZD_REGDOMAIN_FRANCE, 1, 14 },
39 [ZD_REGDOMAIN_FRANCE] = { 1, 14},
40 42
41 /* Japan originally only had channel 14 available (see CHNL_ID 0x40 in 43 /* Japan originally only had channel 14 available (see CHNL_ID 0x40 in
42 * 802.11). However, in 2001 the range was extended to include channels 44 * 802.11). However, in 2001 the range was extended to include channels
43 * 1-13. The ZyDAS devices still use the old region code but are 45 * 1-13. The ZyDAS devices still use the old region code but are
44 * designed to allow the extra channel access in Japan. */ 46 * designed to allow the extra channel access in Japan. */
45 [ZD_REGDOMAIN_JAPAN_ADD] = { 1, 15}, 47 { ZD_REGDOMAIN_JAPAN_ADD, 1, 15 },
46}; 48};
47 49
48const struct channel_range *zd_channel_range(u8 regdomain) 50static const struct channel_range *zd_channel_range(u8 regdomain)
49{
50 if (regdomain >= ARRAY_SIZE(channel_ranges))
51 regdomain = 0;
52 return &channel_ranges[regdomain];
53}
54
55int zd_regdomain_supports_channel(u8 regdomain, u8 channel)
56{
57 const struct channel_range *range = zd_channel_range(regdomain);
58 return range->start <= channel && channel < range->end;
59}
60
61int zd_regdomain_supported(u8 regdomain)
62{ 51{
63 const struct channel_range *range = zd_channel_range(regdomain); 52 int i;
64 return range->start != 0; 53 for (i = 0; i < ARRAY_SIZE(channel_ranges); i++) {
65} 54 const struct channel_range *range = &channel_ranges[i];
66 55 if (range->regdomain == regdomain)
67/* Stores channel frequencies in MHz. */ 56 return range;
68static const u16 channel_frequencies[] = {
69 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447,
70 2452, 2457, 2462, 2467, 2472, 2484,
71};
72
73#define NUM_CHANNELS ARRAY_SIZE(channel_frequencies)
74
75static int compute_freq(struct iw_freq *freq, u32 mhz, u32 hz)
76{
77 u32 factor;
78
79 freq->e = 0;
80 if (mhz >= 1000000000U) {
81 pr_debug("zd1211 mhz %u to large\n", mhz);
82 freq->m = 0;
83 return -EINVAL;
84 }
85
86 factor = 1000;
87 while (mhz >= factor) {
88
89 freq->e += 1;
90 factor *= 10;
91 }
92
93 factor /= 1000U;
94 freq->m = mhz * (1000000U/factor) + hz/factor;
95
96 return 0;
97}
98
99int zd_channel_to_freq(struct iw_freq *freq, u8 channel)
100{
101 if (channel > NUM_CHANNELS) {
102 freq->m = 0;
103 freq->e = 0;
104 return -EINVAL;
105 }
106 if (!channel) {
107 freq->m = 0;
108 freq->e = 0;
109 return -EINVAL;
110 } 57 }
111 return compute_freq(freq, channel_frequencies[channel-1], 0); 58 return NULL;
112} 59}
113 60
114static int freq_to_mhz(const struct iw_freq *freq) 61#define CHAN_TO_IDX(chan) ((chan) - 1)
115{
116 u32 factor;
117 int e;
118
119 /* Such high frequencies are not supported. */
120 if (freq->e > 6)
121 return -EINVAL;
122
123 factor = 1;
124 for (e = freq->e; e > 0; --e) {
125 factor *= 10;
126 }
127 factor = 1000000U / factor;
128
129 if (freq->m % factor) {
130 return -EINVAL;
131 }
132
133 return freq->m / factor;
134}
135 62
136int zd_find_channel(u8 *channel, const struct iw_freq *freq) 63static void unmask_bg_channels(struct ieee80211_hw *hw,
64 const struct channel_range *range,
65 struct ieee80211_hw_mode *mode)
137{ 66{
138 int i, r; 67 u8 channel;
139 u32 mhz;
140
141 if (freq->m < 1000) {
142 if (freq->m > NUM_CHANNELS || freq->m == 0)
143 return -EINVAL;
144 *channel = freq->m;
145 return 1;
146 }
147
148 r = freq_to_mhz(freq);
149 if (r < 0)
150 return r;
151 mhz = r;
152 68
153 for (i = 0; i < NUM_CHANNELS; i++) { 69 for (channel = range->start; channel < range->end; channel++) {
154 if (mhz == channel_frequencies[i]) { 70 struct ieee80211_channel *chan =
155 *channel = i+1; 71 &mode->channels[CHAN_TO_IDX(channel)];
156 return 1; 72 chan->flag |= IEEE80211_CHAN_W_SCAN |
157 } 73 IEEE80211_CHAN_W_ACTIVE_SCAN |
74 IEEE80211_CHAN_W_IBSS;
158 } 75 }
159
160 return -EINVAL;
161} 76}
162 77
163int zd_geo_init(struct ieee80211_device *ieee, u8 regdomain) 78void zd_geo_init(struct ieee80211_hw *hw, u8 regdomain)
164{ 79{
165 struct ieee80211_geo geo; 80 struct zd_mac *mac = zd_hw_mac(hw);
166 const struct channel_range *range; 81 const struct channel_range *range;
167 int i;
168 u8 channel;
169 82
170 dev_dbg(zd_mac_dev(zd_netdev_mac(ieee->dev)), 83 dev_dbg(zd_mac_dev(mac), "regdomain %#02x\n", regdomain);
171 "regdomain %#04x\n", regdomain);
172 84
173 range = zd_channel_range(regdomain); 85 range = zd_channel_range(regdomain);
174 if (range->start == 0) { 86 if (!range) {
175 dev_err(zd_mac_dev(zd_netdev_mac(ieee->dev)), 87 /* The vendor driver overrides the regulatory domain and
176 "zd1211 regdomain %#04x not supported\n", 88 * allowed channel registers and unconditionally restricts
177 regdomain); 89 * available channels to 1-11 everywhere. Match their
178 return -EINVAL; 90 * questionable behaviour only for regdomains which we don't
91 * recognise. */
92 dev_warn(zd_mac_dev(mac), "Unrecognised regulatory domain: "
93 "%#02x. Defaulting to FCC.\n", regdomain);
94 range = zd_channel_range(ZD_REGDOMAIN_FCC);
179 } 95 }
180 96
181 memset(&geo, 0, sizeof(geo)); 97 unmask_bg_channels(hw, range, &mac->modes[0]);
182 98 unmask_bg_channels(hw, range, &mac->modes[1]);
183 for (i = 0, channel = range->start; channel < range->end; channel++) {
184 struct ieee80211_channel *chan = &geo.bg[i++];
185 chan->freq = channel_frequencies[channel - 1];
186 chan->channel = channel;
187 }
188
189 geo.bg_channels = i;
190 memcpy(geo.name, "XX ", 4);
191 ieee80211_set_geo(ieee, &geo);
192 return 0;
193} 99}
100
diff --git a/drivers/net/wireless/zd1211rw/zd_ieee80211.h b/drivers/net/wireless/zd1211rw/zd_ieee80211.h
index fbf6491dce7e..98b87cfe874c 100644
--- a/drivers/net/wireless/zd1211rw/zd_ieee80211.h
+++ b/drivers/net/wireless/zd1211rw/zd_ieee80211.h
@@ -1,7 +1,7 @@
1#ifndef _ZD_IEEE80211_H 1#ifndef _ZD_IEEE80211_H
2#define _ZD_IEEE80211_H 2#define _ZD_IEEE80211_H
3 3
4#include <net/ieee80211.h> 4#include <net/mac80211.h>
5 5
6/* Additional definitions from the standards. 6/* Additional definitions from the standards.
7 */ 7 */
@@ -19,22 +19,7 @@ enum {
19 MAX_CHANNEL24 = 14, 19 MAX_CHANNEL24 = 14,
20}; 20};
21 21
22struct channel_range { 22void zd_geo_init(struct ieee80211_hw *hw, u8 regdomain);
23 u8 start;
24 u8 end; /* exclusive (channel must be less than end) */
25};
26
27struct iw_freq;
28
29int zd_geo_init(struct ieee80211_device *ieee, u8 regdomain);
30
31const struct channel_range *zd_channel_range(u8 regdomain);
32int zd_regdomain_supports_channel(u8 regdomain, u8 channel);
33int zd_regdomain_supported(u8 regdomain);
34
35/* for 2.4 GHz band */
36int zd_channel_to_freq(struct iw_freq *freq, u8 channel);
37int zd_find_channel(u8 *channel, const struct iw_freq *freq);
38 23
39#define ZD_PLCP_SERVICE_LENGTH_EXTENSION 0x80 24#define ZD_PLCP_SERVICE_LENGTH_EXTENSION 0x80
40 25
@@ -54,8 +39,8 @@ static inline u8 zd_ofdm_plcp_header_rate(const struct ofdm_plcp_header *header)
54 * 39 *
55 * See the struct zd_ctrlset definition in zd_mac.h. 40 * See the struct zd_ctrlset definition in zd_mac.h.
56 */ 41 */
57#define ZD_OFDM_PLCP_RATE_6M 0xb 42#define ZD_OFDM_PLCP_RATE_6M 0xb
58#define ZD_OFDM_PLCP_RATE_9M 0xf 43#define ZD_OFDM_PLCP_RATE_9M 0xf
59#define ZD_OFDM_PLCP_RATE_12M 0xa 44#define ZD_OFDM_PLCP_RATE_12M 0xa
60#define ZD_OFDM_PLCP_RATE_18M 0xe 45#define ZD_OFDM_PLCP_RATE_18M 0xe
61#define ZD_OFDM_PLCP_RATE_24M 0x9 46#define ZD_OFDM_PLCP_RATE_24M 0x9
@@ -87,10 +72,4 @@ static inline u8 zd_cck_plcp_header_signal(const struct cck_plcp_header *header)
87#define ZD_CCK_PLCP_SIGNAL_5M5 0x37 72#define ZD_CCK_PLCP_SIGNAL_5M5 0x37
88#define ZD_CCK_PLCP_SIGNAL_11M 0x6e 73#define ZD_CCK_PLCP_SIGNAL_11M 0x6e
89 74
90enum ieee80211_std {
91 IEEE80211B = 0x01,
92 IEEE80211A = 0x02,
93 IEEE80211G = 0x04,
94};
95
96#endif /* _ZD_IEEE80211_H */ 75#endif /* _ZD_IEEE80211_H */
diff --git a/drivers/net/wireless/zd1211rw/zd_mac.c b/drivers/net/wireless/zd1211rw/zd_mac.c
index 5298a8bf1129..aaffd081b1bf 100644
--- a/drivers/net/wireless/zd1211rw/zd_mac.c
+++ b/drivers/net/wireless/zd1211rw/zd_mac.c
@@ -1,5 +1,7 @@
1/* zd_mac.c 1/* zd_mac.c
2 * 2 *
3 * Copyright (c) 2007 Luis R. Rodriguez <mcgrof@winlab.rutgers.edu>
4 *
3 * This program is free software; you can redistribute it and/or modify 5 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by 6 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or 7 * the Free Software Foundation; either version 2 of the License, or
@@ -17,7 +19,6 @@
17 19
18#include <linux/netdevice.h> 20#include <linux/netdevice.h>
19#include <linux/etherdevice.h> 21#include <linux/etherdevice.h>
20#include <linux/wireless.h>
21#include <linux/usb.h> 22#include <linux/usb.h>
22#include <linux/jiffies.h> 23#include <linux/jiffies.h>
23#include <net/ieee80211_radiotap.h> 24#include <net/ieee80211_radiotap.h>
@@ -26,81 +27,105 @@
26#include "zd_chip.h" 27#include "zd_chip.h"
27#include "zd_mac.h" 28#include "zd_mac.h"
28#include "zd_ieee80211.h" 29#include "zd_ieee80211.h"
29#include "zd_netdev.h"
30#include "zd_rf.h" 30#include "zd_rf.h"
31 31
32static void ieee_init(struct ieee80211_device *ieee); 32/* This table contains the hardware specific values for the modulation rates. */
33static void softmac_init(struct ieee80211softmac_device *sm); 33static const struct ieee80211_rate zd_rates[] = {
34static void set_rts_cts_work(struct work_struct *work); 34 { .rate = 10,
35static void set_basic_rates_work(struct work_struct *work); 35 .val = ZD_CCK_RATE_1M,
36 .flags = IEEE80211_RATE_CCK },
37 { .rate = 20,
38 .val = ZD_CCK_RATE_2M,
39 .val2 = ZD_CCK_RATE_2M | ZD_CCK_PREA_SHORT,
40 .flags = IEEE80211_RATE_CCK_2 },
41 { .rate = 55,
42 .val = ZD_CCK_RATE_5_5M,
43 .val2 = ZD_CCK_RATE_5_5M | ZD_CCK_PREA_SHORT,
44 .flags = IEEE80211_RATE_CCK_2 },
45 { .rate = 110,
46 .val = ZD_CCK_RATE_11M,
47 .val2 = ZD_CCK_RATE_11M | ZD_CCK_PREA_SHORT,
48 .flags = IEEE80211_RATE_CCK_2 },
49 { .rate = 60,
50 .val = ZD_OFDM_RATE_6M,
51 .flags = IEEE80211_RATE_OFDM },
52 { .rate = 90,
53 .val = ZD_OFDM_RATE_9M,
54 .flags = IEEE80211_RATE_OFDM },
55 { .rate = 120,
56 .val = ZD_OFDM_RATE_12M,
57 .flags = IEEE80211_RATE_OFDM },
58 { .rate = 180,
59 .val = ZD_OFDM_RATE_18M,
60 .flags = IEEE80211_RATE_OFDM },
61 { .rate = 240,
62 .val = ZD_OFDM_RATE_24M,
63 .flags = IEEE80211_RATE_OFDM },
64 { .rate = 360,
65 .val = ZD_OFDM_RATE_36M,
66 .flags = IEEE80211_RATE_OFDM },
67 { .rate = 480,
68 .val = ZD_OFDM_RATE_48M,
69 .flags = IEEE80211_RATE_OFDM },
70 { .rate = 540,
71 .val = ZD_OFDM_RATE_54M,
72 .flags = IEEE80211_RATE_OFDM },
73};
74
75static const struct ieee80211_channel zd_channels[] = {
76 { .chan = 1,
77 .freq = 2412},
78 { .chan = 2,
79 .freq = 2417},
80 { .chan = 3,
81 .freq = 2422},
82 { .chan = 4,
83 .freq = 2427},
84 { .chan = 5,
85 .freq = 2432},
86 { .chan = 6,
87 .freq = 2437},
88 { .chan = 7,
89 .freq = 2442},
90 { .chan = 8,
91 .freq = 2447},
92 { .chan = 9,
93 .freq = 2452},
94 { .chan = 10,
95 .freq = 2457},
96 { .chan = 11,
97 .freq = 2462},
98 { .chan = 12,
99 .freq = 2467},
100 { .chan = 13,
101 .freq = 2472},
102 { .chan = 14,
103 .freq = 2484}
104};
36 105
37static void housekeeping_init(struct zd_mac *mac); 106static void housekeeping_init(struct zd_mac *mac);
38static void housekeeping_enable(struct zd_mac *mac); 107static void housekeeping_enable(struct zd_mac *mac);
39static void housekeeping_disable(struct zd_mac *mac); 108static void housekeeping_disable(struct zd_mac *mac);
40 109
41static void set_multicast_hash_handler(struct work_struct *work); 110int zd_mac_preinit_hw(struct ieee80211_hw *hw)
42
43static void do_rx(unsigned long mac_ptr);
44
45int zd_mac_init(struct zd_mac *mac,
46 struct net_device *netdev,
47 struct usb_interface *intf)
48{
49 struct ieee80211_device *ieee = zd_netdev_ieee80211(netdev);
50
51 memset(mac, 0, sizeof(*mac));
52 spin_lock_init(&mac->lock);
53 mac->netdev = netdev;
54 INIT_DELAYED_WORK(&mac->set_rts_cts_work, set_rts_cts_work);
55 INIT_DELAYED_WORK(&mac->set_basic_rates_work, set_basic_rates_work);
56
57 skb_queue_head_init(&mac->rx_queue);
58 tasklet_init(&mac->rx_tasklet, do_rx, (unsigned long)mac);
59 tasklet_disable(&mac->rx_tasklet);
60
61 ieee_init(ieee);
62 softmac_init(ieee80211_priv(netdev));
63 zd_chip_init(&mac->chip, netdev, intf);
64 housekeeping_init(mac);
65 INIT_WORK(&mac->set_multicast_hash_work, set_multicast_hash_handler);
66 return 0;
67}
68
69static int reset_channel(struct zd_mac *mac)
70{
71 int r;
72 unsigned long flags;
73 const struct channel_range *range;
74
75 spin_lock_irqsave(&mac->lock, flags);
76 range = zd_channel_range(mac->regdomain);
77 if (!range->start) {
78 r = -EINVAL;
79 goto out;
80 }
81 mac->requested_channel = range->start;
82 r = 0;
83out:
84 spin_unlock_irqrestore(&mac->lock, flags);
85 return r;
86}
87
88int zd_mac_preinit_hw(struct zd_mac *mac)
89{ 111{
90 int r; 112 int r;
91 u8 addr[ETH_ALEN]; 113 u8 addr[ETH_ALEN];
114 struct zd_mac *mac = zd_hw_mac(hw);
92 115
93 r = zd_chip_read_mac_addr_fw(&mac->chip, addr); 116 r = zd_chip_read_mac_addr_fw(&mac->chip, addr);
94 if (r) 117 if (r)
95 return r; 118 return r;
96 119
97 memcpy(mac->netdev->dev_addr, addr, ETH_ALEN); 120 SET_IEEE80211_PERM_ADDR(hw, addr);
121
98 return 0; 122 return 0;
99} 123}
100 124
101int zd_mac_init_hw(struct zd_mac *mac) 125int zd_mac_init_hw(struct ieee80211_hw *hw)
102{ 126{
103 int r; 127 int r;
128 struct zd_mac *mac = zd_hw_mac(hw);
104 struct zd_chip *chip = &mac->chip; 129 struct zd_chip *chip = &mac->chip;
105 u8 default_regdomain; 130 u8 default_regdomain;
106 131
@@ -116,22 +141,9 @@ int zd_mac_init_hw(struct zd_mac *mac)
116 r = zd_read_regdomain(chip, &default_regdomain); 141 r = zd_read_regdomain(chip, &default_regdomain);
117 if (r) 142 if (r)
118 goto disable_int; 143 goto disable_int;
119 if (!zd_regdomain_supported(default_regdomain)) {
120 /* The vendor driver overrides the regulatory domain and
121 * allowed channel registers and unconditionally restricts
122 * available channels to 1-11 everywhere. Match their
123 * questionable behaviour only for regdomains which we don't
124 * recognise. */
125 dev_warn(zd_mac_dev(mac), "Unrecognised regulatory domain: "
126 "%#04x. Defaulting to FCC.\n", default_regdomain);
127 default_regdomain = ZD_REGDOMAIN_FCC;
128 }
129 spin_lock_irq(&mac->lock); 144 spin_lock_irq(&mac->lock);
130 mac->regdomain = mac->default_regdomain = default_regdomain; 145 mac->regdomain = mac->default_regdomain = default_regdomain;
131 spin_unlock_irq(&mac->lock); 146 spin_unlock_irq(&mac->lock);
132 r = reset_channel(mac);
133 if (r)
134 goto disable_int;
135 147
136 /* We must inform the device that we are doing encryption/decryption in 148 /* We must inform the device that we are doing encryption/decryption in
137 * software at the moment. */ 149 * software at the moment. */
@@ -139,9 +151,7 @@ int zd_mac_init_hw(struct zd_mac *mac)
139 if (r) 151 if (r)
140 goto disable_int; 152 goto disable_int;
141 153
142 r = zd_geo_init(zd_mac_to_ieee80211(mac), mac->regdomain); 154 zd_geo_init(hw, mac->regdomain);
143 if (r)
144 goto disable_int;
145 155
146 r = 0; 156 r = 0;
147disable_int: 157disable_int:
@@ -153,8 +163,6 @@ out:
153void zd_mac_clear(struct zd_mac *mac) 163void zd_mac_clear(struct zd_mac *mac)
154{ 164{
155 flush_workqueue(zd_workqueue); 165 flush_workqueue(zd_workqueue);
156 skb_queue_purge(&mac->rx_queue);
157 tasklet_kill(&mac->rx_tasklet);
158 zd_chip_clear(&mac->chip); 166 zd_chip_clear(&mac->chip);
159 ZD_ASSERT(!spin_is_locked(&mac->lock)); 167 ZD_ASSERT(!spin_is_locked(&mac->lock));
160 ZD_MEMCLEAR(mac, sizeof(struct zd_mac)); 168 ZD_MEMCLEAR(mac, sizeof(struct zd_mac));
@@ -162,34 +170,27 @@ void zd_mac_clear(struct zd_mac *mac)
162 170
163static int set_rx_filter(struct zd_mac *mac) 171static int set_rx_filter(struct zd_mac *mac)
164{ 172{
165 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac); 173 unsigned long flags;
166 u32 filter = (ieee->iw_mode == IW_MODE_MONITOR) ? ~0 : STA_RX_FILTER; 174 u32 filter = STA_RX_FILTER;
167 return zd_iowrite32(&mac->chip, CR_RX_FILTER, filter);
168}
169 175
170static int set_sniffer(struct zd_mac *mac) 176 spin_lock_irqsave(&mac->lock, flags);
171{ 177 if (mac->pass_ctrl)
172 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac); 178 filter |= RX_FILTER_CTRL;
173 return zd_iowrite32(&mac->chip, CR_SNIFFER_ON, 179 spin_unlock_irqrestore(&mac->lock, flags);
174 ieee->iw_mode == IW_MODE_MONITOR ? 1 : 0); 180
175 return 0; 181 return zd_iowrite32(&mac->chip, CR_RX_FILTER, filter);
176} 182}
177 183
178static int set_mc_hash(struct zd_mac *mac) 184static int set_mc_hash(struct zd_mac *mac)
179{ 185{
180 struct zd_mc_hash hash; 186 struct zd_mc_hash hash;
181 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
182
183 zd_mc_clear(&hash); 187 zd_mc_clear(&hash);
184 if (ieee->iw_mode == IW_MODE_MONITOR)
185 zd_mc_add_all(&hash);
186
187 return zd_chip_set_multicast_hash(&mac->chip, &hash); 188 return zd_chip_set_multicast_hash(&mac->chip, &hash);
188} 189}
189 190
190int zd_mac_open(struct net_device *netdev) 191static int zd_op_start(struct ieee80211_hw *hw)
191{ 192{
192 struct zd_mac *mac = zd_netdev_mac(netdev); 193 struct zd_mac *mac = zd_hw_mac(hw);
193 struct zd_chip *chip = &mac->chip; 194 struct zd_chip *chip = &mac->chip;
194 struct zd_usb *usb = &chip->usb; 195 struct zd_usb *usb = &chip->usb;
195 int r; 196 int r;
@@ -200,46 +201,33 @@ int zd_mac_open(struct net_device *netdev)
200 goto out; 201 goto out;
201 } 202 }
202 203
203 tasklet_enable(&mac->rx_tasklet);
204
205 r = zd_chip_enable_int(chip); 204 r = zd_chip_enable_int(chip);
206 if (r < 0) 205 if (r < 0)
207 goto out; 206 goto out;
208 207
209 r = zd_write_mac_addr(chip, netdev->dev_addr);
210 if (r)
211 goto disable_int;
212
213 r = zd_chip_set_basic_rates(chip, CR_RATES_80211B | CR_RATES_80211G); 208 r = zd_chip_set_basic_rates(chip, CR_RATES_80211B | CR_RATES_80211G);
214 if (r < 0) 209 if (r < 0)
215 goto disable_int; 210 goto disable_int;
216 r = set_rx_filter(mac); 211 r = set_rx_filter(mac);
217 if (r) 212 if (r)
218 goto disable_int; 213 goto disable_int;
219 r = set_sniffer(mac);
220 if (r)
221 goto disable_int;
222 r = set_mc_hash(mac); 214 r = set_mc_hash(mac);
223 if (r) 215 if (r)
224 goto disable_int; 216 goto disable_int;
225 r = zd_chip_switch_radio_on(chip); 217 r = zd_chip_switch_radio_on(chip);
226 if (r < 0) 218 if (r < 0)
227 goto disable_int; 219 goto disable_int;
228 r = zd_chip_set_channel(chip, mac->requested_channel); 220 r = zd_chip_enable_rxtx(chip);
229 if (r < 0)
230 goto disable_radio;
231 r = zd_chip_enable_rx(chip);
232 if (r < 0) 221 if (r < 0)
233 goto disable_radio; 222 goto disable_radio;
234 r = zd_chip_enable_hwint(chip); 223 r = zd_chip_enable_hwint(chip);
235 if (r < 0) 224 if (r < 0)
236 goto disable_rx; 225 goto disable_rxtx;
237 226
238 housekeeping_enable(mac); 227 housekeeping_enable(mac);
239 ieee80211softmac_start(netdev);
240 return 0; 228 return 0;
241disable_rx: 229disable_rxtx:
242 zd_chip_disable_rx(chip); 230 zd_chip_disable_rxtx(chip);
243disable_radio: 231disable_radio:
244 zd_chip_switch_radio_off(chip); 232 zd_chip_switch_radio_off(chip);
245disable_int: 233disable_int:
@@ -248,494 +236,190 @@ out:
248 return r; 236 return r;
249} 237}
250 238
251int zd_mac_stop(struct net_device *netdev) 239/**
240 * clear_tx_skb_control_block - clears the control block of tx skbuffs
241 * @skb: a &struct sk_buff pointer
242 *
243 * This clears the control block of skbuff buffers, which were transmitted to
244 * the device. Notify that the function is not thread-safe, so prevent
245 * multiple calls.
246 */
247static void clear_tx_skb_control_block(struct sk_buff *skb)
248{
249 struct zd_tx_skb_control_block *cb =
250 (struct zd_tx_skb_control_block *)skb->cb;
251
252 kfree(cb->control);
253 cb->control = NULL;
254}
255
256/**
257 * kfree_tx_skb - frees a tx skbuff
258 * @skb: a &struct sk_buff pointer
259 *
260 * Frees the tx skbuff. Frees also the allocated control structure in the
261 * control block if necessary.
262 */
263static void kfree_tx_skb(struct sk_buff *skb)
252{ 264{
253 struct zd_mac *mac = zd_netdev_mac(netdev); 265 clear_tx_skb_control_block(skb);
254 struct zd_chip *chip = &mac->chip; 266 dev_kfree_skb_any(skb);
267}
255 268
256 netif_stop_queue(netdev); 269static void zd_op_stop(struct ieee80211_hw *hw)
270{
271 struct zd_mac *mac = zd_hw_mac(hw);
272 struct zd_chip *chip = &mac->chip;
273 struct sk_buff *skb;
274 struct sk_buff_head *ack_wait_queue = &mac->ack_wait_queue;
257 275
258 /* 276 /* The order here deliberately is a little different from the open()
259 * The order here deliberately is a little different from the open()
260 * method, since we need to make sure there is no opportunity for RX 277 * method, since we need to make sure there is no opportunity for RX
261 * frames to be processed by softmac after we have stopped it. 278 * frames to be processed by mac80211 after we have stopped it.
262 */ 279 */
263 280
264 zd_chip_disable_rx(chip); 281 zd_chip_disable_rxtx(chip);
265 skb_queue_purge(&mac->rx_queue);
266 tasklet_disable(&mac->rx_tasklet);
267 housekeeping_disable(mac); 282 housekeeping_disable(mac);
268 ieee80211softmac_stop(netdev);
269
270 /* Ensure no work items are running or queued from this point */
271 cancel_delayed_work(&mac->set_rts_cts_work);
272 cancel_delayed_work(&mac->set_basic_rates_work);
273 flush_workqueue(zd_workqueue); 283 flush_workqueue(zd_workqueue);
274 mac->updating_rts_rate = 0;
275 mac->updating_basic_rates = 0;
276 284
277 zd_chip_disable_hwint(chip); 285 zd_chip_disable_hwint(chip);
278 zd_chip_switch_radio_off(chip); 286 zd_chip_switch_radio_off(chip);
279 zd_chip_disable_int(chip); 287 zd_chip_disable_int(chip);
280 288
281 return 0;
282}
283
284int zd_mac_set_mac_address(struct net_device *netdev, void *p)
285{
286 int r;
287 unsigned long flags;
288 struct sockaddr *addr = p;
289 struct zd_mac *mac = zd_netdev_mac(netdev);
290 struct zd_chip *chip = &mac->chip;
291 DECLARE_MAC_BUF(mac2);
292 289
293 if (!is_valid_ether_addr(addr->sa_data)) 290 while ((skb = skb_dequeue(ack_wait_queue)))
294 return -EADDRNOTAVAIL; 291 kfree_tx_skb(skb);
295
296 dev_dbg_f(zd_mac_dev(mac),
297 "Setting MAC to %s\n", print_mac(mac2, addr->sa_data));
298
299 if (netdev->flags & IFF_UP) {
300 r = zd_write_mac_addr(chip, addr->sa_data);
301 if (r)
302 return r;
303 }
304
305 spin_lock_irqsave(&mac->lock, flags);
306 memcpy(netdev->dev_addr, addr->sa_data, ETH_ALEN);
307 spin_unlock_irqrestore(&mac->lock, flags);
308
309 return 0;
310}
311
312static void set_multicast_hash_handler(struct work_struct *work)
313{
314 struct zd_mac *mac = container_of(work, struct zd_mac,
315 set_multicast_hash_work);
316 struct zd_mc_hash hash;
317
318 spin_lock_irq(&mac->lock);
319 hash = mac->multicast_hash;
320 spin_unlock_irq(&mac->lock);
321
322 zd_chip_set_multicast_hash(&mac->chip, &hash);
323}
324
325void zd_mac_set_multicast_list(struct net_device *dev)
326{
327 struct zd_mac *mac = zd_netdev_mac(dev);
328 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
329 struct zd_mc_hash hash;
330 struct dev_mc_list *mc;
331 unsigned long flags;
332 DECLARE_MAC_BUF(mac2);
333
334 if (dev->flags & (IFF_PROMISC|IFF_ALLMULTI) ||
335 ieee->iw_mode == IW_MODE_MONITOR) {
336 zd_mc_add_all(&hash);
337 } else {
338 zd_mc_clear(&hash);
339 for (mc = dev->mc_list; mc; mc = mc->next) {
340 dev_dbg_f(zd_mac_dev(mac), "mc addr %s\n",
341 print_mac(mac2, mc->dmi_addr));
342 zd_mc_add_addr(&hash, mc->dmi_addr);
343 }
344 }
345
346 spin_lock_irqsave(&mac->lock, flags);
347 mac->multicast_hash = hash;
348 spin_unlock_irqrestore(&mac->lock, flags);
349 queue_work(zd_workqueue, &mac->set_multicast_hash_work);
350} 292}
351 293
352int zd_mac_set_regdomain(struct zd_mac *mac, u8 regdomain) 294/**
353{ 295 * init_tx_skb_control_block - initializes skb control block
354 int r; 296 * @skb: a &sk_buff pointer
355 u8 channel; 297 * @dev: pointer to the mac80221 device
356 298 * @control: mac80211 tx control applying for the frame in @skb
357 ZD_ASSERT(!irqs_disabled()); 299 *
358 spin_lock_irq(&mac->lock); 300 * Initializes the control block of the skbuff to be transmitted.
359 if (regdomain == 0) { 301 */
360 regdomain = mac->default_regdomain; 302static int init_tx_skb_control_block(struct sk_buff *skb,
361 } 303 struct ieee80211_hw *hw,
362 if (!zd_regdomain_supported(regdomain)) { 304 struct ieee80211_tx_control *control)
363 spin_unlock_irq(&mac->lock); 305{
364 return -EINVAL; 306 struct zd_tx_skb_control_block *cb =
365 } 307 (struct zd_tx_skb_control_block *)skb->cb;
366 mac->regdomain = regdomain; 308
367 channel = mac->requested_channel; 309 ZD_ASSERT(sizeof(*cb) <= sizeof(skb->cb));
368 spin_unlock_irq(&mac->lock); 310 memset(cb, 0, sizeof(*cb));
369 311 cb->hw= hw;
370 r = zd_geo_init(zd_mac_to_ieee80211(mac), regdomain); 312 cb->control = kmalloc(sizeof(*control), GFP_ATOMIC);
371 if (r) 313 if (cb->control == NULL)
372 return r; 314 return -ENOMEM;
373 if (!zd_regdomain_supports_channel(regdomain, channel)) { 315 memcpy(cb->control, control, sizeof(*control));
374 r = reset_channel(mac);
375 if (r)
376 return r;
377 }
378 316
379 return 0; 317 return 0;
380} 318}
381 319
382u8 zd_mac_get_regdomain(struct zd_mac *mac) 320/**
383{ 321 * tx_status - reports tx status of a packet if required
384 unsigned long flags; 322 * @hw - a &struct ieee80211_hw pointer
385 u8 regdomain; 323 * @skb - a sk-buffer
386 324 * @status - the tx status of the packet without control information
387 spin_lock_irqsave(&mac->lock, flags); 325 * @success - True for successfull transmission of the frame
388 regdomain = mac->regdomain; 326 *
389 spin_unlock_irqrestore(&mac->lock, flags); 327 * This information calls ieee80211_tx_status_irqsafe() if required by the
390 return regdomain; 328 * control information. It copies the control information into the status
391} 329 * information.
392 330 *
393/* Fallback to lowest rate, if rate is unknown. */ 331 * If no status information has been requested, the skb is freed.
394static u8 rate_to_zd_rate(u8 rate) 332 */
395{ 333static void tx_status(struct ieee80211_hw *hw, struct sk_buff *skb,
396 switch (rate) { 334 struct ieee80211_tx_status *status,
397 case IEEE80211_CCK_RATE_2MB: 335 bool success)
398 return ZD_CCK_RATE_2M;
399 case IEEE80211_CCK_RATE_5MB:
400 return ZD_CCK_RATE_5_5M;
401 case IEEE80211_CCK_RATE_11MB:
402 return ZD_CCK_RATE_11M;
403 case IEEE80211_OFDM_RATE_6MB:
404 return ZD_OFDM_RATE_6M;
405 case IEEE80211_OFDM_RATE_9MB:
406 return ZD_OFDM_RATE_9M;
407 case IEEE80211_OFDM_RATE_12MB:
408 return ZD_OFDM_RATE_12M;
409 case IEEE80211_OFDM_RATE_18MB:
410 return ZD_OFDM_RATE_18M;
411 case IEEE80211_OFDM_RATE_24MB:
412 return ZD_OFDM_RATE_24M;
413 case IEEE80211_OFDM_RATE_36MB:
414 return ZD_OFDM_RATE_36M;
415 case IEEE80211_OFDM_RATE_48MB:
416 return ZD_OFDM_RATE_48M;
417 case IEEE80211_OFDM_RATE_54MB:
418 return ZD_OFDM_RATE_54M;
419 }
420 return ZD_CCK_RATE_1M;
421}
422
423static u16 rate_to_cr_rate(u8 rate)
424{
425 switch (rate) {
426 case IEEE80211_CCK_RATE_2MB:
427 return CR_RATE_1M;
428 case IEEE80211_CCK_RATE_5MB:
429 return CR_RATE_5_5M;
430 case IEEE80211_CCK_RATE_11MB:
431 return CR_RATE_11M;
432 case IEEE80211_OFDM_RATE_6MB:
433 return CR_RATE_6M;
434 case IEEE80211_OFDM_RATE_9MB:
435 return CR_RATE_9M;
436 case IEEE80211_OFDM_RATE_12MB:
437 return CR_RATE_12M;
438 case IEEE80211_OFDM_RATE_18MB:
439 return CR_RATE_18M;
440 case IEEE80211_OFDM_RATE_24MB:
441 return CR_RATE_24M;
442 case IEEE80211_OFDM_RATE_36MB:
443 return CR_RATE_36M;
444 case IEEE80211_OFDM_RATE_48MB:
445 return CR_RATE_48M;
446 case IEEE80211_OFDM_RATE_54MB:
447 return CR_RATE_54M;
448 }
449 return CR_RATE_1M;
450}
451
452static void try_enable_tx(struct zd_mac *mac)
453{
454 unsigned long flags;
455
456 spin_lock_irqsave(&mac->lock, flags);
457 if (mac->updating_rts_rate == 0 && mac->updating_basic_rates == 0)
458 netif_wake_queue(mac->netdev);
459 spin_unlock_irqrestore(&mac->lock, flags);
460}
461
462static void set_rts_cts_work(struct work_struct *work)
463{ 336{
464 struct zd_mac *mac = 337 struct zd_tx_skb_control_block *cb = (struct zd_tx_skb_control_block *)
465 container_of(work, struct zd_mac, set_rts_cts_work.work); 338 skb->cb;
466 unsigned long flags;
467 u8 rts_rate;
468 unsigned int short_preamble;
469
470 mutex_lock(&mac->chip.mutex);
471
472 spin_lock_irqsave(&mac->lock, flags);
473 mac->updating_rts_rate = 0;
474 rts_rate = mac->rts_rate;
475 short_preamble = mac->short_preamble;
476 spin_unlock_irqrestore(&mac->lock, flags);
477
478 zd_chip_set_rts_cts_rate_locked(&mac->chip, rts_rate, short_preamble);
479 mutex_unlock(&mac->chip.mutex);
480 339
481 try_enable_tx(mac); 340 ZD_ASSERT(cb->control != NULL);
341 memcpy(&status->control, cb->control, sizeof(status->control));
342 if (!success)
343 status->excessive_retries = 1;
344 clear_tx_skb_control_block(skb);
345 ieee80211_tx_status_irqsafe(hw, skb, status);
482} 346}
483 347
484static void set_basic_rates_work(struct work_struct *work) 348/**
349 * zd_mac_tx_failed - callback for failed frames
350 * @dev: the mac80211 wireless device
351 *
352 * This function is called if a frame couldn't be succesfully be
353 * transferred. The first frame from the tx queue, will be selected and
354 * reported as error to the upper layers.
355 */
356void zd_mac_tx_failed(struct ieee80211_hw *hw)
485{ 357{
486 struct zd_mac *mac = 358 struct sk_buff_head *q = &zd_hw_mac(hw)->ack_wait_queue;
487 container_of(work, struct zd_mac, set_basic_rates_work.work); 359 struct sk_buff *skb;
488 unsigned long flags; 360 struct ieee80211_tx_status status = {{0}};
489 u16 basic_rates;
490
491 mutex_lock(&mac->chip.mutex);
492
493 spin_lock_irqsave(&mac->lock, flags);
494 mac->updating_basic_rates = 0;
495 basic_rates = mac->basic_rates;
496 spin_unlock_irqrestore(&mac->lock, flags);
497
498 zd_chip_set_basic_rates_locked(&mac->chip, basic_rates);
499 mutex_unlock(&mac->chip.mutex);
500 361
501 try_enable_tx(mac); 362 skb = skb_dequeue(q);
363 if (skb == NULL)
364 return;
365 tx_status(hw, skb, &status, 0);
502} 366}
503 367
504static void bssinfo_change(struct net_device *netdev, u32 changes) 368/**
505{ 369 * zd_mac_tx_to_dev - callback for USB layer
506 struct zd_mac *mac = zd_netdev_mac(netdev); 370 * @skb: a &sk_buff pointer
507 struct ieee80211softmac_device *softmac = ieee80211_priv(netdev); 371 * @error: error value, 0 if transmission successful
508 struct ieee80211softmac_bss_info *bssinfo = &softmac->bssinfo; 372 *
509 int need_set_rts_cts = 0; 373 * Informs the MAC layer that the frame has successfully transferred to the
510 int need_set_rates = 0; 374 * device. If an ACK is required and the transfer to the device has been
511 u16 basic_rates; 375 * successful, the packets are put on the @ack_wait_queue with
512 unsigned long flags; 376 * the control set removed.
513 377 */
514 dev_dbg_f(zd_mac_dev(mac), "changes: %x\n", changes); 378void zd_mac_tx_to_dev(struct sk_buff *skb, int error)
515 379{
516 if (changes & IEEE80211SOFTMAC_BSSINFOCHG_SHORT_PREAMBLE) { 380 struct zd_tx_skb_control_block *cb =
517 spin_lock_irqsave(&mac->lock, flags); 381 (struct zd_tx_skb_control_block *)skb->cb;
518 mac->short_preamble = bssinfo->short_preamble; 382 struct ieee80211_hw *hw = cb->hw;
519 spin_unlock_irqrestore(&mac->lock, flags); 383
520 need_set_rts_cts = 1; 384 if (likely(cb->control)) {
521 } 385 skb_pull(skb, sizeof(struct zd_ctrlset));
522 386 if (unlikely(error ||
523 if (changes & IEEE80211SOFTMAC_BSSINFOCHG_RATES) { 387 (cb->control->flags & IEEE80211_TXCTL_NO_ACK)))
524 /* Set RTS rate to highest available basic rate */ 388 {
525 u8 hi_rate = ieee80211softmac_highest_supported_rate(softmac, 389 struct ieee80211_tx_status status = {{0}};
526 &bssinfo->supported_rates, 1); 390 tx_status(hw, skb, &status, !error);
527 hi_rate = rate_to_zd_rate(hi_rate);
528
529 spin_lock_irqsave(&mac->lock, flags);
530 if (hi_rate != mac->rts_rate) {
531 mac->rts_rate = hi_rate;
532 need_set_rts_cts = 1;
533 }
534 spin_unlock_irqrestore(&mac->lock, flags);
535
536 /* Set basic rates */
537 need_set_rates = 1;
538 if (bssinfo->supported_rates.count == 0) {
539 /* Allow the device to be flexible */
540 basic_rates = CR_RATES_80211B | CR_RATES_80211G;
541 } else { 391 } else {
542 int i = 0; 392 struct sk_buff_head *q =
543 basic_rates = 0; 393 &zd_hw_mac(hw)->ack_wait_queue;
544 394
545 for (i = 0; i < bssinfo->supported_rates.count; i++) { 395 skb_queue_tail(q, skb);
546 u16 rate = bssinfo->supported_rates.rates[i]; 396 while (skb_queue_len(q) > ZD_MAC_MAX_ACK_WAITERS)
547 if ((rate & IEEE80211_BASIC_RATE_MASK) == 0) 397 zd_mac_tx_failed(hw);
548 continue;
549
550 rate &= ~IEEE80211_BASIC_RATE_MASK;
551 basic_rates |= rate_to_cr_rate(rate);
552 }
553 } 398 }
554 spin_lock_irqsave(&mac->lock, flags); 399 } else {
555 mac->basic_rates = basic_rates; 400 kfree_tx_skb(skb);
556 spin_unlock_irqrestore(&mac->lock, flags);
557 }
558
559 /* Schedule any changes we made above */
560
561 spin_lock_irqsave(&mac->lock, flags);
562 if (need_set_rts_cts && !mac->updating_rts_rate) {
563 mac->updating_rts_rate = 1;
564 netif_stop_queue(mac->netdev);
565 queue_delayed_work(zd_workqueue, &mac->set_rts_cts_work, 0);
566 }
567 if (need_set_rates && !mac->updating_basic_rates) {
568 mac->updating_basic_rates = 1;
569 netif_stop_queue(mac->netdev);
570 queue_delayed_work(zd_workqueue, &mac->set_basic_rates_work,
571 0);
572 }
573 spin_unlock_irqrestore(&mac->lock, flags);
574}
575
576static void set_channel(struct net_device *netdev, u8 channel)
577{
578 struct zd_mac *mac = zd_netdev_mac(netdev);
579
580 dev_dbg_f(zd_mac_dev(mac), "channel %d\n", channel);
581
582 zd_chip_set_channel(&mac->chip, channel);
583}
584
585int zd_mac_request_channel(struct zd_mac *mac, u8 channel)
586{
587 unsigned long lock_flags;
588 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
589
590 if (ieee->iw_mode == IW_MODE_INFRA)
591 return -EPERM;
592
593 spin_lock_irqsave(&mac->lock, lock_flags);
594 if (!zd_regdomain_supports_channel(mac->regdomain, channel)) {
595 spin_unlock_irqrestore(&mac->lock, lock_flags);
596 return -EINVAL;
597 }
598 mac->requested_channel = channel;
599 spin_unlock_irqrestore(&mac->lock, lock_flags);
600 if (netif_running(mac->netdev))
601 return zd_chip_set_channel(&mac->chip, channel);
602 else
603 return 0;
604}
605
606u8 zd_mac_get_channel(struct zd_mac *mac)
607{
608 u8 channel = zd_chip_get_channel(&mac->chip);
609
610 dev_dbg_f(zd_mac_dev(mac), "channel %u\n", channel);
611 return channel;
612}
613
614int zd_mac_set_mode(struct zd_mac *mac, u32 mode)
615{
616 struct ieee80211_device *ieee;
617
618 switch (mode) {
619 case IW_MODE_AUTO:
620 case IW_MODE_ADHOC:
621 case IW_MODE_INFRA:
622 mac->netdev->type = ARPHRD_ETHER;
623 break;
624 case IW_MODE_MONITOR:
625 mac->netdev->type = ARPHRD_IEEE80211_RADIOTAP;
626 break;
627 default:
628 dev_dbg_f(zd_mac_dev(mac), "wrong mode %u\n", mode);
629 return -EINVAL;
630 }
631
632 ieee = zd_mac_to_ieee80211(mac);
633 ZD_ASSERT(!irqs_disabled());
634 spin_lock_irq(&ieee->lock);
635 ieee->iw_mode = mode;
636 spin_unlock_irq(&ieee->lock);
637
638 if (netif_running(mac->netdev)) {
639 int r = set_rx_filter(mac);
640 if (r)
641 return r;
642 return set_sniffer(mac);
643 }
644
645 return 0;
646}
647
648int zd_mac_get_mode(struct zd_mac *mac, u32 *mode)
649{
650 unsigned long flags;
651 struct ieee80211_device *ieee;
652
653 ieee = zd_mac_to_ieee80211(mac);
654 spin_lock_irqsave(&ieee->lock, flags);
655 *mode = ieee->iw_mode;
656 spin_unlock_irqrestore(&ieee->lock, flags);
657 return 0;
658}
659
660int zd_mac_get_range(struct zd_mac *mac, struct iw_range *range)
661{
662 int i;
663 const struct channel_range *channel_range;
664 u8 regdomain;
665
666 memset(range, 0, sizeof(*range));
667
668 /* FIXME: Not so important and depends on the mode. For 802.11g
669 * usually this value is used. It seems to be that Bit/s number is
670 * given here.
671 */
672 range->throughput = 27 * 1000 * 1000;
673
674 range->max_qual.qual = 100;
675 range->max_qual.level = 100;
676
677 /* FIXME: Needs still to be tuned. */
678 range->avg_qual.qual = 71;
679 range->avg_qual.level = 80;
680
681 /* FIXME: depends on standard? */
682 range->min_rts = 256;
683 range->max_rts = 2346;
684
685 range->min_frag = MIN_FRAG_THRESHOLD;
686 range->max_frag = MAX_FRAG_THRESHOLD;
687
688 range->max_encoding_tokens = WEP_KEYS;
689 range->num_encoding_sizes = 2;
690 range->encoding_size[0] = 5;
691 range->encoding_size[1] = WEP_KEY_LEN;
692
693 range->we_version_compiled = WIRELESS_EXT;
694 range->we_version_source = 20;
695
696 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
697 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
698
699 ZD_ASSERT(!irqs_disabled());
700 spin_lock_irq(&mac->lock);
701 regdomain = mac->regdomain;
702 spin_unlock_irq(&mac->lock);
703 channel_range = zd_channel_range(regdomain);
704
705 range->num_channels = channel_range->end - channel_range->start;
706 range->old_num_channels = range->num_channels;
707 range->num_frequency = range->num_channels;
708 range->old_num_frequency = range->num_frequency;
709
710 for (i = 0; i < range->num_frequency; i++) {
711 struct iw_freq *freq = &range->freq[i];
712 freq->i = channel_range->start + i;
713 zd_channel_to_freq(freq, freq->i);
714 } 401 }
715
716 return 0;
717} 402}
718 403
719static int zd_calc_tx_length_us(u8 *service, u8 zd_rate, u16 tx_length) 404static int zd_calc_tx_length_us(u8 *service, u8 zd_rate, u16 tx_length)
720{ 405{
721 /* ZD_PURE_RATE() must be used to remove the modulation type flag of 406 /* ZD_PURE_RATE() must be used to remove the modulation type flag of
722 * the zd-rate values. */ 407 * the zd-rate values.
408 */
723 static const u8 rate_divisor[] = { 409 static const u8 rate_divisor[] = {
724 [ZD_PURE_RATE(ZD_CCK_RATE_1M)] = 1, 410 [ZD_PURE_RATE(ZD_CCK_RATE_1M)] = 1,
725 [ZD_PURE_RATE(ZD_CCK_RATE_2M)] = 2, 411 [ZD_PURE_RATE(ZD_CCK_RATE_2M)] = 2,
726 412 /* Bits must be doubled. */
727 /* bits must be doubled */ 413 [ZD_PURE_RATE(ZD_CCK_RATE_5_5M)] = 11,
728 [ZD_PURE_RATE(ZD_CCK_RATE_5_5M)] = 11, 414 [ZD_PURE_RATE(ZD_CCK_RATE_11M)] = 11,
729 415 [ZD_PURE_RATE(ZD_OFDM_RATE_6M)] = 6,
730 [ZD_PURE_RATE(ZD_CCK_RATE_11M)] = 11, 416 [ZD_PURE_RATE(ZD_OFDM_RATE_9M)] = 9,
731 [ZD_PURE_RATE(ZD_OFDM_RATE_6M)] = 6, 417 [ZD_PURE_RATE(ZD_OFDM_RATE_12M)] = 12,
732 [ZD_PURE_RATE(ZD_OFDM_RATE_9M)] = 9, 418 [ZD_PURE_RATE(ZD_OFDM_RATE_18M)] = 18,
733 [ZD_PURE_RATE(ZD_OFDM_RATE_12M)] = 12, 419 [ZD_PURE_RATE(ZD_OFDM_RATE_24M)] = 24,
734 [ZD_PURE_RATE(ZD_OFDM_RATE_18M)] = 18, 420 [ZD_PURE_RATE(ZD_OFDM_RATE_36M)] = 36,
735 [ZD_PURE_RATE(ZD_OFDM_RATE_24M)] = 24, 421 [ZD_PURE_RATE(ZD_OFDM_RATE_48M)] = 48,
736 [ZD_PURE_RATE(ZD_OFDM_RATE_36M)] = 36, 422 [ZD_PURE_RATE(ZD_OFDM_RATE_54M)] = 54,
737 [ZD_PURE_RATE(ZD_OFDM_RATE_48M)] = 48,
738 [ZD_PURE_RATE(ZD_OFDM_RATE_54M)] = 54,
739 }; 423 };
740 424
741 u32 bits = (u32)tx_length * 8; 425 u32 bits = (u32)tx_length * 8;
@@ -764,34 +448,10 @@ static int zd_calc_tx_length_us(u8 *service, u8 zd_rate, u16 tx_length)
764 return bits/divisor; 448 return bits/divisor;
765} 449}
766 450
767static void cs_set_modulation(struct zd_mac *mac, struct zd_ctrlset *cs,
768 struct ieee80211_hdr_4addr *hdr)
769{
770 struct ieee80211softmac_device *softmac = ieee80211_priv(mac->netdev);
771 u16 ftype = WLAN_FC_GET_TYPE(le16_to_cpu(hdr->frame_ctl));
772 u8 rate;
773 int is_mgt = (ftype == IEEE80211_FTYPE_MGMT) != 0;
774 int is_multicast = is_multicast_ether_addr(hdr->addr1);
775 int short_preamble = ieee80211softmac_short_preamble_ok(softmac,
776 is_multicast, is_mgt);
777
778 rate = ieee80211softmac_suggest_txrate(softmac, is_multicast, is_mgt);
779 cs->modulation = rate_to_zd_rate(rate);
780
781 /* Set short preamble bit when appropriate */
782 if (short_preamble && ZD_MODULATION_TYPE(cs->modulation) == ZD_CCK
783 && cs->modulation != ZD_CCK_RATE_1M)
784 cs->modulation |= ZD_CCK_PREA_SHORT;
785}
786
787static void cs_set_control(struct zd_mac *mac, struct zd_ctrlset *cs, 451static void cs_set_control(struct zd_mac *mac, struct zd_ctrlset *cs,
788 struct ieee80211_hdr_4addr *header) 452 struct ieee80211_hdr *header, u32 flags)
789{ 453{
790 struct ieee80211softmac_device *softmac = ieee80211_priv(mac->netdev); 454 u16 fctl = le16_to_cpu(header->frame_control);
791 unsigned int tx_length = le16_to_cpu(cs->tx_length);
792 u16 fctl = le16_to_cpu(header->frame_ctl);
793 u16 ftype = WLAN_FC_GET_TYPE(fctl);
794 u16 stype = WLAN_FC_GET_STYPE(fctl);
795 455
796 /* 456 /*
797 * CONTROL TODO: 457 * CONTROL TODO:
@@ -802,7 +462,7 @@ static void cs_set_control(struct zd_mac *mac, struct zd_ctrlset *cs,
802 cs->control = 0; 462 cs->control = 0;
803 463
804 /* First fragment */ 464 /* First fragment */
805 if (WLAN_GET_SEQ_FRAG(le16_to_cpu(header->seq_ctl)) == 0) 465 if (flags & IEEE80211_TXCTL_FIRST_FRAGMENT)
806 cs->control |= ZD_CS_NEED_RANDOM_BACKOFF; 466 cs->control |= ZD_CS_NEED_RANDOM_BACKOFF;
807 467
808 /* Multicast */ 468 /* Multicast */
@@ -810,54 +470,37 @@ static void cs_set_control(struct zd_mac *mac, struct zd_ctrlset *cs,
810 cs->control |= ZD_CS_MULTICAST; 470 cs->control |= ZD_CS_MULTICAST;
811 471
812 /* PS-POLL */ 472 /* PS-POLL */
813 if (ftype == IEEE80211_FTYPE_CTL && stype == IEEE80211_STYPE_PSPOLL) 473 if ((fctl & (IEEE80211_FCTL_FTYPE|IEEE80211_FCTL_STYPE)) ==
474 (IEEE80211_FTYPE_CTL|IEEE80211_STYPE_PSPOLL))
814 cs->control |= ZD_CS_PS_POLL_FRAME; 475 cs->control |= ZD_CS_PS_POLL_FRAME;
815 476
816 /* Unicast data frames over the threshold should have RTS */ 477 if (flags & IEEE80211_TXCTL_USE_RTS_CTS)
817 if (!is_multicast_ether_addr(header->addr1) &&
818 ftype != IEEE80211_FTYPE_MGMT &&
819 tx_length > zd_netdev_ieee80211(mac->netdev)->rts)
820 cs->control |= ZD_CS_RTS; 478 cs->control |= ZD_CS_RTS;
821 479
822 /* Use CTS-to-self protection if required */ 480 if (flags & IEEE80211_TXCTL_USE_CTS_PROTECT)
823 if (ZD_MODULATION_TYPE(cs->modulation) == ZD_OFDM &&
824 ieee80211softmac_protection_needed(softmac)) {
825 /* FIXME: avoid sending RTS *and* self-CTS, is that correct? */
826 cs->control &= ~ZD_CS_RTS;
827 cs->control |= ZD_CS_SELF_CTS; 481 cs->control |= ZD_CS_SELF_CTS;
828 }
829 482
830 /* FIXME: Management frame? */ 483 /* FIXME: Management frame? */
831} 484}
832 485
833static int fill_ctrlset(struct zd_mac *mac, 486static int fill_ctrlset(struct zd_mac *mac,
834 struct ieee80211_txb *txb, 487 struct sk_buff *skb,
835 int frag_num) 488 struct ieee80211_tx_control *control)
836{ 489{
837 int r; 490 int r;
838 struct sk_buff *skb = txb->fragments[frag_num]; 491 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
839 struct ieee80211_hdr_4addr *hdr = 492 unsigned int frag_len = skb->len + FCS_LEN;
840 (struct ieee80211_hdr_4addr *) skb->data;
841 unsigned int frag_len = skb->len + IEEE80211_FCS_LEN;
842 unsigned int next_frag_len;
843 unsigned int packet_length; 493 unsigned int packet_length;
844 struct zd_ctrlset *cs = (struct zd_ctrlset *) 494 struct zd_ctrlset *cs = (struct zd_ctrlset *)
845 skb_push(skb, sizeof(struct zd_ctrlset)); 495 skb_push(skb, sizeof(struct zd_ctrlset));
846 496
847 if (frag_num+1 < txb->nr_frags) {
848 next_frag_len = txb->fragments[frag_num+1]->len +
849 IEEE80211_FCS_LEN;
850 } else {
851 next_frag_len = 0;
852 }
853 ZD_ASSERT(frag_len <= 0xffff); 497 ZD_ASSERT(frag_len <= 0xffff);
854 ZD_ASSERT(next_frag_len <= 0xffff);
855 498
856 cs_set_modulation(mac, cs, hdr); 499 cs->modulation = control->tx_rate;
857 500
858 cs->tx_length = cpu_to_le16(frag_len); 501 cs->tx_length = cpu_to_le16(frag_len);
859 502
860 cs_set_control(mac, cs, hdr); 503 cs_set_control(mac, cs, hdr, control->flags);
861 504
862 packet_length = frag_len + sizeof(struct zd_ctrlset) + 10; 505 packet_length = frag_len + sizeof(struct zd_ctrlset) + 10;
863 ZD_ASSERT(packet_length <= 0xffff); 506 ZD_ASSERT(packet_length <= 0xffff);
@@ -886,419 +529,399 @@ static int fill_ctrlset(struct zd_mac *mac,
886 if (r < 0) 529 if (r < 0)
887 return r; 530 return r;
888 cs->current_length = cpu_to_le16(r); 531 cs->current_length = cpu_to_le16(r);
889 532 cs->next_frame_length = 0;
890 if (next_frag_len == 0) {
891 cs->next_frame_length = 0;
892 } else {
893 r = zd_calc_tx_length_us(NULL, ZD_RATE(cs->modulation),
894 next_frag_len);
895 if (r < 0)
896 return r;
897 cs->next_frame_length = cpu_to_le16(r);
898 }
899 533
900 return 0; 534 return 0;
901} 535}
902 536
903static int zd_mac_tx(struct zd_mac *mac, struct ieee80211_txb *txb, int pri) 537/**
538 * zd_op_tx - transmits a network frame to the device
539 *
540 * @dev: mac80211 hardware device
541 * @skb: socket buffer
542 * @control: the control structure
543 *
544 * This function transmit an IEEE 802.11 network frame to the device. The
545 * control block of the skbuff will be initialized. If necessary the incoming
546 * mac80211 queues will be stopped.
547 */
548static int zd_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb,
549 struct ieee80211_tx_control *control)
904{ 550{
905 int i, r; 551 struct zd_mac *mac = zd_hw_mac(hw);
906 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac); 552 int r;
907 553
908 for (i = 0; i < txb->nr_frags; i++) { 554 r = fill_ctrlset(mac, skb, control);
909 struct sk_buff *skb = txb->fragments[i]; 555 if (r)
556 return r;
910 557
911 r = fill_ctrlset(mac, txb, i); 558 r = init_tx_skb_control_block(skb, hw, control);
912 if (r) { 559 if (r)
913 ieee->stats.tx_dropped++; 560 return r;
914 return r; 561 r = zd_usb_tx(&mac->chip.usb, skb);
915 } 562 if (r) {
916 r = zd_usb_tx(&mac->chip.usb, skb->data, skb->len); 563 clear_tx_skb_control_block(skb);
917 if (r) { 564 return r;
918 ieee->stats.tx_dropped++;
919 return r;
920 }
921 } 565 }
922
923 /* FIXME: shouldn't this be handled by the upper layers? */
924 mac->netdev->trans_start = jiffies;
925
926 ieee80211_txb_free(txb);
927 return 0; 566 return 0;
928} 567}
929 568
930struct zd_rt_hdr { 569/**
931 struct ieee80211_radiotap_header rt_hdr; 570 * filter_ack - filters incoming packets for acknowledgements
932 u8 rt_flags; 571 * @dev: the mac80211 device
933 u8 rt_rate; 572 * @rx_hdr: received header
934 u16 rt_channel; 573 * @stats: the status for the received packet
935 u16 rt_chbitmask;
936} __attribute__((packed));
937
938static void fill_rt_header(void *buffer, struct zd_mac *mac,
939 const struct ieee80211_rx_stats *stats,
940 const struct rx_status *status)
941{
942 struct zd_rt_hdr *hdr = buffer;
943
944 hdr->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
945 hdr->rt_hdr.it_pad = 0;
946 hdr->rt_hdr.it_len = cpu_to_le16(sizeof(struct zd_rt_hdr));
947 hdr->rt_hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
948 (1 << IEEE80211_RADIOTAP_CHANNEL) |
949 (1 << IEEE80211_RADIOTAP_RATE));
950
951 hdr->rt_flags = 0;
952 if (status->decryption_type & (ZD_RX_WEP64|ZD_RX_WEP128|ZD_RX_WEP256))
953 hdr->rt_flags |= IEEE80211_RADIOTAP_F_WEP;
954
955 hdr->rt_rate = stats->rate / 5;
956
957 /* FIXME: 802.11a */
958 hdr->rt_channel = cpu_to_le16(ieee80211chan2mhz(
959 _zd_chip_get_channel(&mac->chip)));
960 hdr->rt_chbitmask = cpu_to_le16(IEEE80211_CHAN_2GHZ |
961 ((status->frame_status & ZD_RX_FRAME_MODULATION_MASK) ==
962 ZD_RX_OFDM ? IEEE80211_CHAN_OFDM : IEEE80211_CHAN_CCK));
963}
964
965/* Returns 1 if the data packet is for us and 0 otherwise. */
966static int is_data_packet_for_us(struct ieee80211_device *ieee,
967 struct ieee80211_hdr_4addr *hdr)
968{
969 struct net_device *netdev = ieee->dev;
970 u16 fc = le16_to_cpu(hdr->frame_ctl);
971
972 ZD_ASSERT(WLAN_FC_GET_TYPE(fc) == IEEE80211_FTYPE_DATA);
973
974 switch (ieee->iw_mode) {
975 case IW_MODE_ADHOC:
976 if ((fc & (IEEE80211_FCTL_TODS|IEEE80211_FCTL_FROMDS)) != 0 ||
977 compare_ether_addr(hdr->addr3, ieee->bssid) != 0)
978 return 0;
979 break;
980 case IW_MODE_AUTO:
981 case IW_MODE_INFRA:
982 if ((fc & (IEEE80211_FCTL_TODS|IEEE80211_FCTL_FROMDS)) !=
983 IEEE80211_FCTL_FROMDS ||
984 compare_ether_addr(hdr->addr2, ieee->bssid) != 0)
985 return 0;
986 break;
987 default:
988 ZD_ASSERT(ieee->iw_mode != IW_MODE_MONITOR);
989 return 0;
990 }
991
992 return compare_ether_addr(hdr->addr1, netdev->dev_addr) == 0 ||
993 (is_multicast_ether_addr(hdr->addr1) &&
994 compare_ether_addr(hdr->addr3, netdev->dev_addr) != 0) ||
995 (netdev->flags & IFF_PROMISC);
996}
997
998/* Filters received packets. The function returns 1 if the packet should be
999 * forwarded to ieee80211_rx(). If the packet should be ignored the function
1000 * returns 0. If an invalid packet is found the function returns -EINVAL.
1001 * 574 *
1002 * The function calls ieee80211_rx_mgt() directly. 575 * This functions looks for ACK packets and tries to match them with the
576 * frames in the tx queue. If a match is found the frame will be dequeued and
577 * the upper layers is informed about the successful transmission. If
578 * mac80211 queues have been stopped and the number of frames still to be
579 * transmitted is low the queues will be opened again.
1003 * 580 *
1004 * It has been based on ieee80211_rx_any. 581 * Returns 1 if the frame was an ACK, 0 if it was ignored.
1005 */ 582 */
1006static int filter_rx(struct ieee80211_device *ieee, 583static int filter_ack(struct ieee80211_hw *hw, struct ieee80211_hdr *rx_hdr,
1007 const u8 *buffer, unsigned int length, 584 struct ieee80211_rx_status *stats)
1008 struct ieee80211_rx_stats *stats)
1009{ 585{
1010 struct ieee80211_hdr_4addr *hdr; 586 u16 fc = le16_to_cpu(rx_hdr->frame_control);
1011 u16 fc; 587 struct sk_buff *skb;
1012 588 struct sk_buff_head *q;
1013 if (ieee->iw_mode == IW_MODE_MONITOR) 589 unsigned long flags;
1014 return 1;
1015
1016 hdr = (struct ieee80211_hdr_4addr *)buffer;
1017 fc = le16_to_cpu(hdr->frame_ctl);
1018 if ((fc & IEEE80211_FCTL_VERS) != 0)
1019 return -EINVAL;
1020 590
1021 switch (WLAN_FC_GET_TYPE(fc)) { 591 if ((fc & (IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE)) !=
1022 case IEEE80211_FTYPE_MGMT: 592 (IEEE80211_FTYPE_CTL | IEEE80211_STYPE_ACK))
1023 if (length < sizeof(struct ieee80211_hdr_3addr))
1024 return -EINVAL;
1025 ieee80211_rx_mgt(ieee, hdr, stats);
1026 return 0; 593 return 0;
1027 case IEEE80211_FTYPE_CTL:
1028 return 0;
1029 case IEEE80211_FTYPE_DATA:
1030 /* Ignore invalid short buffers */
1031 if (length < sizeof(struct ieee80211_hdr_3addr))
1032 return -EINVAL;
1033 return is_data_packet_for_us(ieee, hdr);
1034 }
1035 594
1036 return -EINVAL; 595 q = &zd_hw_mac(hw)->ack_wait_queue;
596 spin_lock_irqsave(&q->lock, flags);
597 for (skb = q->next; skb != (struct sk_buff *)q; skb = skb->next) {
598 struct ieee80211_hdr *tx_hdr;
599
600 tx_hdr = (struct ieee80211_hdr *)skb->data;
601 if (likely(!compare_ether_addr(tx_hdr->addr2, rx_hdr->addr1)))
602 {
603 struct ieee80211_tx_status status = {{0}};
604 status.flags = IEEE80211_TX_STATUS_ACK;
605 status.ack_signal = stats->ssi;
606 __skb_unlink(skb, q);
607 tx_status(hw, skb, &status, 1);
608 goto out;
609 }
610 }
611out:
612 spin_unlock_irqrestore(&q->lock, flags);
613 return 1;
1037} 614}
1038 615
1039static void update_qual_rssi(struct zd_mac *mac, 616int zd_mac_rx(struct ieee80211_hw *hw, const u8 *buffer, unsigned int length)
1040 const u8 *buffer, unsigned int length,
1041 u8 qual_percent, u8 rssi_percent)
1042{ 617{
1043 unsigned long flags; 618 struct zd_mac *mac = zd_hw_mac(hw);
1044 struct ieee80211_hdr_3addr *hdr; 619 struct ieee80211_rx_status stats;
1045 int i; 620 const struct rx_status *status;
621 struct sk_buff *skb;
622 int bad_frame = 0;
1046 623
1047 hdr = (struct ieee80211_hdr_3addr *)buffer; 624 if (length < ZD_PLCP_HEADER_SIZE + 10 /* IEEE80211_1ADDR_LEN */ +
1048 if (length < offsetof(struct ieee80211_hdr_3addr, addr3)) 625 FCS_LEN + sizeof(struct rx_status))
1049 return; 626 return -EINVAL;
1050 if (compare_ether_addr(hdr->addr2, zd_mac_to_ieee80211(mac)->bssid) != 0)
1051 return;
1052 627
1053 spin_lock_irqsave(&mac->lock, flags); 628 memset(&stats, 0, sizeof(stats));
1054 i = mac->stats_count % ZD_MAC_STATS_BUFFER_SIZE;
1055 mac->qual_buffer[i] = qual_percent;
1056 mac->rssi_buffer[i] = rssi_percent;
1057 mac->stats_count++;
1058 spin_unlock_irqrestore(&mac->lock, flags);
1059}
1060 629
1061static int fill_rx_stats(struct ieee80211_rx_stats *stats, 630 /* Note about pass_failed_fcs and pass_ctrl access below:
1062 const struct rx_status **pstatus, 631 * mac locking intentionally omitted here, as this is the only unlocked
1063 struct zd_mac *mac, 632 * reader and the only writer is configure_filter. Plus, if there were
1064 const u8 *buffer, unsigned int length) 633 * any races accessing these variables, it wouldn't really matter.
1065{ 634 * If mac80211 ever provides a way for us to access filter flags
1066 const struct rx_status *status; 635 * from outside configure_filter, we could improve on this. Also, this
636 * situation may change once we implement some kind of DMA-into-skb
637 * RX path. */
1067 638
1068 *pstatus = status = (struct rx_status *) 639 /* Caller has to ensure that length >= sizeof(struct rx_status). */
640 status = (struct rx_status *)
1069 (buffer + (length - sizeof(struct rx_status))); 641 (buffer + (length - sizeof(struct rx_status)));
1070 if (status->frame_status & ZD_RX_ERROR) { 642 if (status->frame_status & ZD_RX_ERROR) {
1071 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac); 643 if (mac->pass_failed_fcs &&
1072 ieee->stats.rx_errors++; 644 (status->frame_status & ZD_RX_CRC32_ERROR)) {
1073 if (status->frame_status & ZD_RX_TIMEOUT_ERROR) 645 stats.flag |= RX_FLAG_FAILED_FCS_CRC;
1074 ieee->stats.rx_missed_errors++; 646 bad_frame = 1;
1075 else if (status->frame_status & ZD_RX_FIFO_OVERRUN_ERROR) 647 } else {
1076 ieee->stats.rx_fifo_errors++; 648 return -EINVAL;
1077 else if (status->frame_status & ZD_RX_DECRYPTION_ERROR)
1078 ieee->ieee_stats.rx_discards_undecryptable++;
1079 else if (status->frame_status & ZD_RX_CRC32_ERROR) {
1080 ieee->stats.rx_crc_errors++;
1081 ieee->ieee_stats.rx_fcs_errors++;
1082 } 649 }
1083 else if (status->frame_status & ZD_RX_CRC16_ERROR)
1084 ieee->stats.rx_crc_errors++;
1085 return -EINVAL;
1086 } 650 }
1087 651
1088 memset(stats, 0, sizeof(struct ieee80211_rx_stats)); 652 stats.channel = _zd_chip_get_channel(&mac->chip);
1089 stats->len = length - (ZD_PLCP_HEADER_SIZE + IEEE80211_FCS_LEN + 653 stats.freq = zd_channels[stats.channel - 1].freq;
1090 + sizeof(struct rx_status)); 654 stats.phymode = MODE_IEEE80211G;
1091 /* FIXME: 802.11a */ 655 stats.ssi = status->signal_strength;
1092 stats->freq = IEEE80211_24GHZ_BAND; 656 stats.signal = zd_rx_qual_percent(buffer,
1093 stats->received_channel = _zd_chip_get_channel(&mac->chip);
1094 stats->rssi = zd_rx_strength_percent(status->signal_strength);
1095 stats->signal = zd_rx_qual_percent(buffer,
1096 length - sizeof(struct rx_status), 657 length - sizeof(struct rx_status),
1097 status); 658 status);
1098 stats->mask = IEEE80211_STATMASK_RSSI | IEEE80211_STATMASK_SIGNAL; 659 stats.rate = zd_rx_rate(buffer, status);
1099 stats->rate = zd_rx_rate(buffer, status); 660
1100 if (stats->rate) 661 length -= ZD_PLCP_HEADER_SIZE + sizeof(struct rx_status);
1101 stats->mask |= IEEE80211_STATMASK_RATE; 662 buffer += ZD_PLCP_HEADER_SIZE;
663
664 /* Except for bad frames, filter each frame to see if it is an ACK, in
665 * which case our internal TX tracking is updated. Normally we then
666 * bail here as there's no need to pass ACKs on up to the stack, but
667 * there is also the case where the stack has requested us to pass
668 * control frames on up (pass_ctrl) which we must consider. */
669 if (!bad_frame &&
670 filter_ack(hw, (struct ieee80211_hdr *)buffer, &stats)
671 && !mac->pass_ctrl)
672 return 0;
1102 673
674 skb = dev_alloc_skb(length);
675 if (skb == NULL)
676 return -ENOMEM;
677 memcpy(skb_put(skb, length), buffer, length);
678
679 ieee80211_rx_irqsafe(hw, skb, &stats);
1103 return 0; 680 return 0;
1104} 681}
1105 682
1106static void zd_mac_rx(struct zd_mac *mac, struct sk_buff *skb) 683static int zd_op_add_interface(struct ieee80211_hw *hw,
684 struct ieee80211_if_init_conf *conf)
1107{ 685{
1108 int r; 686 struct zd_mac *mac = zd_hw_mac(hw);
1109 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
1110 struct ieee80211_rx_stats stats;
1111 const struct rx_status *status;
1112 687
1113 if (skb->len < ZD_PLCP_HEADER_SIZE + IEEE80211_1ADDR_LEN + 688 /* using IEEE80211_IF_TYPE_INVALID to indicate no mode selected */
1114 IEEE80211_FCS_LEN + sizeof(struct rx_status)) 689 if (mac->type != IEEE80211_IF_TYPE_INVALID)
1115 { 690 return -EOPNOTSUPP;
1116 ieee->stats.rx_errors++;
1117 ieee->stats.rx_length_errors++;
1118 goto free_skb;
1119 }
1120 691
1121 r = fill_rx_stats(&stats, &status, mac, skb->data, skb->len); 692 switch (conf->type) {
1122 if (r) { 693 case IEEE80211_IF_TYPE_MNTR:
1123 /* Only packets with rx errors are included here. 694 case IEEE80211_IF_TYPE_STA:
1124 * The error stats have already been set in fill_rx_stats. 695 mac->type = conf->type;
1125 */ 696 break;
1126 goto free_skb; 697 default:
698 return -EOPNOTSUPP;
1127 } 699 }
1128 700
1129 __skb_pull(skb, ZD_PLCP_HEADER_SIZE); 701 return zd_write_mac_addr(&mac->chip, conf->mac_addr);
1130 __skb_trim(skb, skb->len - 702}
1131 (IEEE80211_FCS_LEN + sizeof(struct rx_status)));
1132 703
1133 ZD_ASSERT(IS_ALIGNED((unsigned long)skb->data, 4)); 704static void zd_op_remove_interface(struct ieee80211_hw *hw,
705 struct ieee80211_if_init_conf *conf)
706{
707 struct zd_mac *mac = zd_hw_mac(hw);
708 mac->type = IEEE80211_IF_TYPE_INVALID;
709 zd_write_mac_addr(&mac->chip, NULL);
710}
1134 711
1135 update_qual_rssi(mac, skb->data, skb->len, stats.signal, 712static int zd_op_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf)
1136 status->signal_strength); 713{
714 struct zd_mac *mac = zd_hw_mac(hw);
715 return zd_chip_set_channel(&mac->chip, conf->channel);
716}
1137 717
1138 r = filter_rx(ieee, skb->data, skb->len, &stats); 718static int zd_op_config_interface(struct ieee80211_hw *hw, int if_id,
1139 if (r <= 0) { 719 struct ieee80211_if_conf *conf)
1140 if (r < 0) { 720{
1141 ieee->stats.rx_errors++; 721 struct zd_mac *mac = zd_hw_mac(hw);
1142 dev_dbg_f(zd_mac_dev(mac), "Error in packet.\n");
1143 }
1144 goto free_skb;
1145 }
1146 722
1147 if (ieee->iw_mode == IW_MODE_MONITOR) 723 spin_lock_irq(&mac->lock);
1148 fill_rt_header(skb_push(skb, sizeof(struct zd_rt_hdr)), mac, 724 mac->associated = is_valid_ether_addr(conf->bssid);
1149 &stats, status); 725 spin_unlock_irq(&mac->lock);
1150 726
1151 r = ieee80211_rx(ieee, skb, &stats); 727 /* TODO: do hardware bssid filtering */
1152 if (r) 728 return 0;
1153 return;
1154free_skb:
1155 /* We are always in a soft irq. */
1156 dev_kfree_skb(skb);
1157} 729}
1158 730
1159static void do_rx(unsigned long mac_ptr) 731static void set_multicast_hash_handler(struct work_struct *work)
1160{ 732{
1161 struct zd_mac *mac = (struct zd_mac *)mac_ptr; 733 struct zd_mac *mac =
1162 struct sk_buff *skb; 734 container_of(work, struct zd_mac, set_multicast_hash_work);
735 struct zd_mc_hash hash;
1163 736
1164 while ((skb = skb_dequeue(&mac->rx_queue)) != NULL) 737 spin_lock_irq(&mac->lock);
1165 zd_mac_rx(mac, skb); 738 hash = mac->multicast_hash;
1166} 739 spin_unlock_irq(&mac->lock);
1167 740
1168int zd_mac_rx_irq(struct zd_mac *mac, const u8 *buffer, unsigned int length) 741 zd_chip_set_multicast_hash(&mac->chip, &hash);
1169{
1170 struct sk_buff *skb;
1171 unsigned int reserved =
1172 ALIGN(max_t(unsigned int,
1173 sizeof(struct zd_rt_hdr), ZD_PLCP_HEADER_SIZE), 4) -
1174 ZD_PLCP_HEADER_SIZE;
1175
1176 skb = dev_alloc_skb(reserved + length);
1177 if (!skb) {
1178 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
1179 dev_warn(zd_mac_dev(mac), "Could not allocate skb.\n");
1180 ieee->stats.rx_dropped++;
1181 return -ENOMEM;
1182 }
1183 skb_reserve(skb, reserved);
1184 memcpy(__skb_put(skb, length), buffer, length);
1185 skb_queue_tail(&mac->rx_queue, skb);
1186 tasklet_schedule(&mac->rx_tasklet);
1187 return 0;
1188} 742}
1189 743
1190static int netdev_tx(struct ieee80211_txb *txb, struct net_device *netdev, 744static void set_rx_filter_handler(struct work_struct *work)
1191 int pri)
1192{ 745{
1193 return zd_mac_tx(zd_netdev_mac(netdev), txb, pri); 746 struct zd_mac *mac =
747 container_of(work, struct zd_mac, set_rx_filter_work);
748 int r;
749
750 dev_dbg_f(zd_mac_dev(mac), "\n");
751 r = set_rx_filter(mac);
752 if (r)
753 dev_err(zd_mac_dev(mac), "set_rx_filter_handler error %d\n", r);
1194} 754}
1195 755
1196static void set_security(struct net_device *netdev, 756#define SUPPORTED_FIF_FLAGS \
1197 struct ieee80211_security *sec) 757 (FIF_PROMISC_IN_BSS | FIF_ALLMULTI | FIF_FCSFAIL | FIF_CONTROL | \
758 FIF_OTHER_BSS)
759static void zd_op_configure_filter(struct ieee80211_hw *hw,
760 unsigned int changed_flags,
761 unsigned int *new_flags,
762 int mc_count, struct dev_mc_list *mclist)
1198{ 763{
1199 struct ieee80211_device *ieee = zd_netdev_ieee80211(netdev); 764 struct zd_mc_hash hash;
1200 struct ieee80211_security *secinfo = &ieee->sec; 765 struct zd_mac *mac = zd_hw_mac(hw);
1201 int keyidx; 766 unsigned long flags;
1202 767 int i;
1203 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)), "\n");
1204
1205 for (keyidx = 0; keyidx<WEP_KEYS; keyidx++)
1206 if (sec->flags & (1<<keyidx)) {
1207 secinfo->encode_alg[keyidx] = sec->encode_alg[keyidx];
1208 secinfo->key_sizes[keyidx] = sec->key_sizes[keyidx];
1209 memcpy(secinfo->keys[keyidx], sec->keys[keyidx],
1210 SCM_KEY_LEN);
1211 }
1212 768
1213 if (sec->flags & SEC_ACTIVE_KEY) { 769 /* Only deal with supported flags */
1214 secinfo->active_key = sec->active_key; 770 changed_flags &= SUPPORTED_FIF_FLAGS;
1215 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)), 771 *new_flags &= SUPPORTED_FIF_FLAGS;
1216 " .active_key = %d\n", sec->active_key); 772
1217 } 773 /* changed_flags is always populated but this driver
1218 if (sec->flags & SEC_UNICAST_GROUP) { 774 * doesn't support all FIF flags so its possible we don't
1219 secinfo->unicast_uses_group = sec->unicast_uses_group; 775 * need to do anything */
1220 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)), 776 if (!changed_flags)
1221 " .unicast_uses_group = %d\n", 777 return;
1222 sec->unicast_uses_group); 778
1223 } 779 if (*new_flags & (FIF_PROMISC_IN_BSS | FIF_ALLMULTI)) {
1224 if (sec->flags & SEC_LEVEL) { 780 zd_mc_add_all(&hash);
1225 secinfo->level = sec->level; 781 } else {
1226 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)), 782 DECLARE_MAC_BUF(macbuf);
1227 " .level = %d\n", sec->level); 783
1228 } 784 zd_mc_clear(&hash);
1229 if (sec->flags & SEC_ENABLED) { 785 for (i = 0; i < mc_count; i++) {
1230 secinfo->enabled = sec->enabled; 786 if (!mclist)
1231 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)), 787 break;
1232 " .enabled = %d\n", sec->enabled); 788 dev_dbg_f(zd_mac_dev(mac), "mc addr %s\n",
1233 } 789 print_mac(macbuf, mclist->dmi_addr));
1234 if (sec->flags & SEC_ENCRYPT) { 790 zd_mc_add_addr(&hash, mclist->dmi_addr);
1235 secinfo->encrypt = sec->encrypt; 791 mclist = mclist->next;
1236 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)), 792 }
1237 " .encrypt = %d\n", sec->encrypt);
1238 }
1239 if (sec->flags & SEC_AUTH_MODE) {
1240 secinfo->auth_mode = sec->auth_mode;
1241 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)),
1242 " .auth_mode = %d\n", sec->auth_mode);
1243 } 793 }
794
795 spin_lock_irqsave(&mac->lock, flags);
796 mac->pass_failed_fcs = !!(*new_flags & FIF_FCSFAIL);
797 mac->pass_ctrl = !!(*new_flags & FIF_CONTROL);
798 mac->multicast_hash = hash;
799 spin_unlock_irqrestore(&mac->lock, flags);
800 queue_work(zd_workqueue, &mac->set_multicast_hash_work);
801
802 if (changed_flags & FIF_CONTROL)
803 queue_work(zd_workqueue, &mac->set_rx_filter_work);
804
805 /* no handling required for FIF_OTHER_BSS as we don't currently
806 * do BSSID filtering */
807 /* FIXME: in future it would be nice to enable the probe response
808 * filter (so that the driver doesn't see them) until
809 * FIF_BCN_PRBRESP_PROMISC is set. however due to atomicity here, we'd
810 * have to schedule work to enable prbresp reception, which might
811 * happen too late. For now we'll just listen and forward them all the
812 * time. */
1244} 813}
1245 814
1246static void ieee_init(struct ieee80211_device *ieee) 815static void set_rts_cts_work(struct work_struct *work)
1247{ 816{
1248 ieee->mode = IEEE_B | IEEE_G; 817 struct zd_mac *mac =
1249 ieee->freq_band = IEEE80211_24GHZ_BAND; 818 container_of(work, struct zd_mac, set_rts_cts_work);
1250 ieee->modulation = IEEE80211_OFDM_MODULATION | IEEE80211_CCK_MODULATION; 819 unsigned long flags;
1251 ieee->tx_headroom = sizeof(struct zd_ctrlset); 820 unsigned int short_preamble;
1252 ieee->set_security = set_security; 821
1253 ieee->hard_start_xmit = netdev_tx; 822 mutex_lock(&mac->chip.mutex);
1254 823
1255 /* Software encryption/decryption for now */ 824 spin_lock_irqsave(&mac->lock, flags);
1256 ieee->host_build_iv = 0; 825 mac->updating_rts_rate = 0;
1257 ieee->host_encrypt = 1; 826 short_preamble = mac->short_preamble;
1258 ieee->host_decrypt = 1; 827 spin_unlock_irqrestore(&mac->lock, flags);
1259 828
1260 /* FIXME: default to managed mode, until ieee80211 and zd1211rw can 829 zd_chip_set_rts_cts_rate_locked(&mac->chip, short_preamble);
1261 * correctly support AUTO */ 830 mutex_unlock(&mac->chip.mutex);
1262 ieee->iw_mode = IW_MODE_INFRA;
1263} 831}
1264 832
1265static void softmac_init(struct ieee80211softmac_device *sm) 833static void zd_op_erp_ie_changed(struct ieee80211_hw *hw, u8 changes,
834 int cts_protection, int preamble)
1266{ 835{
1267 sm->set_channel = set_channel; 836 struct zd_mac *mac = zd_hw_mac(hw);
1268 sm->bssinfo_change = bssinfo_change; 837 unsigned long flags;
838
839 dev_dbg_f(zd_mac_dev(mac), "changes: %x\n", changes);
840
841 if (changes & IEEE80211_ERP_CHANGE_PREAMBLE) {
842 spin_lock_irqsave(&mac->lock, flags);
843 mac->short_preamble = !preamble;
844 if (!mac->updating_rts_rate) {
845 mac->updating_rts_rate = 1;
846 /* FIXME: should disable TX here, until work has
847 * completed and RTS_CTS reg is updated */
848 queue_work(zd_workqueue, &mac->set_rts_cts_work);
849 }
850 spin_unlock_irqrestore(&mac->lock, flags);
851 }
1269} 852}
1270 853
1271struct iw_statistics *zd_mac_get_wireless_stats(struct net_device *ndev) 854static const struct ieee80211_ops zd_ops = {
855 .tx = zd_op_tx,
856 .start = zd_op_start,
857 .stop = zd_op_stop,
858 .add_interface = zd_op_add_interface,
859 .remove_interface = zd_op_remove_interface,
860 .config = zd_op_config,
861 .config_interface = zd_op_config_interface,
862 .configure_filter = zd_op_configure_filter,
863 .erp_ie_changed = zd_op_erp_ie_changed,
864};
865
866struct ieee80211_hw *zd_mac_alloc_hw(struct usb_interface *intf)
1272{ 867{
1273 struct zd_mac *mac = zd_netdev_mac(ndev); 868 struct zd_mac *mac;
1274 struct iw_statistics *iw_stats = &mac->iw_stats; 869 struct ieee80211_hw *hw;
1275 unsigned int i, count, qual_total, rssi_total; 870 int i;
1276 871
1277 memset(iw_stats, 0, sizeof(struct iw_statistics)); 872 hw = ieee80211_alloc_hw(sizeof(struct zd_mac), &zd_ops);
1278 /* We are not setting the status, because ieee->state is not updated 873 if (!hw) {
1279 * at all and this driver doesn't track authentication state. 874 dev_dbg_f(&intf->dev, "out of memory\n");
1280 */ 875 return NULL;
1281 spin_lock_irq(&mac->lock);
1282 count = mac->stats_count < ZD_MAC_STATS_BUFFER_SIZE ?
1283 mac->stats_count : ZD_MAC_STATS_BUFFER_SIZE;
1284 qual_total = rssi_total = 0;
1285 for (i = 0; i < count; i++) {
1286 qual_total += mac->qual_buffer[i];
1287 rssi_total += mac->rssi_buffer[i];
1288 } 876 }
1289 spin_unlock_irq(&mac->lock); 877
1290 iw_stats->qual.updated = IW_QUAL_NOISE_INVALID; 878 mac = zd_hw_mac(hw);
1291 if (count > 0) { 879
1292 iw_stats->qual.qual = qual_total / count; 880 memset(mac, 0, sizeof(*mac));
1293 iw_stats->qual.level = rssi_total / count; 881 spin_lock_init(&mac->lock);
1294 iw_stats->qual.updated |= 882 mac->hw = hw;
1295 IW_QUAL_QUAL_UPDATED|IW_QUAL_LEVEL_UPDATED; 883
1296 } else { 884 mac->type = IEEE80211_IF_TYPE_INVALID;
1297 iw_stats->qual.updated |= 885
1298 IW_QUAL_QUAL_INVALID|IW_QUAL_LEVEL_INVALID; 886 memcpy(mac->channels, zd_channels, sizeof(zd_channels));
887 memcpy(mac->rates, zd_rates, sizeof(zd_rates));
888 mac->modes[0].mode = MODE_IEEE80211G;
889 mac->modes[0].num_rates = ARRAY_SIZE(zd_rates);
890 mac->modes[0].rates = mac->rates;
891 mac->modes[0].num_channels = ARRAY_SIZE(zd_channels);
892 mac->modes[0].channels = mac->channels;
893 mac->modes[1].mode = MODE_IEEE80211B;
894 mac->modes[1].num_rates = 4;
895 mac->modes[1].rates = mac->rates;
896 mac->modes[1].num_channels = ARRAY_SIZE(zd_channels);
897 mac->modes[1].channels = mac->channels;
898
899 hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
900 IEEE80211_HW_DEFAULT_REG_DOMAIN_CONFIGURED;
901 hw->max_rssi = 100;
902 hw->max_signal = 100;
903
904 hw->queues = 1;
905 hw->extra_tx_headroom = sizeof(struct zd_ctrlset);
906
907 skb_queue_head_init(&mac->ack_wait_queue);
908
909 for (i = 0; i < 2; i++) {
910 if (ieee80211_register_hwmode(hw, &mac->modes[i])) {
911 dev_dbg_f(&intf->dev, "cannot register hwmode\n");
912 ieee80211_free_hw(hw);
913 return NULL;
914 }
1299 } 915 }
1300 /* TODO: update counter */ 916
1301 return iw_stats; 917 zd_chip_init(&mac->chip, hw, intf);
918 housekeeping_init(mac);
919 INIT_WORK(&mac->set_multicast_hash_work, set_multicast_hash_handler);
920 INIT_WORK(&mac->set_rts_cts_work, set_rts_cts_work);
921 INIT_WORK(&mac->set_rx_filter_work, set_rx_filter_handler);
922
923 SET_IEEE80211_DEV(hw, &intf->dev);
924 return hw;
1302} 925}
1303 926
1304#define LINK_LED_WORK_DELAY HZ 927#define LINK_LED_WORK_DELAY HZ
@@ -1308,18 +931,17 @@ static void link_led_handler(struct work_struct *work)
1308 struct zd_mac *mac = 931 struct zd_mac *mac =
1309 container_of(work, struct zd_mac, housekeeping.link_led_work.work); 932 container_of(work, struct zd_mac, housekeeping.link_led_work.work);
1310 struct zd_chip *chip = &mac->chip; 933 struct zd_chip *chip = &mac->chip;
1311 struct ieee80211softmac_device *sm = ieee80211_priv(mac->netdev);
1312 int is_associated; 934 int is_associated;
1313 int r; 935 int r;
1314 936
1315 spin_lock_irq(&mac->lock); 937 spin_lock_irq(&mac->lock);
1316 is_associated = sm->associnfo.associated != 0; 938 is_associated = mac->associated;
1317 spin_unlock_irq(&mac->lock); 939 spin_unlock_irq(&mac->lock);
1318 940
1319 r = zd_chip_control_leds(chip, 941 r = zd_chip_control_leds(chip,
1320 is_associated ? LED_ASSOCIATED : LED_SCANNING); 942 is_associated ? LED_ASSOCIATED : LED_SCANNING);
1321 if (r) 943 if (r)
1322 dev_err(zd_mac_dev(mac), "zd_chip_control_leds error %d\n", r); 944 dev_dbg_f(zd_mac_dev(mac), "zd_chip_control_leds error %d\n", r);
1323 945
1324 queue_delayed_work(zd_workqueue, &mac->housekeeping.link_led_work, 946 queue_delayed_work(zd_workqueue, &mac->housekeeping.link_led_work,
1325 LINK_LED_WORK_DELAY); 947 LINK_LED_WORK_DELAY);
diff --git a/drivers/net/wireless/zd1211rw/zd_mac.h b/drivers/net/wireless/zd1211rw/zd_mac.h
index 1b15bde3ff60..ed5417ca2d10 100644
--- a/drivers/net/wireless/zd1211rw/zd_mac.h
+++ b/drivers/net/wireless/zd1211rw/zd_mac.h
@@ -18,14 +18,11 @@
18#ifndef _ZD_MAC_H 18#ifndef _ZD_MAC_H
19#define _ZD_MAC_H 19#define _ZD_MAC_H
20 20
21#include <linux/wireless.h>
22#include <linux/kernel.h> 21#include <linux/kernel.h>
23#include <linux/workqueue.h> 22#include <net/mac80211.h>
24#include <net/ieee80211.h>
25#include <net/ieee80211softmac.h>
26 23
27#include "zd_chip.h" 24#include "zd_chip.h"
28#include "zd_netdev.h" 25#include "zd_ieee80211.h"
29 26
30struct zd_ctrlset { 27struct zd_ctrlset {
31 u8 modulation; 28 u8 modulation;
@@ -57,7 +54,7 @@ struct zd_ctrlset {
57/* The two possible modulation types. Notify that 802.11b doesn't use the CCK 54/* The two possible modulation types. Notify that 802.11b doesn't use the CCK
58 * codeing for the 1 and 2 MBit/s rate. We stay with the term here to remain 55 * codeing for the 1 and 2 MBit/s rate. We stay with the term here to remain
59 * consistent with uses the term at other places. 56 * consistent with uses the term at other places.
60 */ 57 */
61#define ZD_CCK 0x00 58#define ZD_CCK 0x00
62#define ZD_OFDM 0x10 59#define ZD_OFDM 0x10
63 60
@@ -141,58 +138,68 @@ struct rx_status {
141#define ZD_RX_CRC16_ERROR 0x40 138#define ZD_RX_CRC16_ERROR 0x40
142#define ZD_RX_ERROR 0x80 139#define ZD_RX_ERROR 0x80
143 140
141enum mac_flags {
142 MAC_FIXED_CHANNEL = 0x01,
143};
144
144struct housekeeping { 145struct housekeeping {
145 struct delayed_work link_led_work; 146 struct delayed_work link_led_work;
146}; 147};
147 148
149/**
150 * struct zd_tx_skb_control_block - control block for tx skbuffs
151 * @control: &struct ieee80211_tx_control pointer
152 * @context: context pointer
153 *
154 * This structure is used to fill the cb field in an &sk_buff to transmit.
155 * The control field is NULL, if there is no requirement from the mac80211
156 * stack to report about the packet ACK. This is the case if the flag
157 * IEEE80211_TXCTL_NO_ACK is not set in &struct ieee80211_tx_control.
158 */
159struct zd_tx_skb_control_block {
160 struct ieee80211_tx_control *control;
161 struct ieee80211_hw *hw;
162 void *context;
163};
164
148#define ZD_MAC_STATS_BUFFER_SIZE 16 165#define ZD_MAC_STATS_BUFFER_SIZE 16
149 166
167#define ZD_MAC_MAX_ACK_WAITERS 10
168
150struct zd_mac { 169struct zd_mac {
151 struct zd_chip chip; 170 struct zd_chip chip;
152 spinlock_t lock; 171 spinlock_t lock;
153 struct net_device *netdev; 172 struct ieee80211_hw *hw;
154
155 /* Unlocked reading possible */
156 struct iw_statistics iw_stats;
157
158 struct housekeeping housekeeping; 173 struct housekeeping housekeeping;
159 struct work_struct set_multicast_hash_work; 174 struct work_struct set_multicast_hash_work;
175 struct work_struct set_rts_cts_work;
176 struct work_struct set_rx_filter_work;
160 struct zd_mc_hash multicast_hash; 177 struct zd_mc_hash multicast_hash;
161 struct delayed_work set_rts_cts_work;
162 struct delayed_work set_basic_rates_work;
163
164 struct tasklet_struct rx_tasklet;
165 struct sk_buff_head rx_queue;
166
167 unsigned int stats_count;
168 u8 qual_buffer[ZD_MAC_STATS_BUFFER_SIZE];
169 u8 rssi_buffer[ZD_MAC_STATS_BUFFER_SIZE];
170 u8 regdomain; 178 u8 regdomain;
171 u8 default_regdomain; 179 u8 default_regdomain;
172 u8 requested_channel; 180 int type;
173 181 int associated;
174 /* A bitpattern of cr_rates */ 182 struct sk_buff_head ack_wait_queue;
175 u16 basic_rates; 183 struct ieee80211_channel channels[14];
176 184 struct ieee80211_rate rates[12];
177 /* A zd_rate */ 185 struct ieee80211_hw_mode modes[2];
178 u8 rts_rate;
179 186
180 /* Short preamble (used for RTS/CTS) */ 187 /* Short preamble (used for RTS/CTS) */
181 unsigned int short_preamble:1; 188 unsigned int short_preamble:1;
182 189
183 /* flags to indicate update in progress */ 190 /* flags to indicate update in progress */
184 unsigned int updating_rts_rate:1; 191 unsigned int updating_rts_rate:1;
185 unsigned int updating_basic_rates:1;
186};
187 192
188static inline struct ieee80211_device *zd_mac_to_ieee80211(struct zd_mac *mac) 193 /* whether to pass frames with CRC errors to stack */
189{ 194 unsigned int pass_failed_fcs:1;
190 return zd_netdev_ieee80211(mac->netdev);
191}
192 195
193static inline struct zd_mac *zd_netdev_mac(struct net_device *netdev) 196 /* whether to pass control frames to stack */
197 unsigned int pass_ctrl:1;
198};
199
200static inline struct zd_mac *zd_hw_mac(struct ieee80211_hw *hw)
194{ 201{
195 return ieee80211softmac_priv(netdev); 202 return hw->priv;
196} 203}
197 204
198static inline struct zd_mac *zd_chip_to_mac(struct zd_chip *chip) 205static inline struct zd_mac *zd_chip_to_mac(struct zd_chip *chip)
@@ -205,35 +212,22 @@ static inline struct zd_mac *zd_usb_to_mac(struct zd_usb *usb)
205 return zd_chip_to_mac(zd_usb_to_chip(usb)); 212 return zd_chip_to_mac(zd_usb_to_chip(usb));
206} 213}
207 214
215static inline u8 *zd_mac_get_perm_addr(struct zd_mac *mac)
216{
217 return mac->hw->wiphy->perm_addr;
218}
219
208#define zd_mac_dev(mac) (zd_chip_dev(&(mac)->chip)) 220#define zd_mac_dev(mac) (zd_chip_dev(&(mac)->chip))
209 221
210int zd_mac_init(struct zd_mac *mac, 222struct ieee80211_hw *zd_mac_alloc_hw(struct usb_interface *intf);
211 struct net_device *netdev,
212 struct usb_interface *intf);
213void zd_mac_clear(struct zd_mac *mac); 223void zd_mac_clear(struct zd_mac *mac);
214 224
215int zd_mac_preinit_hw(struct zd_mac *mac); 225int zd_mac_preinit_hw(struct ieee80211_hw *hw);
216int zd_mac_init_hw(struct zd_mac *mac); 226int zd_mac_init_hw(struct ieee80211_hw *hw);
217
218int zd_mac_open(struct net_device *netdev);
219int zd_mac_stop(struct net_device *netdev);
220int zd_mac_set_mac_address(struct net_device *dev, void *p);
221void zd_mac_set_multicast_list(struct net_device *netdev);
222
223int zd_mac_rx_irq(struct zd_mac *mac, const u8 *buffer, unsigned int length);
224
225int zd_mac_set_regdomain(struct zd_mac *zd_mac, u8 regdomain);
226u8 zd_mac_get_regdomain(struct zd_mac *zd_mac);
227
228int zd_mac_request_channel(struct zd_mac *mac, u8 channel);
229u8 zd_mac_get_channel(struct zd_mac *mac);
230
231int zd_mac_set_mode(struct zd_mac *mac, u32 mode);
232int zd_mac_get_mode(struct zd_mac *mac, u32 *mode);
233
234int zd_mac_get_range(struct zd_mac *mac, struct iw_range *range);
235 227
236struct iw_statistics *zd_mac_get_wireless_stats(struct net_device *ndev); 228int zd_mac_rx(struct ieee80211_hw *hw, const u8 *buffer, unsigned int length);
229void zd_mac_tx_failed(struct ieee80211_hw *hw);
230void zd_mac_tx_to_dev(struct sk_buff *skb, int error);
237 231
238#ifdef DEBUG 232#ifdef DEBUG
239void zd_dump_rx_status(const struct rx_status *status); 233void zd_dump_rx_status(const struct rx_status *status);
diff --git a/drivers/net/wireless/zd1211rw/zd_netdev.c b/drivers/net/wireless/zd1211rw/zd_netdev.c
deleted file mode 100644
index 047cab3d87df..000000000000
--- a/drivers/net/wireless/zd1211rw/zd_netdev.c
+++ /dev/null
@@ -1,264 +0,0 @@
1/* zd_netdev.c
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 */
17
18#include <linux/netdevice.h>
19#include <linux/etherdevice.h>
20#include <linux/skbuff.h>
21#include <net/ieee80211.h>
22#include <net/ieee80211softmac.h>
23#include <net/ieee80211softmac_wx.h>
24#include <net/iw_handler.h>
25
26#include "zd_def.h"
27#include "zd_netdev.h"
28#include "zd_mac.h"
29#include "zd_ieee80211.h"
30
31/* Region 0 means reset regdomain to default. */
32static int zd_set_regdomain(struct net_device *netdev,
33 struct iw_request_info *info,
34 union iwreq_data *req, char *extra)
35{
36 const u8 *regdomain = (u8 *)req;
37 return zd_mac_set_regdomain(zd_netdev_mac(netdev), *regdomain);
38}
39
40static int zd_get_regdomain(struct net_device *netdev,
41 struct iw_request_info *info,
42 union iwreq_data *req, char *extra)
43{
44 u8 *regdomain = (u8 *)req;
45 if (!regdomain)
46 return -EINVAL;
47 *regdomain = zd_mac_get_regdomain(zd_netdev_mac(netdev));
48 return 0;
49}
50
51static const struct iw_priv_args zd_priv_args[] = {
52 {
53 .cmd = ZD_PRIV_SET_REGDOMAIN,
54 .set_args = IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
55 .name = "set_regdomain",
56 },
57 {
58 .cmd = ZD_PRIV_GET_REGDOMAIN,
59 .get_args = IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
60 .name = "get_regdomain",
61 },
62};
63
64#define PRIV_OFFSET(x) [(x)-SIOCIWFIRSTPRIV]
65
66static const iw_handler zd_priv_handler[] = {
67 PRIV_OFFSET(ZD_PRIV_SET_REGDOMAIN) = zd_set_regdomain,
68 PRIV_OFFSET(ZD_PRIV_GET_REGDOMAIN) = zd_get_regdomain,
69};
70
71static int iw_get_name(struct net_device *netdev,
72 struct iw_request_info *info,
73 union iwreq_data *req, char *extra)
74{
75 /* FIXME: check whether 802.11a will also supported */
76 strlcpy(req->name, "IEEE 802.11b/g", IFNAMSIZ);
77 return 0;
78}
79
80static int iw_get_nick(struct net_device *netdev,
81 struct iw_request_info *info,
82 union iwreq_data *req, char *extra)
83{
84 strcpy(extra, "zd1211");
85 req->data.length = strlen(extra);
86 req->data.flags = 1;
87 return 0;
88}
89
90static int iw_set_freq(struct net_device *netdev,
91 struct iw_request_info *info,
92 union iwreq_data *req, char *extra)
93{
94 int r;
95 struct zd_mac *mac = zd_netdev_mac(netdev);
96 struct iw_freq *freq = &req->freq;
97 u8 channel;
98
99 r = zd_find_channel(&channel, freq);
100 if (r < 0)
101 return r;
102 r = zd_mac_request_channel(mac, channel);
103 return r;
104}
105
106static int iw_get_freq(struct net_device *netdev,
107 struct iw_request_info *info,
108 union iwreq_data *req, char *extra)
109{
110 struct zd_mac *mac = zd_netdev_mac(netdev);
111 struct iw_freq *freq = &req->freq;
112
113 return zd_channel_to_freq(freq, zd_mac_get_channel(mac));
114}
115
116static int iw_set_mode(struct net_device *netdev,
117 struct iw_request_info *info,
118 union iwreq_data *req, char *extra)
119{
120 return zd_mac_set_mode(zd_netdev_mac(netdev), req->mode);
121}
122
123static int iw_get_mode(struct net_device *netdev,
124 struct iw_request_info *info,
125 union iwreq_data *req, char *extra)
126{
127 return zd_mac_get_mode(zd_netdev_mac(netdev), &req->mode);
128}
129
130static int iw_get_range(struct net_device *netdev,
131 struct iw_request_info *info,
132 union iwreq_data *req, char *extra)
133{
134 struct iw_range *range = (struct iw_range *)extra;
135
136 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)), "\n");
137 req->data.length = sizeof(*range);
138 return zd_mac_get_range(zd_netdev_mac(netdev), range);
139}
140
141static int iw_set_encode(struct net_device *netdev,
142 struct iw_request_info *info,
143 union iwreq_data *data,
144 char *extra)
145{
146 return ieee80211_wx_set_encode(zd_netdev_ieee80211(netdev), info,
147 data, extra);
148}
149
150static int iw_get_encode(struct net_device *netdev,
151 struct iw_request_info *info,
152 union iwreq_data *data,
153 char *extra)
154{
155 return ieee80211_wx_get_encode(zd_netdev_ieee80211(netdev), info,
156 data, extra);
157}
158
159static int iw_set_encodeext(struct net_device *netdev,
160 struct iw_request_info *info,
161 union iwreq_data *data,
162 char *extra)
163{
164 return ieee80211_wx_set_encodeext(zd_netdev_ieee80211(netdev), info,
165 data, extra);
166}
167
168static int iw_get_encodeext(struct net_device *netdev,
169 struct iw_request_info *info,
170 union iwreq_data *data,
171 char *extra)
172{
173 return ieee80211_wx_get_encodeext(zd_netdev_ieee80211(netdev), info,
174 data, extra);
175}
176
177#define WX(x) [(x)-SIOCIWFIRST]
178
179static const iw_handler zd_standard_iw_handlers[] = {
180 WX(SIOCGIWNAME) = iw_get_name,
181 WX(SIOCGIWNICKN) = iw_get_nick,
182 WX(SIOCSIWFREQ) = iw_set_freq,
183 WX(SIOCGIWFREQ) = iw_get_freq,
184 WX(SIOCSIWMODE) = iw_set_mode,
185 WX(SIOCGIWMODE) = iw_get_mode,
186 WX(SIOCGIWRANGE) = iw_get_range,
187 WX(SIOCSIWENCODE) = iw_set_encode,
188 WX(SIOCGIWENCODE) = iw_get_encode,
189 WX(SIOCSIWENCODEEXT) = iw_set_encodeext,
190 WX(SIOCGIWENCODEEXT) = iw_get_encodeext,
191 WX(SIOCSIWAUTH) = ieee80211_wx_set_auth,
192 WX(SIOCGIWAUTH) = ieee80211_wx_get_auth,
193 WX(SIOCSIWSCAN) = ieee80211softmac_wx_trigger_scan,
194 WX(SIOCGIWSCAN) = ieee80211softmac_wx_get_scan_results,
195 WX(SIOCSIWESSID) = ieee80211softmac_wx_set_essid,
196 WX(SIOCGIWESSID) = ieee80211softmac_wx_get_essid,
197 WX(SIOCSIWAP) = ieee80211softmac_wx_set_wap,
198 WX(SIOCGIWAP) = ieee80211softmac_wx_get_wap,
199 WX(SIOCSIWRATE) = ieee80211softmac_wx_set_rate,
200 WX(SIOCGIWRATE) = ieee80211softmac_wx_get_rate,
201 WX(SIOCSIWGENIE) = ieee80211softmac_wx_set_genie,
202 WX(SIOCGIWGENIE) = ieee80211softmac_wx_get_genie,
203 WX(SIOCSIWMLME) = ieee80211softmac_wx_set_mlme,
204};
205
206static const struct iw_handler_def iw_handler_def = {
207 .standard = zd_standard_iw_handlers,
208 .num_standard = ARRAY_SIZE(zd_standard_iw_handlers),
209 .private = zd_priv_handler,
210 .num_private = ARRAY_SIZE(zd_priv_handler),
211 .private_args = zd_priv_args,
212 .num_private_args = ARRAY_SIZE(zd_priv_args),
213 .get_wireless_stats = zd_mac_get_wireless_stats,
214};
215
216struct net_device *zd_netdev_alloc(struct usb_interface *intf)
217{
218 int r;
219 struct net_device *netdev;
220 struct zd_mac *mac;
221
222 netdev = alloc_ieee80211softmac(sizeof(struct zd_mac));
223 if (!netdev) {
224 dev_dbg_f(&intf->dev, "out of memory\n");
225 return NULL;
226 }
227
228 mac = zd_netdev_mac(netdev);
229 r = zd_mac_init(mac, netdev, intf);
230 if (r) {
231 usb_set_intfdata(intf, NULL);
232 free_ieee80211(netdev);
233 return NULL;
234 }
235
236 SET_NETDEV_DEV(netdev, &intf->dev);
237
238 dev_dbg_f(&intf->dev, "netdev->flags %#06hx\n", netdev->flags);
239 dev_dbg_f(&intf->dev, "netdev->features %#010lx\n", netdev->features);
240
241 netdev->open = zd_mac_open;
242 netdev->stop = zd_mac_stop;
243 /* netdev->get_stats = */
244 netdev->set_multicast_list = zd_mac_set_multicast_list;
245 netdev->set_mac_address = zd_mac_set_mac_address;
246 netdev->wireless_handlers = &iw_handler_def;
247 /* netdev->ethtool_ops = */
248
249 return netdev;
250}
251
252void zd_netdev_free(struct net_device *netdev)
253{
254 if (!netdev)
255 return;
256
257 zd_mac_clear(zd_netdev_mac(netdev));
258 free_ieee80211(netdev);
259}
260
261void zd_netdev_disconnect(struct net_device *netdev)
262{
263 unregister_netdev(netdev);
264}
diff --git a/drivers/net/wireless/zd1211rw/zd_netdev.h b/drivers/net/wireless/zd1211rw/zd_netdev.h
deleted file mode 100644
index 374a957073c1..000000000000
--- a/drivers/net/wireless/zd1211rw/zd_netdev.h
+++ /dev/null
@@ -1,45 +0,0 @@
1/* zd_netdev.h: Header for net device related functions.
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 */
17
18#ifndef _ZD_NETDEV_H
19#define _ZD_NETDEV_H
20
21#include <linux/usb.h>
22#include <linux/netdevice.h>
23#include <net/ieee80211.h>
24
25#define ZD_PRIV_SET_REGDOMAIN (SIOCIWFIRSTPRIV)
26#define ZD_PRIV_GET_REGDOMAIN (SIOCIWFIRSTPRIV+1)
27
28static inline struct ieee80211_device *zd_netdev_ieee80211(
29 struct net_device *ndev)
30{
31 return netdev_priv(ndev);
32}
33
34static inline struct net_device *zd_ieee80211_to_netdev(
35 struct ieee80211_device *ieee)
36{
37 return ieee->dev;
38}
39
40struct net_device *zd_netdev_alloc(struct usb_interface *intf);
41void zd_netdev_free(struct net_device *netdev);
42
43void zd_netdev_disconnect(struct net_device *netdev);
44
45#endif /* _ZD_NETDEV_H */
diff --git a/drivers/net/wireless/zd1211rw/zd_usb.c b/drivers/net/wireless/zd1211rw/zd_usb.c
index c755b6923812..3429576a95f7 100644
--- a/drivers/net/wireless/zd1211rw/zd_usb.c
+++ b/drivers/net/wireless/zd1211rw/zd_usb.c
@@ -17,18 +17,16 @@
17 17
18#include <linux/kernel.h> 18#include <linux/kernel.h>
19#include <linux/init.h> 19#include <linux/init.h>
20#include <linux/module.h>
21#include <linux/firmware.h> 20#include <linux/firmware.h>
22#include <linux/device.h> 21#include <linux/device.h>
23#include <linux/errno.h> 22#include <linux/errno.h>
24#include <linux/skbuff.h> 23#include <linux/skbuff.h>
25#include <linux/usb.h> 24#include <linux/usb.h>
26#include <linux/workqueue.h> 25#include <linux/workqueue.h>
27#include <net/ieee80211.h> 26#include <net/mac80211.h>
28#include <asm/unaligned.h> 27#include <asm/unaligned.h>
29 28
30#include "zd_def.h" 29#include "zd_def.h"
31#include "zd_netdev.h"
32#include "zd_mac.h" 30#include "zd_mac.h"
33#include "zd_usb.h" 31#include "zd_usb.h"
34 32
@@ -353,18 +351,6 @@ out:
353 spin_unlock(&intr->lock); 351 spin_unlock(&intr->lock);
354} 352}
355 353
356static inline void handle_retry_failed_int(struct urb *urb)
357{
358 struct zd_usb *usb = urb->context;
359 struct zd_mac *mac = zd_usb_to_mac(usb);
360 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
361
362 ieee->stats.tx_errors++;
363 ieee->ieee_stats.tx_retry_limit_exceeded++;
364 dev_dbg_f(urb_dev(urb), "retry failed interrupt\n");
365}
366
367
368static void int_urb_complete(struct urb *urb) 354static void int_urb_complete(struct urb *urb)
369{ 355{
370 int r; 356 int r;
@@ -400,7 +386,7 @@ static void int_urb_complete(struct urb *urb)
400 handle_regs_int(urb); 386 handle_regs_int(urb);
401 break; 387 break;
402 case USB_INT_ID_RETRY_FAILED: 388 case USB_INT_ID_RETRY_FAILED:
403 handle_retry_failed_int(urb); 389 zd_mac_tx_failed(zd_usb_to_hw(urb->context));
404 break; 390 break;
405 default: 391 default:
406 dev_dbg_f(urb_dev(urb), "error: urb %p unknown id %x\n", urb, 392 dev_dbg_f(urb_dev(urb), "error: urb %p unknown id %x\n", urb,
@@ -530,14 +516,10 @@ static void handle_rx_packet(struct zd_usb *usb, const u8 *buffer,
530 unsigned int length) 516 unsigned int length)
531{ 517{
532 int i; 518 int i;
533 struct zd_mac *mac = zd_usb_to_mac(usb);
534 const struct rx_length_info *length_info; 519 const struct rx_length_info *length_info;
535 520
536 if (length < sizeof(struct rx_length_info)) { 521 if (length < sizeof(struct rx_length_info)) {
537 /* It's not a complete packet anyhow. */ 522 /* It's not a complete packet anyhow. */
538 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
539 ieee->stats.rx_errors++;
540 ieee->stats.rx_length_errors++;
541 return; 523 return;
542 } 524 }
543 length_info = (struct rx_length_info *) 525 length_info = (struct rx_length_info *)
@@ -561,13 +543,13 @@ static void handle_rx_packet(struct zd_usb *usb, const u8 *buffer,
561 n = l+k; 543 n = l+k;
562 if (n > length) 544 if (n > length)
563 return; 545 return;
564 zd_mac_rx_irq(mac, buffer+l, k); 546 zd_mac_rx(zd_usb_to_hw(usb), buffer+l, k);
565 if (i >= 2) 547 if (i >= 2)
566 return; 548 return;
567 l = (n+3) & ~3; 549 l = (n+3) & ~3;
568 } 550 }
569 } else { 551 } else {
570 zd_mac_rx_irq(mac, buffer, length); 552 zd_mac_rx(zd_usb_to_hw(usb), buffer, length);
571 } 553 }
572} 554}
573 555
@@ -629,7 +611,7 @@ resubmit:
629 usb_submit_urb(urb, GFP_ATOMIC); 611 usb_submit_urb(urb, GFP_ATOMIC);
630} 612}
631 613
632static struct urb *alloc_urb(struct zd_usb *usb) 614static struct urb *alloc_rx_urb(struct zd_usb *usb)
633{ 615{
634 struct usb_device *udev = zd_usb_to_usbdev(usb); 616 struct usb_device *udev = zd_usb_to_usbdev(usb);
635 struct urb *urb; 617 struct urb *urb;
@@ -653,7 +635,7 @@ static struct urb *alloc_urb(struct zd_usb *usb)
653 return urb; 635 return urb;
654} 636}
655 637
656static void free_urb(struct urb *urb) 638static void free_rx_urb(struct urb *urb)
657{ 639{
658 if (!urb) 640 if (!urb)
659 return; 641 return;
@@ -671,11 +653,11 @@ int zd_usb_enable_rx(struct zd_usb *usb)
671 dev_dbg_f(zd_usb_dev(usb), "\n"); 653 dev_dbg_f(zd_usb_dev(usb), "\n");
672 654
673 r = -ENOMEM; 655 r = -ENOMEM;
674 urbs = kcalloc(URBS_COUNT, sizeof(struct urb *), GFP_KERNEL); 656 urbs = kcalloc(RX_URBS_COUNT, sizeof(struct urb *), GFP_KERNEL);
675 if (!urbs) 657 if (!urbs)
676 goto error; 658 goto error;
677 for (i = 0; i < URBS_COUNT; i++) { 659 for (i = 0; i < RX_URBS_COUNT; i++) {
678 urbs[i] = alloc_urb(usb); 660 urbs[i] = alloc_rx_urb(usb);
679 if (!urbs[i]) 661 if (!urbs[i])
680 goto error; 662 goto error;
681 } 663 }
@@ -688,10 +670,10 @@ int zd_usb_enable_rx(struct zd_usb *usb)
688 goto error; 670 goto error;
689 } 671 }
690 rx->urbs = urbs; 672 rx->urbs = urbs;
691 rx->urbs_count = URBS_COUNT; 673 rx->urbs_count = RX_URBS_COUNT;
692 spin_unlock_irq(&rx->lock); 674 spin_unlock_irq(&rx->lock);
693 675
694 for (i = 0; i < URBS_COUNT; i++) { 676 for (i = 0; i < RX_URBS_COUNT; i++) {
695 r = usb_submit_urb(urbs[i], GFP_KERNEL); 677 r = usb_submit_urb(urbs[i], GFP_KERNEL);
696 if (r) 678 if (r)
697 goto error_submit; 679 goto error_submit;
@@ -699,7 +681,7 @@ int zd_usb_enable_rx(struct zd_usb *usb)
699 681
700 return 0; 682 return 0;
701error_submit: 683error_submit:
702 for (i = 0; i < URBS_COUNT; i++) { 684 for (i = 0; i < RX_URBS_COUNT; i++) {
703 usb_kill_urb(urbs[i]); 685 usb_kill_urb(urbs[i]);
704 } 686 }
705 spin_lock_irq(&rx->lock); 687 spin_lock_irq(&rx->lock);
@@ -708,8 +690,8 @@ error_submit:
708 spin_unlock_irq(&rx->lock); 690 spin_unlock_irq(&rx->lock);
709error: 691error:
710 if (urbs) { 692 if (urbs) {
711 for (i = 0; i < URBS_COUNT; i++) 693 for (i = 0; i < RX_URBS_COUNT; i++)
712 free_urb(urbs[i]); 694 free_rx_urb(urbs[i]);
713 } 695 }
714 return r; 696 return r;
715} 697}
@@ -731,7 +713,7 @@ void zd_usb_disable_rx(struct zd_usb *usb)
731 713
732 for (i = 0; i < count; i++) { 714 for (i = 0; i < count; i++) {
733 usb_kill_urb(urbs[i]); 715 usb_kill_urb(urbs[i]);
734 free_urb(urbs[i]); 716 free_rx_urb(urbs[i]);
735 } 717 }
736 kfree(urbs); 718 kfree(urbs);
737 719
@@ -741,9 +723,142 @@ void zd_usb_disable_rx(struct zd_usb *usb)
741 spin_unlock_irqrestore(&rx->lock, flags); 723 spin_unlock_irqrestore(&rx->lock, flags);
742} 724}
743 725
726/**
727 * zd_usb_disable_tx - disable transmission
728 * @usb: the zd1211rw-private USB structure
729 *
730 * Frees all URBs in the free list and marks the transmission as disabled.
731 */
732void zd_usb_disable_tx(struct zd_usb *usb)
733{
734 struct zd_usb_tx *tx = &usb->tx;
735 unsigned long flags;
736 struct list_head *pos, *n;
737
738 spin_lock_irqsave(&tx->lock, flags);
739 list_for_each_safe(pos, n, &tx->free_urb_list) {
740 list_del(pos);
741 usb_free_urb(list_entry(pos, struct urb, urb_list));
742 }
743 tx->enabled = 0;
744 tx->submitted_urbs = 0;
745 /* The stopped state is ignored, relying on ieee80211_wake_queues()
746 * in a potentionally following zd_usb_enable_tx().
747 */
748 spin_unlock_irqrestore(&tx->lock, flags);
749}
750
751/**
752 * zd_usb_enable_tx - enables transmission
753 * @usb: a &struct zd_usb pointer
754 *
755 * This function enables transmission and prepares the &zd_usb_tx data
756 * structure.
757 */
758void zd_usb_enable_tx(struct zd_usb *usb)
759{
760 unsigned long flags;
761 struct zd_usb_tx *tx = &usb->tx;
762
763 spin_lock_irqsave(&tx->lock, flags);
764 tx->enabled = 1;
765 tx->submitted_urbs = 0;
766 ieee80211_wake_queues(zd_usb_to_hw(usb));
767 tx->stopped = 0;
768 spin_unlock_irqrestore(&tx->lock, flags);
769}
770
771/**
772 * alloc_tx_urb - provides an tx URB
773 * @usb: a &struct zd_usb pointer
774 *
775 * Allocates a new URB. If possible takes the urb from the free list in
776 * usb->tx.
777 */
778static struct urb *alloc_tx_urb(struct zd_usb *usb)
779{
780 struct zd_usb_tx *tx = &usb->tx;
781 unsigned long flags;
782 struct list_head *entry;
783 struct urb *urb;
784
785 spin_lock_irqsave(&tx->lock, flags);
786 if (list_empty(&tx->free_urb_list)) {
787 urb = usb_alloc_urb(0, GFP_ATOMIC);
788 goto out;
789 }
790 entry = tx->free_urb_list.next;
791 list_del(entry);
792 urb = list_entry(entry, struct urb, urb_list);
793out:
794 spin_unlock_irqrestore(&tx->lock, flags);
795 return urb;
796}
797
798/**
799 * free_tx_urb - frees a used tx URB
800 * @usb: a &struct zd_usb pointer
801 * @urb: URB to be freed
802 *
803 * Frees the the transmission URB, which means to put it on the free URB
804 * list.
805 */
806static void free_tx_urb(struct zd_usb *usb, struct urb *urb)
807{
808 struct zd_usb_tx *tx = &usb->tx;
809 unsigned long flags;
810
811 spin_lock_irqsave(&tx->lock, flags);
812 if (!tx->enabled) {
813 usb_free_urb(urb);
814 goto out;
815 }
816 list_add(&urb->urb_list, &tx->free_urb_list);
817out:
818 spin_unlock_irqrestore(&tx->lock, flags);
819}
820
821static void tx_dec_submitted_urbs(struct zd_usb *usb)
822{
823 struct zd_usb_tx *tx = &usb->tx;
824 unsigned long flags;
825
826 spin_lock_irqsave(&tx->lock, flags);
827 --tx->submitted_urbs;
828 if (tx->stopped && tx->submitted_urbs <= ZD_USB_TX_LOW) {
829 ieee80211_wake_queues(zd_usb_to_hw(usb));
830 tx->stopped = 0;
831 }
832 spin_unlock_irqrestore(&tx->lock, flags);
833}
834
835static void tx_inc_submitted_urbs(struct zd_usb *usb)
836{
837 struct zd_usb_tx *tx = &usb->tx;
838 unsigned long flags;
839
840 spin_lock_irqsave(&tx->lock, flags);
841 ++tx->submitted_urbs;
842 if (!tx->stopped && tx->submitted_urbs > ZD_USB_TX_HIGH) {
843 ieee80211_stop_queues(zd_usb_to_hw(usb));
844 tx->stopped = 1;
845 }
846 spin_unlock_irqrestore(&tx->lock, flags);
847}
848
849/**
850 * tx_urb_complete - completes the execution of an URB
851 * @urb: a URB
852 *
853 * This function is called if the URB has been transferred to a device or an
854 * error has happened.
855 */
744static void tx_urb_complete(struct urb *urb) 856static void tx_urb_complete(struct urb *urb)
745{ 857{
746 int r; 858 int r;
859 struct sk_buff *skb;
860 struct zd_tx_skb_control_block *cb;
861 struct zd_usb *usb;
747 862
748 switch (urb->status) { 863 switch (urb->status) {
749 case 0: 864 case 0:
@@ -761,9 +876,12 @@ static void tx_urb_complete(struct urb *urb)
761 goto resubmit; 876 goto resubmit;
762 } 877 }
763free_urb: 878free_urb:
764 usb_buffer_free(urb->dev, urb->transfer_buffer_length, 879 skb = (struct sk_buff *)urb->context;
765 urb->transfer_buffer, urb->transfer_dma); 880 zd_mac_tx_to_dev(skb, urb->status);
766 usb_free_urb(urb); 881 cb = (struct zd_tx_skb_control_block *)skb->cb;
882 usb = &zd_hw_mac(cb->hw)->chip.usb;
883 free_tx_urb(usb, urb);
884 tx_dec_submitted_urbs(usb);
767 return; 885 return;
768resubmit: 886resubmit:
769 r = usb_submit_urb(urb, GFP_ATOMIC); 887 r = usb_submit_urb(urb, GFP_ATOMIC);
@@ -773,43 +891,40 @@ resubmit:
773 } 891 }
774} 892}
775 893
776/* Puts the frame on the USB endpoint. It doesn't wait for 894/**
777 * completion. The frame must contain the control set. 895 * zd_usb_tx: initiates transfer of a frame of the device
896 *
897 * @usb: the zd1211rw-private USB structure
898 * @skb: a &struct sk_buff pointer
899 *
900 * This function tranmits a frame to the device. It doesn't wait for
901 * completion. The frame must contain the control set and have all the
902 * control set information available.
903 *
904 * The function returns 0 if the transfer has been successfully initiated.
778 */ 905 */
779int zd_usb_tx(struct zd_usb *usb, const u8 *frame, unsigned int length) 906int zd_usb_tx(struct zd_usb *usb, struct sk_buff *skb)
780{ 907{
781 int r; 908 int r;
782 struct usb_device *udev = zd_usb_to_usbdev(usb); 909 struct usb_device *udev = zd_usb_to_usbdev(usb);
783 struct urb *urb; 910 struct urb *urb;
784 void *buffer;
785 911
786 urb = usb_alloc_urb(0, GFP_ATOMIC); 912 urb = alloc_tx_urb(usb);
787 if (!urb) { 913 if (!urb) {
788 r = -ENOMEM; 914 r = -ENOMEM;
789 goto out; 915 goto out;
790 } 916 }
791 917
792 buffer = usb_buffer_alloc(zd_usb_to_usbdev(usb), length, GFP_ATOMIC,
793 &urb->transfer_dma);
794 if (!buffer) {
795 r = -ENOMEM;
796 goto error_free_urb;
797 }
798 memcpy(buffer, frame, length);
799
800 usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_DATA_OUT), 918 usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_DATA_OUT),
801 buffer, length, tx_urb_complete, NULL); 919 skb->data, skb->len, tx_urb_complete, skb);
802 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
803 920
804 r = usb_submit_urb(urb, GFP_ATOMIC); 921 r = usb_submit_urb(urb, GFP_ATOMIC);
805 if (r) 922 if (r)
806 goto error; 923 goto error;
924 tx_inc_submitted_urbs(usb);
807 return 0; 925 return 0;
808error: 926error:
809 usb_buffer_free(zd_usb_to_usbdev(usb), length, buffer, 927 free_tx_urb(usb, urb);
810 urb->transfer_dma);
811error_free_urb:
812 usb_free_urb(urb);
813out: 928out:
814 return r; 929 return r;
815} 930}
@@ -838,16 +953,20 @@ static inline void init_usb_rx(struct zd_usb *usb)
838 953
839static inline void init_usb_tx(struct zd_usb *usb) 954static inline void init_usb_tx(struct zd_usb *usb)
840{ 955{
841 /* FIXME: at this point we will allocate a fixed number of urb's for 956 struct zd_usb_tx *tx = &usb->tx;
842 * use in a cyclic scheme */ 957 spin_lock_init(&tx->lock);
958 tx->enabled = 0;
959 tx->stopped = 0;
960 INIT_LIST_HEAD(&tx->free_urb_list);
961 tx->submitted_urbs = 0;
843} 962}
844 963
845void zd_usb_init(struct zd_usb *usb, struct net_device *netdev, 964void zd_usb_init(struct zd_usb *usb, struct ieee80211_hw *hw,
846 struct usb_interface *intf) 965 struct usb_interface *intf)
847{ 966{
848 memset(usb, 0, sizeof(*usb)); 967 memset(usb, 0, sizeof(*usb));
849 usb->intf = usb_get_intf(intf); 968 usb->intf = usb_get_intf(intf);
850 usb_set_intfdata(usb->intf, netdev); 969 usb_set_intfdata(usb->intf, hw);
851 init_usb_interrupt(usb); 970 init_usb_interrupt(usb);
852 init_usb_tx(usb); 971 init_usb_tx(usb);
853 init_usb_rx(usb); 972 init_usb_rx(usb);
@@ -973,7 +1092,7 @@ int zd_usb_init_hw(struct zd_usb *usb)
973 return r; 1092 return r;
974 } 1093 }
975 1094
976 r = zd_mac_init_hw(mac); 1095 r = zd_mac_init_hw(mac->hw);
977 if (r) { 1096 if (r) {
978 dev_dbg_f(zd_usb_dev(usb), 1097 dev_dbg_f(zd_usb_dev(usb),
979 "couldn't initialize mac. Error number %d\n", r); 1098 "couldn't initialize mac. Error number %d\n", r);
@@ -987,9 +1106,9 @@ int zd_usb_init_hw(struct zd_usb *usb)
987static int probe(struct usb_interface *intf, const struct usb_device_id *id) 1106static int probe(struct usb_interface *intf, const struct usb_device_id *id)
988{ 1107{
989 int r; 1108 int r;
990 struct zd_usb *usb;
991 struct usb_device *udev = interface_to_usbdev(intf); 1109 struct usb_device *udev = interface_to_usbdev(intf);
992 struct net_device *netdev = NULL; 1110 struct zd_usb *usb;
1111 struct ieee80211_hw *hw = NULL;
993 1112
994 print_id(udev); 1113 print_id(udev);
995 1114
@@ -1007,57 +1126,65 @@ static int probe(struct usb_interface *intf, const struct usb_device_id *id)
1007 goto error; 1126 goto error;
1008 } 1127 }
1009 1128
1010 usb_reset_device(interface_to_usbdev(intf)); 1129 r = usb_reset_device(udev);
1130 if (r) {
1131 dev_err(&intf->dev,
1132 "couldn't reset usb device. Error number %d\n", r);
1133 goto error;
1134 }
1011 1135
1012 netdev = zd_netdev_alloc(intf); 1136 hw = zd_mac_alloc_hw(intf);
1013 if (netdev == NULL) { 1137 if (hw == NULL) {
1014 r = -ENOMEM; 1138 r = -ENOMEM;
1015 goto error; 1139 goto error;
1016 } 1140 }
1017 1141
1018 usb = &zd_netdev_mac(netdev)->chip.usb; 1142 usb = &zd_hw_mac(hw)->chip.usb;
1019 usb->is_zd1211b = (id->driver_info == DEVICE_ZD1211B) != 0; 1143 usb->is_zd1211b = (id->driver_info == DEVICE_ZD1211B) != 0;
1020 1144
1021 r = zd_mac_preinit_hw(zd_netdev_mac(netdev)); 1145 r = zd_mac_preinit_hw(hw);
1022 if (r) { 1146 if (r) {
1023 dev_dbg_f(&intf->dev, 1147 dev_dbg_f(&intf->dev,
1024 "couldn't initialize mac. Error number %d\n", r); 1148 "couldn't initialize mac. Error number %d\n", r);
1025 goto error; 1149 goto error;
1026 } 1150 }
1027 1151
1028 r = register_netdev(netdev); 1152 r = ieee80211_register_hw(hw);
1029 if (r) { 1153 if (r) {
1030 dev_dbg_f(&intf->dev, 1154 dev_dbg_f(&intf->dev,
1031 "couldn't register netdev. Error number %d\n", r); 1155 "couldn't register device. Error number %d\n", r);
1032 goto error; 1156 goto error;
1033 } 1157 }
1034 1158
1035 dev_dbg_f(&intf->dev, "successful\n"); 1159 dev_dbg_f(&intf->dev, "successful\n");
1036 dev_info(&intf->dev,"%s\n", netdev->name); 1160 dev_info(&intf->dev, "%s\n", wiphy_name(hw->wiphy));
1037 return 0; 1161 return 0;
1038error: 1162error:
1039 usb_reset_device(interface_to_usbdev(intf)); 1163 usb_reset_device(interface_to_usbdev(intf));
1040 zd_netdev_free(netdev); 1164 if (hw) {
1165 zd_mac_clear(zd_hw_mac(hw));
1166 ieee80211_free_hw(hw);
1167 }
1041 return r; 1168 return r;
1042} 1169}
1043 1170
1044static void disconnect(struct usb_interface *intf) 1171static void disconnect(struct usb_interface *intf)
1045{ 1172{
1046 struct net_device *netdev = zd_intf_to_netdev(intf); 1173 struct ieee80211_hw *hw = zd_intf_to_hw(intf);
1047 struct zd_mac *mac; 1174 struct zd_mac *mac;
1048 struct zd_usb *usb; 1175 struct zd_usb *usb;
1049 1176
1050 /* Either something really bad happened, or we're just dealing with 1177 /* Either something really bad happened, or we're just dealing with
1051 * a DEVICE_INSTALLER. */ 1178 * a DEVICE_INSTALLER. */
1052 if (netdev == NULL) 1179 if (hw == NULL)
1053 return; 1180 return;
1054 1181
1055 mac = zd_netdev_mac(netdev); 1182 mac = zd_hw_mac(hw);
1056 usb = &mac->chip.usb; 1183 usb = &mac->chip.usb;
1057 1184
1058 dev_dbg_f(zd_usb_dev(usb), "\n"); 1185 dev_dbg_f(zd_usb_dev(usb), "\n");
1059 1186
1060 zd_netdev_disconnect(netdev); 1187 ieee80211_unregister_hw(hw);
1061 1188
1062 /* Just in case something has gone wrong! */ 1189 /* Just in case something has gone wrong! */
1063 zd_usb_disable_rx(usb); 1190 zd_usb_disable_rx(usb);
@@ -1070,12 +1197,13 @@ static void disconnect(struct usb_interface *intf)
1070 */ 1197 */
1071 usb_reset_device(interface_to_usbdev(intf)); 1198 usb_reset_device(interface_to_usbdev(intf));
1072 1199
1073 zd_netdev_free(netdev); 1200 zd_mac_clear(mac);
1201 ieee80211_free_hw(hw);
1074 dev_dbg(&intf->dev, "disconnected\n"); 1202 dev_dbg(&intf->dev, "disconnected\n");
1075} 1203}
1076 1204
1077static struct usb_driver driver = { 1205static struct usb_driver driver = {
1078 .name = "zd1211rw", 1206 .name = KBUILD_MODNAME,
1079 .id_table = usb_ids, 1207 .id_table = usb_ids,
1080 .probe = probe, 1208 .probe = probe,
1081 .disconnect = disconnect, 1209 .disconnect = disconnect,
diff --git a/drivers/net/wireless/zd1211rw/zd_usb.h b/drivers/net/wireless/zd1211rw/zd_usb.h
index 961a7a12ad68..42159fc49cf8 100644
--- a/drivers/net/wireless/zd1211rw/zd_usb.h
+++ b/drivers/net/wireless/zd1211rw/zd_usb.h
@@ -26,6 +26,9 @@
26 26
27#include "zd_def.h" 27#include "zd_def.h"
28 28
29#define ZD_USB_TX_HIGH 5
30#define ZD_USB_TX_LOW 2
31
29enum devicetype { 32enum devicetype {
30 DEVICE_ZD1211 = 0, 33 DEVICE_ZD1211 = 0,
31 DEVICE_ZD1211B = 1, 34 DEVICE_ZD1211B = 1,
@@ -165,7 +168,7 @@ static inline struct usb_int_regs *get_read_regs(struct zd_usb_interrupt *intr)
165 return (struct usb_int_regs *)intr->read_regs.buffer; 168 return (struct usb_int_regs *)intr->read_regs.buffer;
166} 169}
167 170
168#define URBS_COUNT 5 171#define RX_URBS_COUNT 5
169 172
170struct zd_usb_rx { 173struct zd_usb_rx {
171 spinlock_t lock; 174 spinlock_t lock;
@@ -176,8 +179,21 @@ struct zd_usb_rx {
176 int urbs_count; 179 int urbs_count;
177}; 180};
178 181
182/**
183 * struct zd_usb_tx - structure used for transmitting frames
184 * @lock: lock for transmission
185 * @free_urb_list: list of free URBs, contains all the URBs, which can be used
186 * @submitted_urbs: atomic integer that counts the URBs having sent to the
187 * device, which haven't been completed
188 * @enabled: enabled flag, indicates whether tx is enabled
189 * @stopped: indicates whether higher level tx queues are stopped
190 */
179struct zd_usb_tx { 191struct zd_usb_tx {
180 spinlock_t lock; 192 spinlock_t lock;
193 struct list_head free_urb_list;
194 int submitted_urbs;
195 int enabled;
196 int stopped;
181}; 197};
182 198
183/* Contains the usb parts. The structure doesn't require a lock because intf 199/* Contains the usb parts. The structure doesn't require a lock because intf
@@ -198,17 +214,17 @@ static inline struct usb_device *zd_usb_to_usbdev(struct zd_usb *usb)
198 return interface_to_usbdev(usb->intf); 214 return interface_to_usbdev(usb->intf);
199} 215}
200 216
201static inline struct net_device *zd_intf_to_netdev(struct usb_interface *intf) 217static inline struct ieee80211_hw *zd_intf_to_hw(struct usb_interface *intf)
202{ 218{
203 return usb_get_intfdata(intf); 219 return usb_get_intfdata(intf);
204} 220}
205 221
206static inline struct net_device *zd_usb_to_netdev(struct zd_usb *usb) 222static inline struct ieee80211_hw *zd_usb_to_hw(struct zd_usb *usb)
207{ 223{
208 return zd_intf_to_netdev(usb->intf); 224 return zd_intf_to_hw(usb->intf);
209} 225}
210 226
211void zd_usb_init(struct zd_usb *usb, struct net_device *netdev, 227void zd_usb_init(struct zd_usb *usb, struct ieee80211_hw *hw,
212 struct usb_interface *intf); 228 struct usb_interface *intf);
213int zd_usb_init_hw(struct zd_usb *usb); 229int zd_usb_init_hw(struct zd_usb *usb);
214void zd_usb_clear(struct zd_usb *usb); 230void zd_usb_clear(struct zd_usb *usb);
@@ -221,7 +237,10 @@ void zd_usb_disable_int(struct zd_usb *usb);
221int zd_usb_enable_rx(struct zd_usb *usb); 237int zd_usb_enable_rx(struct zd_usb *usb);
222void zd_usb_disable_rx(struct zd_usb *usb); 238void zd_usb_disable_rx(struct zd_usb *usb);
223 239
224int zd_usb_tx(struct zd_usb *usb, const u8 *frame, unsigned int length); 240void zd_usb_enable_tx(struct zd_usb *usb);
241void zd_usb_disable_tx(struct zd_usb *usb);
242
243int zd_usb_tx(struct zd_usb *usb, struct sk_buff *skb);
225 244
226int zd_usb_ioread16v(struct zd_usb *usb, u16 *values, 245int zd_usb_ioread16v(struct zd_usb *usb, u16 *values,
227 const zd_addr_t *addresses, unsigned int count); 246 const zd_addr_t *addresses, unsigned int count);
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-12 23:32:20 -0400