Support for mesh virtual interface, mesh statistics
Javier Cardona
javier at cozybit.unroutablecom
Mon Dec 11 15:18:30 EST 2006
Commit: 5e3c6b9a2e1578aa47d5d5c4b189b29d01905f52
Parent: 67ce319af79169216374b99a4d5ee184adad23f4
commit 5e3c6b9a2e1578aa47d5d5c4b189b29d01905f52
Author: Javier Cardona <javier at cozybit.com>
AuthorDate: Thu Nov 16 14:55:41 2006 -0800
Commit: Javier Cardona <javier at cozybit.com>
CommitDate: Thu Nov 16 14:55:41 2006 -0800
Support for mesh virtual interface, mesh statistics
and bug fixes (from jcardona's branch)
---
drivers/net/wireless/libertas/README | 228 +++++++++
drivers/net/wireless/libertas/host.h | 44 +-
drivers/net/wireless/libertas/hostcmd.h | 35 +
drivers/net/wireless/libertas/if_usb.c | 22 +
drivers/net/wireless/libertas/sbi.h | 1
drivers/net/wireless/libertas/wlan_11d.c | 18 -
drivers/net/wireless/libertas/wlan_cmd.c | 416 +++++++++-------
drivers/net/wireless/libertas/wlan_cmdresp.c | 109 ++--
drivers/net/wireless/libertas/wlan_defs.h | 35 +
drivers/net/wireless/libertas/wlan_dev.h | 15 +
drivers/net/wireless/libertas/wlan_ethtool.c | 79 +++
drivers/net/wireless/libertas/wlan_fw.c | 8
drivers/net/wireless/libertas/wlan_ioctl.c | 686 +++++++++++++++++++++-----
drivers/net/wireless/libertas/wlan_join.c | 68 +--
drivers/net/wireless/libertas/wlan_main.c | 178 ++++++-
drivers/net/wireless/libertas/wlan_rx.c | 9
drivers/net/wireless/libertas/wlan_scan.c | 48 +-
drivers/net/wireless/libertas/wlan_tx.c | 4
drivers/net/wireless/libertas/wlan_version.h | 2
drivers/net/wireless/libertas/wlan_wext.c | 101 +++-
drivers/net/wireless/libertas/wlan_wext.h | 17 -
21 files changed, 1608 insertions(+), 515 deletions(-)
diff --git a/drivers/net/wireless/libertas/README b/drivers/net/wireless/libertas/README
index 9747dab..4024cda 100644
--- a/drivers/net/wireless/libertas/README
+++ b/drivers/net/wireless/libertas/README
@@ -123,6 +123,50 @@ Version 5 Command:
iwpriv ethX gettxrate
iwpriv ethX beaconinterval
+BT Commands:
+ The blinding table (BT) contains a list of mac addresses that should be
+ ignored by the firmware. It is primarily used for debugging and
+ testing networks. It can be edited and inspected with the following
+ commands:
+
+ iwpriv ethX bt_reset
+ iwpriv ethX bt_add <mac_address>
+ iwpriv ethX bt_del <mac_address>
+ iwpriv ethX bt_list <id>
+
+FWT Commands:
+ The forwarding table (FWT) is a feature used to manage mesh network
+ routing in the firmware. The FWT is essentially a routing table that
+ associates a destination mac address (da) with a next hop receiver
+ address (ra). The FWT can be inspected and edited with the following
+ iwpriv commands, which are described in greater detail below.
+ Eventually, the table will be automatically maintained by a custom
+ routing protocol.
+
+ NOTE: FWT commands replace the previous DFT commands. What were the DFT
+ commands?, you might ask. They were an earlier API to the firmware that
+ implemented a simple MAC-layer forwarding mechanism. In the unlikely
+ event that you were using these commands, you must migrate to the new
+ FWT commands which can be used to achieve the same functionality.
+
+ iwpriv ethX fwt_add [parameters]
+ iwpriv ethX fwt_del [parameters]
+ iwpriv ethX fwt_lookup [parameters]
+ iwpriv ethX fwt_list [parameters]
+ iwpriv ethX fwt_list_route [parameters]
+ iwpriv ethX fwt_list_neigh [parameters]
+ iwpriv ethX fwt_reset [parameters]
+ iwpriv ethX fwt_cleanup
+ iwpriv ethX fwt_time
+
+MESH Commands:
+
+ The MESH commands are used to configure various features of the mesh
+ routing protocol. The following commands are supported:
+
+ iwpriv ethX mesh_get_ttl
+ iwpriv ethX mesh_set_ttl ttl
+
DESCRIPTION
Those commands are used to send additional commands to the Marvell WLAN
card via the Linux device driver.
@@ -637,6 +681,190 @@ bcninterval
iwpriv ethX bcninterval 100 (set adhoc beacon interval to 100)
iwpriv ethX bcninterval (get adhoc beacon interval)
+fwt_add
+ This command is used to insert an entry into the FWT table. The list of
+ parameters must follow the following structure:
+
+ iwpriv ethX fwt_add da ra [metric dir ssn dsn hopcount ttl expiration sleepmode snr]
+
+ The parameters between brackets are optional, but they must appear in
+ the order specified. For example, if you want to specify the metric,
+ you must also specify the dir, ssn, and dsn but you need not specify the
+ hopcount, expiration, sleepmode, or snr. Any unspecified parameters
+ will be assigned the defaults specified below.
+
+ The different parameters are:-
+ da -- DA MAC address in the form 00:11:22:33:44:55
+ ra -- RA MAC address in the form 00:11:22:33:44:55
+ metric -- route metric (cost: smaller-metric routes are
+ preferred, default is 0)
+ dir -- direction (1 for direct, 0 for reverse,
+ default is 1)
+ ssn -- Source Sequence Number (time at the RA for
+ reverse routes. Default is 0)
+ dsn -- Destination Sequence Number (time at the DA
+ for direct routes. Default is 0)
+ hopcount -- hop count (currently unused, default is 0)
+ ttl -- TTL (Only used in reverse entries)
+ expiration -- entry expiration (in ticks, where a tick is
+ 1024us, or ~ 1ms. Use 0 for an indefinite
+ entry, default is 0)
+ sleepmode -- RA's sleep mode (currently unused, default is
+ 0)
+ snr -- SNR in the link to RA (currently unused,
+ default is 0)
+
+ The command does not return anything.
+
+fwt_del
+ This command is used to remove an entry to the FWT table. The list of
+ parameters must follow the following structure:
+
+ iwpriv ethX fwt_del da ra [dir]
+
+ where the different parameters are:-
+ da -- DA MAC address (in the form "00:11:22:33:44:55")
+ ra -- RA MAC address (in the form "00:11:22:33:44:55")
+ dir -- direction (1 for direct, 0 for reverse,
+ default is 1)
+
+ The command does not return anything.
+
+fwt_lookup
+ This command is used to get the best route in the FWT table to a given
+ host. The only parameter is the MAC address of the host that is being
+ looked for.
+
+ iwpriv ethX fwt_lookup da
+
+ where:-
+ da -- DA MAC address (in the form "00:11:22:33:44:55")
+
+ The command returns an output string identical to the one returned by
+ fwt_list described below.
+
+
+fwt_list
+ This command is used to list a route from the FWT table. The only
+ parameter is the index into the table. If you want to list all the
+ routes in a table, start with index=0, and keep listing until you get a
+ "(null)" string. Note that the indicies may change as the fwt is
+ updated. It is expected that most users will not use fwt_list directly,
+ but that a utility similar to the traditional route command will be used
+ to invoke fwt_list over and over.
+
+ iwpriv ethX fwt_list index
+
+ The output is a string of the following form:
+
+ da ra metric dir ssn dsn hopcount ttl expiration sleepmode snr
+
+ where the different fields are:-
+ da -- DA MAC address (in the form "00:11:22:33:44:55")
+ ra -- RA MAC address (in the form "00:11:22:33:44:55")
+ metric -- route metric (cost: smaller-metric routes are preferred)
+ dir -- direction (1 for direct, 0 for reverse)
+ ssn -- Source Sequence Number (time at the RA for reverse routes)
+ dsn -- Destination Sequence Number (time at the DA for direct routes)
+ hopcount -- hop count (currently unused)
+ ttl -- TTL (only used in reverse entries)
+ expiration -- entry expiration (in ticks, where a tick is 1024us, or ~ 1ms. Use 0 for an indefinite entry)
+ sleepmode -- RA's sleep mode (currently unused)
+ snr -- SNR in the link to RA (currently unused)
+
+fwt_list_route
+ This command is used to list a route from the FWT table. The only
+ parameter is the route ID. If you want to list all the routes in a
+ table, start with rid=0, and keep incrementing rid until you get a
+ "(null)" string. This function is similar to fwt_list. The only
+ difference is the output format. Also note that this command is meant
+ for debugging. It is expected that users will use fwt_lookup and
+ fwt_list. One important reason for this is that the route id may change
+ as the route table is altered.
+
+ iwpriv ethX fwt_list_route rid
+
+ The output is a string of the following form:
+
+ da metric dir nid ssn dsn hopcount ttl expiration
+
+ where the different fields are:-
+ da -- DA MAC address (in the form "00:11:22:33:44:55")
+ metric -- route metric (cost: smaller-metric routes are preferred)
+ dir -- direction (1 for direct, 0 for reverse)
+ nid -- Next-hop (neighbor) host ID (nid)
+ ssn -- Source Sequence Number (time at the RA for reverse routes)
+ dsn -- Destination Sequence Number (time at the DA for direct routes)
+ hopcount -- hop count (currently unused)
+ ttl -- TTL count (only used in reverse entries)
+ expiration -- entry expiration (in ticks, where a tick is 1024us, or ~ 1ms. Use 0 for an indefinite entry)
+
+fwt_list_neigh
+ This command is used to list a neighbor from the FWT table. The only
+ parameter is the neighbor ID. If you want to list all the neighbors in a
+ table, start with nid=0, and keep incrementing nid until you get a
+ "(null)" string. Note that the nid from a fwt_list_route command can be
+ used as an input to this command. Also note that this command is meant
+ mostly for debugging. It is expected that users will use fwt_lookup.
+ One important reason for this is that the neighbor id may change as the
+ neighbor table is altered.
+
+ iwpriv ethX fwt_list_neigh nid
+
+ The output is a string of the following form:
+
+ ra sleepmode snr references
+
+ where the different fields are:-
+ ra -- RA MAC address (in the form "00:11:22:33:44:55")
+ sleepmode -- RA's sleep mode (currently unused)
+ snr -- SNR in the link to RA (currently unused)
+ references -- RA's reference counter
+
+fwt_reset
+ This command is used to reset the FWT table, getting rid of all the
+ entries. There are no input parameters.
+
+ iwpriv ethX fwt_reset
+
+ The command does not return anything.
+
+fwt_cleanup
+ This command is used to perform user-based garbage recollection. The
+ FWT table is checked, and all the entries that are expired or invalid
+ are cleaned. Note that this is exported to the driver for debugging
+ purposes, as garbage collection is also fired by the firmware when in
+ space problems. There are no input parameters.
+
+ iwpriv ethX fwt_cleanup
+
+ The command does returns the number of invalid/expired routes deleted.
+
+fwt_time
+ This command returns a card's internal time representation. It is this
+ time that is used to represent the expiration times of FWT entries. The
+ number is not consistent from card to card; it is simply a timer count.
+ The fwt_time command is used to inspect the timer so that expiration
+ times reported by fwt_list can be properly interpreted.
+
+ iwpriv ethX fwt_time
+
+mesh_get_ttl
+
+ The mesh ttl is the number of hops a mesh packet can traverse before it
+ is dropped. This parameter is used to prevent infinite loops in the
+ mesh network. The value returned by this function is the ttl assigned
+ to all mesh packets. Currently there is no way to control the ttl on a
+ per packet or per socket basis.
+
+ iwpriv ethX mesh_get_ttl
+
+mesh_set_ttl ttl
+
+ Set the ttl. The argument must be between 0 and 255.
+
+ iwpriv ethX mesh_set_ttl <ttl>
+
=========================
4) FOR WLANCONFIG COMMAND
=========================
diff --git a/drivers/net/wireless/libertas/host.h b/drivers/net/wireless/libertas/host.h
index fa7ab9f..535b796 100644
--- a/drivers/net/wireless/libertas/host.h
+++ b/drivers/net/wireless/libertas/host.h
@@ -171,8 +171,14 @@ #define HostCmd_CMD_802_11_TX_RATE_QUERY
#define HostCmd_CMD_GET_TSF 0x0080
-#define HostCmd_CMD_DFT_ACCESS 0x0087
-#define HostCmd_RET_DFT_ACCESS 0x8087
+#define HostCmd_CMD_BT_ACCESS 0x0087
+#define HostCmd_RET_BT_ACCESS 0x8087
+
+#define HostCmd_CMD_FWT_ACCESS 0x0088
+#define HostCmd_RET_FWT_ACCESS 0x8088
+
+#define HostCmd_CMD_MESH_ACCESS 0x0090
+#define HostCmd_RET_MESH_ACCESS 0x8090
/* For the IEEE Power Save */
#define HostCmd_SubCmd_Enter_PS 0x0030
@@ -422,18 +428,38 @@ #define HostCmd_TYPE_CAM
#define HostCmd_TYPE_MAX_PSP 0x0001
#define HostCmd_TYPE_FAST_PSP 0x0002
-/* Define action or option for HostCmd_CMD_DFT_ACCESS */
-enum HostCmd_CMD_DFT_ACCESS_OPTS {
- HostCmd_ACT_DFT_ACCESS_ADD = 1,
- HostCmd_ACT_DFT_ACCESS_DEL,
- HostCmd_ACT_DFT_ACCESS_LIST,
- HostCmd_ACT_DFT_ACCESS_RESET,
- HostCmd_ACT_BT_ACCESS_ADD,
+/* Define action or option for HostCmd_CMD_BT_ACCESS */
+enum HostCmd_CMD_BT_ACCESS_OPTS {
+ /* The bt commands start at 5 instead of 1 because the old dft commands
+ * are mapped to 1-4. These old commands are no longer maintained and
+ * should not be called.
+ */
+ HostCmd_ACT_BT_ACCESS_ADD = 5,
HostCmd_ACT_BT_ACCESS_DEL,
HostCmd_ACT_BT_ACCESS_LIST,
HostCmd_ACT_BT_ACCESS_RESET
};
+/* Define action or option for HostCmd_CMD_FWT_ACCESS */
+enum HostCmd_CMD_FWT_ACCESS_OPTS {
+ HostCmd_ACT_FWT_ACCESS_ADD = 1,
+ HostCmd_ACT_FWT_ACCESS_DEL,
+ HostCmd_ACT_FWT_ACCESS_LOOKUP,
+ HostCmd_ACT_FWT_ACCESS_LIST,
+ HostCmd_ACT_FWT_ACCESS_LIST_ROUTE,
+ HostCmd_ACT_FWT_ACCESS_LIST_NEIGHBOR,
+ HostCmd_ACT_FWT_ACCESS_RESET,
+ HostCmd_ACT_FWT_ACCESS_CLEANUP,
+ HostCmd_ACT_FWT_ACCESS_TIME,
+};
+
+/* Define action or option for HostCmd_CMD_MESH_ACCESS */
+enum HostCmd_CMD_MESH_ACCESS_OPTS {
+ HostCmd_ACT_MESH_GET_TTL = 1,
+ HostCmd_ACT_MESH_SET_TTL,
+ HostCmd_ACT_MESH_GET_STATS,
+};
+
/** Card Event definition */
#define MACREG_INT_CODE_TX_PPA_FREE 0x00000000
#define MACREG_INT_CODE_TX_DMA_DONE 0x00000001
diff --git a/drivers/net/wireless/libertas/hostcmd.h b/drivers/net/wireless/libertas/hostcmd.h
index fd63bdc..37d42d0 100644
--- a/drivers/net/wireless/libertas/hostcmd.h
+++ b/drivers/net/wireless/libertas/hostcmd.h
@@ -28,7 +28,7 @@ Change log:
04/10/06: Add hostcmd generic API and power_adapt_cfg_ext command
04/18/06: Remove old Subscrive Event and add new Subscribe Event
implementation through generic hostcmd API
-
+ 06/27/06: Remove dft features. Use fwt instead.
********************************************************/
#ifndef __HOSTCMD__H
@@ -890,14 +890,39 @@ struct HostCmd_DS_GET_TSF {
u64 TsfValue;
} __attribute__ ((packed));
-/* HostCmd_CMD_DFT_ACCESS */
-struct HostCmd_DS_DFT_ACCESS {
+/* HostCmd_CMD_BT_ACCESS */
+struct HostCmd_DS_BT_ACCESS {
u16 action;
u32 id;
u8 addr1[ETH_ALEN];
u8 addr2[ETH_ALEN];
} __attribute__ ((packed));
+/* HostCmd_CMD_FWT_ACCESS */
+struct HostCmd_DS_FWT_ACCESS {
+ u16 action;
+ u32 id;
+ u8 da[ETH_ALEN];
+ u8 dir;
+ u8 ra[ETH_ALEN];
+ u32 ssn;
+ u32 dsn;
+ u32 metric;
+ u8 hopcount;
+ u8 ttl;
+ u32 expiration;
+ u8 sleepmode;
+ u32 snr;
+ u32 references;
+} __attribute__ ((packed));
+
+/* HostCmd_CMD_MESH_ACCESS */
+#define MESH_STATS_NUM 7
+struct HostCmd_DS_MESH_ACCESS {
+ u16 action;
+ u32 data[MESH_STATS_NUM + 1]; /* last position reserved */
+} __attribute__ ((packed));
+
/* HostCmd_DS_COMMAND */
struct HostCmd_DS_COMMAND {
/* Command Header */
@@ -959,7 +984,9 @@ struct HostCmd_DS_COMMAND {
struct HostCmd_DS_802_11_LED_CTRL ledgpio;
struct HostCmd_TX_RATE_QUERY txrate;
- struct HostCmd_DS_DFT_ACCESS dft;
+ struct HostCmd_DS_BT_ACCESS bt;
+ struct HostCmd_DS_FWT_ACCESS fwt;
+ struct HostCmd_DS_MESH_ACCESS mesh;
struct HostCmd_DS_GET_TSF gettsf;
} params;
} __attribute__ ((packed));
diff --git a/drivers/net/wireless/libertas/if_usb.c b/drivers/net/wireless/libertas/if_usb.c
index 7bcfc14..702f1f4 100644
--- a/drivers/net/wireless/libertas/if_usb.c
+++ b/drivers/net/wireless/libertas/if_usb.c
@@ -141,6 +141,9 @@ static void if_usb_write_bulk_callback(s
dprintk(2, "Actual length transmitted %d\n",
urb->actual_length);
priv->wlan_dev.dnld_sent = DNLD_RES_RECEIVED;
+ /* Wake main thread if commands are pending */
+ if (!adapter->CurCmd)
+ wake_up_interruptible(&priv->MainThread.waitQ);
if ((adapter->MediaConnectStatus == WlanMediaStateConnected))
netif_wake_queue(dev);
}
@@ -576,7 +579,7 @@ #define MRVDRV_MIN_PKT_LEN 30
memcpy(&RecvType, RecvBuff, sizeof(u32));
dprintk(1, "Recv length = 0x%x\n", RecvLength);
dprintk(1, "Receive type = 0x%X\n", RecvType);
- RecvType = wlan_le32_to_cpu(RecvType);
+ RecvType = le32_to_cpu(RecvType);
dprintk(1, "Receive type after = 0x%X\n", RecvType);
} else if (urb->status) {
if (!cardp->rx_urb_recall) {
@@ -652,7 +655,7 @@ #define MRVDRV_MIN_PKT_LEN 30
libertas_send_tx_feedback(priv);
break;
}
- cardp->usb_event_cause = wlan_le32_to_cpu(cardp->usb_event_cause) << 3;
+ cardp->usb_event_cause = le32_to_cpu(cardp->usb_event_cause) << 3;
usb_int_cause |= HIS_CardEvent;
kfree_skb(skb);
if_usb_interrupt(priv, HIS_CardEvent, RX_SUCCESS);
@@ -691,13 +694,13 @@ int libertas_sbi_host_to_card(wlan_priva
dprintk(1, "Size after = %d\n", nb);
if (type == MVMS_CMD) {
- tmp = wlan_cpu_to_le32(CMD_TYPE_REQUEST);
+ tmp = cpu_to_le32(CMD_TYPE_REQUEST);
priv->wlan_dev.dnld_sent = DNLD_CMD_SENT;
memcpy(cardp->bulk_out_buffer, (u8 *) & tmp,
MESSAGE_HEADER_LEN);
} else {
- tmp = wlan_cpu_to_le32(CMD_TYPE_DATA);
+ tmp = cpu_to_le32(CMD_TYPE_DATA);
priv->wlan_dev.dnld_sent = DNLD_DATA_SENT;
memcpy(cardp->bulk_out_buffer, (u8 *) & tmp,
MESSAGE_HEADER_LEN);
@@ -1036,6 +1039,17 @@ int libertas_sbi_disable_host_int(wlan_p
return WLAN_STATUS_SUCCESS;
}
+/**
+ * @brief Given a usb_card_rec return its wlan_private
+ * @param card pointer to a usb_card_rec
+ * @return pointer to wlan_private
+ */
+wlan_private *libertas_sbi_get_priv(void *card)
+{
+ struct usb_card_rec *cardp = (struct usb_card_rec *)card;
+ return (wlan_private *)cardp->priv;
+}
+
#ifdef ENABLE_PM
/**
* @brief This is a dummy function
diff --git a/drivers/net/wireless/libertas/sbi.h b/drivers/net/wireless/libertas/sbi.h
index 175049c..6d4078f 100644
--- a/drivers/net/wireless/libertas/sbi.h
+++ b/drivers/net/wireless/libertas/sbi.h
@@ -104,6 +104,7 @@ int libertas_sbi_read_event_cause(wlan_p
int libertas_sbi_reenable_host_interrupt(wlan_private *, u8);
int libertas_sbi_host_to_card(wlan_private * priv, u8 type, u8 * payload, u16 nb);
int libertas_sbi_enable_host_int(wlan_private *);
+wlan_private *libertas_sbi_get_priv(void *card);
#ifdef ENABLE_PM
int libertas_sbi_suspend(wlan_private *);
diff --git a/drivers/net/wireless/libertas/wlan_11d.c b/drivers/net/wireless/libertas/wlan_11d.c
index be8ef8b..a9adeb9 100644
--- a/drivers/net/wireless/libertas/wlan_11d.c
+++ b/drivers/net/wireless/libertas/wlan_11d.c
@@ -636,36 +636,36 @@ int libertas_cmd_802_11d_domain_info(wla
dprintk(1, "NoOfSubband=%x\n", NoOfSubband);
- cmd->Command = wlan_cpu_to_le16(cmdno);
- pDomainInfo->Action = wlan_cpu_to_le16(CmdOption);
+ cmd->Command = cpu_to_le16(cmdno);
+ pDomainInfo->Action = cpu_to_le16(CmdOption);
if (CmdOption == HostCmd_ACT_GET) {
cmd->Size =
- wlan_cpu_to_le16(sizeof(pDomainInfo->Action) + S_DS_GEN);
+ cpu_to_le16(sizeof(pDomainInfo->Action) + S_DS_GEN);
HEXDUMP("11D: 802_11D_DOMAIN_INFO:", (u8 *) cmd,
(int)(cmd->Size));
LEAVE();
return WLAN_STATUS_SUCCESS;
}
- domain->Header.Type = wlan_cpu_to_le16(TLV_TYPE_DOMAIN);
+ domain->Header.Type = cpu_to_le16(TLV_TYPE_DOMAIN);
memcpy(domain->CountryCode, Adapter->DomainReg.CountryCode,
sizeof(domain->CountryCode));
domain->Header.Len =
- wlan_cpu_to_le16(NoOfSubband * sizeof(struct IEEEtypes_SubbandSet) +
+ cpu_to_le16(NoOfSubband * sizeof(struct IEEEtypes_SubbandSet) +
sizeof(domain->CountryCode));
if (NoOfSubband) {
memcpy(domain->Subband, Adapter->DomainReg.Subband,
NoOfSubband * sizeof(struct IEEEtypes_SubbandSet));
- cmd->Size = wlan_cpu_to_le16(sizeof(pDomainInfo->Action) +
+ cmd->Size = cpu_to_le16(sizeof(pDomainInfo->Action) +
domain->Header.Len +
sizeof(struct MrvlIEtypesHeader) +
S_DS_GEN);
} else {
cmd->Size =
- wlan_cpu_to_le16(sizeof(pDomainInfo->Action) + S_DS_GEN);
+ cpu_to_le16(sizeof(pDomainInfo->Action) + S_DS_GEN);
}
HEXDUMP("11D:802_11D_DOMAIN_INFO:", (u8 *) cmd, (int)(cmd->Size));
@@ -726,14 +726,14 @@ int libertas_ret_802_11d_domain_info(wla
struct HostCmd_DS_802_11D_DOMAIN_INFO_RSP
*domaininfo = &resp->params.domaininforesp;
struct MrvlIEtypes_DomainParamSet *domain = &domaininfo->Domain;
- u16 Action = wlan_le16_to_cpu(domaininfo->Action);
+ u16 Action = le16_to_cpu(domaininfo->Action);
s16 ret = WLAN_STATUS_SUCCESS;
u8 NoOfSubband = 0;
ENTER();
HEXDUMP("11D DOMAIN Info Rsp Data:", (u8 *) resp,
- (int)wlan_le16_to_cpu(resp->Size));
+ (int)le16_to_cpu(resp->Size));
NoOfSubband = (domain->Header.Len - 3) / sizeof(struct IEEEtypes_SubbandSet);
/* countrycode 3 bytes */
diff --git a/drivers/net/wireless/libertas/wlan_cmd.c b/drivers/net/wireless/libertas/wlan_cmd.c
index eef548f..bf6426f 100644
--- a/drivers/net/wireless/libertas/wlan_cmd.c
+++ b/drivers/net/wireless/libertas/wlan_cmd.c
@@ -33,6 +33,7 @@ Change log:
04/06/06: Add TSPEC, queue metrics, and MSDU expiry support
04/18/06: Remove old Subscrive Event and add new Subscribe Event
implementation through generic hostcmd API
+ 06/27/06: Remove dft features. Use fwt instead.
********************************************************/
#include <net/iw_handler.h>
@@ -66,7 +67,7 @@ static u8 Is_Command_Allowed_In_PS(u16 C
int i;
for (i = 0; i < count; i++) {
- if (Command == wlan_cpu_to_le16(Commands_Allowed_In_PS[i]))
+ if (Command == cpu_to_le16(Commands_Allowed_In_PS[i]))
return 1;
}
@@ -86,9 +87,9 @@ static int wlan_cmd_hw_spec(wlan_private
ENTER();
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_GET_HW_SPEC);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_GET_HW_SPEC);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_GET_HW_SPEC) + S_DS_GEN);
+ cpu_to_le16(sizeof(struct HostCmd_DS_GET_HW_SPEC) + S_DS_GEN);
memcpy(hwspec->PermanentAddr, priv->adapter->CurrentAddr, ETH_ALEN);
LEAVE();
@@ -113,11 +114,11 @@ static int wlan_cmd_802_11_ps_mode(wlan_
ENTER();
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_PS_MODE);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_PS_MODE);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_PS_MODE) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_PS_MODE) +
S_DS_GEN);
- psm->Action = wlan_cpu_to_le16(cmd_action);
+ psm->Action = cpu_to_le16(cmd_action);
psm->MultipleDtim = 0;
switch (Action) {
case HostCmd_SubCmd_Enter_PS:
@@ -126,11 +127,11 @@ static int wlan_cmd_802_11_ps_mode(wlan_
Adapter->LocalListenInterval);
psm->LocalListenInterval =
- wlan_cpu_to_le16(Adapter->LocalListenInterval);
+ cpu_to_le16(Adapter->LocalListenInterval);
psm->NullPktInterval =
- wlan_cpu_to_le16(Adapter->NullPktInterval);
+ cpu_to_le16(Adapter->NullPktInterval);
psm->MultipleDtim =
- wlan_cpu_to_le16(priv->adapter->MultipleDtim);
+ cpu_to_le16(priv->adapter->MultipleDtim);
break;
case HostCmd_SubCmd_Exit_PS:
@@ -164,16 +165,16 @@ static int wlan_cmd_802_11_inactivity_ti
{
u16 *timeout = (u16 *) pdata_buf;
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_INACTIVITY_TIMEOUT);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_INACTIVITY_TIMEOUT);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_INACTIVITY_TIMEOUT)
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_INACTIVITY_TIMEOUT)
+ S_DS_GEN);
- cmd->params.inactivity_timeout.Action = wlan_cpu_to_le16(cmd_action);
+ cmd->params.inactivity_timeout.Action = cpu_to_le16(cmd_action);
if (cmd_action)
cmd->params.inactivity_timeout.Timeout =
- wlan_cpu_to_le16(*timeout);
+ cpu_to_le16(*timeout);
else
cmd->params.inactivity_timeout.Timeout = 0;
@@ -193,9 +194,9 @@ static int wlan_cmd_802_11_sleep_period(
struct HostCmd_DS_COMMAND *cmd,
u16 cmd_action, void *pdata_buf)
{
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_SLEEP_PERIOD);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_SLEEP_PERIOD);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_SLEEP_PERIOD) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_SLEEP_PERIOD) +
S_DS_GEN);
memmove(&cmd->params.ps_sleeppd, pdata_buf,
sizeof(struct HostCmd_DS_802_11_SLEEP_PERIOD));
@@ -221,22 +222,22 @@ static int wlan_cmd_802_11_sleep_params(
ENTER();
cmd->Size =
- wlan_cpu_to_le16((sizeof(struct HostCmd_DS_802_11_SLEEP_PARAMS)) +
+ cpu_to_le16((sizeof(struct HostCmd_DS_802_11_SLEEP_PARAMS)) +
S_DS_GEN);
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_SLEEP_PARAMS);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_SLEEP_PARAMS);
if (cmd_action == HostCmd_ACT_GEN_GET) {
memset(&Adapter->sp, 0, sizeof(struct sleep_params));
memset(sp, 0, sizeof(struct HostCmd_DS_802_11_SLEEP_PARAMS));
- sp->Action = wlan_cpu_to_le16(cmd_action);
+ sp->Action = cpu_to_le16(cmd_action);
} else if (cmd_action == HostCmd_ACT_GEN_SET) {
- sp->Action = wlan_cpu_to_le16(cmd_action);
- sp->Error = wlan_cpu_to_le16(Adapter->sp.sp_error);
- sp->Offset = wlan_cpu_to_le16(Adapter->sp.sp_offset);
- sp->StableTime = wlan_cpu_to_le16(Adapter->sp.sp_stabletime);
+ sp->Action = cpu_to_le16(cmd_action);
+ sp->Error = cpu_to_le16(Adapter->sp.sp_error);
+ sp->Offset = cpu_to_le16(Adapter->sp.sp_offset);
+ sp->StableTime = cpu_to_le16(Adapter->sp.sp_stabletime);
sp->CalControl = (u8) Adapter->sp.sp_calcontrol;
sp->ExternalSleepClk = (u8) Adapter->sp.sp_extsleepclk;
- sp->Reserved = wlan_cpu_to_le16(Adapter->sp.sp_reserved);
+ sp->Reserved = cpu_to_le16(Adapter->sp.sp_reserved);
}
LEAVE();
@@ -263,8 +264,8 @@ static int wlan_cmd_802_11_set_wep(wlan_
ENTER();
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_SET_WEP);
- cmd->Size = wlan_cpu_to_le16((sizeof(struct HostCmd_DS_802_11_SET_WEP))
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_SET_WEP);
+ cmd->Size = cpu_to_le16((sizeof(struct HostCmd_DS_802_11_SET_WEP))
+ S_DS_GEN);
if (cmd_act == HostCmd_ACT_ADD) {
@@ -276,10 +277,10 @@ static int wlan_cmd_802_11_set_wep(wlan_
goto done;
}
- wep->Action = wlan_cpu_to_le16(HostCmd_ACT_ADD);
+ wep->Action = cpu_to_le16(HostCmd_ACT_ADD);
/* default tx key index */
- wep->KeyIndex = wlan_cpu_to_le16((u16)
+ wep->KeyIndex = cpu_to_le16((u16)
(assoc_req->wep_tx_keyidx &
(u32)HostCmd_WEP_KEY_INDEX_MASK));
@@ -312,10 +313,10 @@ static int wlan_cmd_802_11_set_wep(wlan_
}
} else if (cmd_act == HostCmd_ACT_REMOVE) {
/* ACT_REMOVE clears _all_ WEP keys */
- wep->Action = wlan_cpu_to_le16(HostCmd_ACT_REMOVE);
+ wep->Action = cpu_to_le16(HostCmd_ACT_REMOVE);
/* default tx key index */
- wep->KeyIndex = wlan_cpu_to_le16((u16)
+ wep->KeyIndex = cpu_to_le16((u16)
(Adapter->wep_tx_keyidx &
(u32)HostCmd_WEP_KEY_INDEX_MASK));
}
@@ -342,15 +343,15 @@ static int wlan_cmd_802_11_enable_rsn(wl
struct HostCmd_DS_802_11_ENABLE_RSN *pEnableRSN = &cmd->params.enbrsn;
wlan_adapter *Adapter = priv->adapter;
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_ENABLE_RSN);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_ENABLE_RSN);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_ENABLE_RSN) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_ENABLE_RSN) +
S_DS_GEN);
- pEnableRSN->Action = wlan_cpu_to_le16(cmd_action);
+ pEnableRSN->Action = cpu_to_le16(cmd_action);
if (Adapter->SecInfo.WPAEnabled || Adapter->SecInfo.WPA2Enabled) {
- pEnableRSN->Enable = wlan_cpu_to_le16(HostCmd_ENABLE_RSN);
+ pEnableRSN->Enable = cpu_to_le16(HostCmd_ENABLE_RSN);
} else {
- pEnableRSN->Enable = wlan_cpu_to_le16(HostCmd_DISABLE_RSN);
+ pEnableRSN->Enable = cpu_to_le16(HostCmd_DISABLE_RSN);
}
return WLAN_STATUS_SUCCESS;
@@ -360,24 +361,24 @@ static int wlan_cmd_802_11_enable_rsn(wl
static void set_one_wpa_key(struct MrvlIEtype_KeyParamSet * pKeyParamSet,
struct WLAN_802_11_KEY * pKey)
{
- pKeyParamSet->KeyTypeId = wlan_cpu_to_le16(pKey->type);
+ pKeyParamSet->KeyTypeId = cpu_to_le16(pKey->type);
if (pKey->flags & KEY_INFO_WPA_ENABLED) {
- pKeyParamSet->KeyInfo = wlan_cpu_to_le16(KEY_INFO_WPA_ENABLED);
+ pKeyParamSet->KeyInfo = cpu_to_le16(KEY_INFO_WPA_ENABLED);
} else {
- pKeyParamSet->KeyInfo = wlan_cpu_to_le16(!KEY_INFO_WPA_ENABLED);
+ pKeyParamSet->KeyInfo = cpu_to_le16(!KEY_INFO_WPA_ENABLED);
}
if (pKey->flags & KEY_INFO_WPA_UNICAST) {
- pKeyParamSet->KeyInfo |= wlan_cpu_to_le16(KEY_INFO_WPA_UNICAST);
+ pKeyParamSet->KeyInfo |= cpu_to_le16(KEY_INFO_WPA_UNICAST);
} else if (pKey->flags & KEY_INFO_WPA_MCAST) {
- pKeyParamSet->KeyInfo |= wlan_cpu_to_le16(KEY_INFO_WPA_MCAST);
+ pKeyParamSet->KeyInfo |= cpu_to_le16(KEY_INFO_WPA_MCAST);
}
- pKeyParamSet->Type = wlan_cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
- pKeyParamSet->KeyLen = wlan_cpu_to_le16(pKey->len);
+ pKeyParamSet->Type = cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
+ pKeyParamSet->KeyLen = cpu_to_le16(pKey->len);
memcpy(pKeyParamSet->Key, pKey->key, pKey->len);
- pKeyParamSet->Length = wlan_cpu_to_le16( sizeof(pKeyParamSet->KeyTypeId)
+ pKeyParamSet->Length = cpu_to_le16( sizeof(pKeyParamSet->KeyTypeId)
+ sizeof(pKeyParamSet->KeyInfo)
+ sizeof(pKeyParamSet->KeyLen)
+ sizeof(pKeyParamSet->Key));
@@ -406,11 +407,11 @@ static int wlan_cmd_802_11_key_material(
ENTER();
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_KEY_MATERIAL);
- pKeyMaterial->Action = wlan_cpu_to_le16(cmd_action);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_KEY_MATERIAL);
+ pKeyMaterial->Action = cpu_to_le16(cmd_action);
if (cmd_action == HostCmd_ACT_GET) {
- cmd->Size = wlan_cpu_to_le16( S_DS_GEN
+ cmd->Size = cpu_to_le16( S_DS_GEN
+ sizeof (pKeyMaterial->Action));
ret = WLAN_STATUS_SUCCESS;
goto done;
@@ -430,7 +431,7 @@ static int wlan_cmd_802_11_key_material(
index++;
}
- cmd->Size = wlan_cpu_to_le16( S_DS_GEN
+ cmd->Size = cpu_to_le16( S_DS_GEN
+ sizeof (pKeyMaterial->Action)
+ index * sizeof(struct MrvlIEtype_KeyParamSet));
@@ -454,10 +455,10 @@ static int wlan_cmd_802_11_reset(wlan_pr
{
struct HostCmd_DS_802_11_RESET *reset = &cmd->params.reset;
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_RESET);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_RESET);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_RESET) + S_DS_GEN);
- reset->Action = wlan_cpu_to_le16(cmd_action);
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_RESET) + S_DS_GEN);
+ reset->Action = cpu_to_le16(cmd_action);
return WLAN_STATUS_SUCCESS;
}
@@ -472,9 +473,9 @@ static int wlan_cmd_802_11_reset(wlan_pr
static int wlan_cmd_802_11_get_log(wlan_private * priv,
struct HostCmd_DS_COMMAND *cmd)
{
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_GET_LOG);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_GET_LOG);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_GET_LOG) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_GET_LOG) +
S_DS_GEN);
return WLAN_STATUS_SUCCESS;
@@ -490,9 +491,9 @@ static int wlan_cmd_802_11_get_log(wlan_
static int wlan_cmd_802_11_get_stat(wlan_private * priv,
struct HostCmd_DS_COMMAND *cmd)
{
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_GET_STAT);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_GET_STAT);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_GET_STAT) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_GET_STAT) +
S_DS_GEN);
return WLAN_STATUS_SUCCESS;
@@ -521,9 +522,9 @@ static int wlan_cmd_802_11_snmp_mib(wlan
dprintk(1, "SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid);
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_SNMP_MIB);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_SNMP_MIB);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_SNMP_MIB) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_SNMP_MIB) +
S_DS_GEN);
switch (cmd_oid) {
@@ -531,8 +532,8 @@ static int wlan_cmd_802_11_snmp_mib(wlan
{
enum WLAN_802_11_NETWORK_INFRASTRUCTURE mode =
(enum WLAN_802_11_NETWORK_INFRASTRUCTURE) pdata_buf;
- pSNMPMIB->QueryType = wlan_cpu_to_le16(HostCmd_ACT_GEN_SET);
- pSNMPMIB->OID = wlan_cpu_to_le16((u16) DesiredBssType_i);
+ pSNMPMIB->QueryType = cpu_to_le16(HostCmd_ACT_GEN_SET);
+ pSNMPMIB->OID = cpu_to_le16((u16) DesiredBssType_i);
pSNMPMIB->BufSize = sizeof(u8);
if (mode == Wlan802_11Infrastructure)
ucTemp = SNMP_MIB_VALUE_INFRA;
@@ -548,14 +549,14 @@ static int wlan_cmd_802_11_snmp_mib(wlan
{
u32 ulTemp;
- pSNMPMIB->OID = wlan_cpu_to_le16((u16) Dot11D_i);
+ pSNMPMIB->OID = cpu_to_le16((u16) Dot11D_i);
if (cmd_action == HostCmd_ACT_SET) {
pSNMPMIB->QueryType = HostCmd_ACT_GEN_SET;
pSNMPMIB->BufSize = sizeof(u16);
ulTemp = *(u32 *) pdata_buf;
*((unsigned short *)(pSNMPMIB->Value)) =
- wlan_cpu_to_le16((u16) ulTemp);
+ cpu_to_le16((u16) ulTemp);
}
break;
}
@@ -564,19 +565,19 @@ static int wlan_cmd_802_11_snmp_mib(wlan
{
u32 ulTemp;
- pSNMPMIB->OID = wlan_cpu_to_le16((u16) FragThresh_i);
+ pSNMPMIB->OID = cpu_to_le16((u16) FragThresh_i);
if (cmd_action == HostCmd_ACT_GET) {
pSNMPMIB->QueryType =
- wlan_cpu_to_le16(HostCmd_ACT_GEN_GET);
+ cpu_to_le16(HostCmd_ACT_GEN_GET);
} else if (cmd_action == HostCmd_ACT_SET) {
pSNMPMIB->QueryType =
- wlan_cpu_to_le16(HostCmd_ACT_GEN_SET);
+ cpu_to_le16(HostCmd_ACT_GEN_SET);
pSNMPMIB->BufSize =
- wlan_cpu_to_le16(sizeof(u16));
+ cpu_to_le16(sizeof(u16));
ulTemp = *((u32 *) pdata_buf);
*((unsigned short *)(pSNMPMIB->Value)) =
- wlan_cpu_to_le16((u16) ulTemp);
+ cpu_to_le16((u16) ulTemp);
}
@@ -587,36 +588,36 @@ static int wlan_cmd_802_11_snmp_mib(wlan
{
u32 ulTemp;
- pSNMPMIB->OID = wlan_le16_to_cpu((u16) RtsThresh_i);
+ pSNMPMIB->OID = le16_to_cpu((u16) RtsThresh_i);
if (cmd_action == HostCmd_ACT_GET) {
pSNMPMIB->QueryType =
- wlan_cpu_to_le16(HostCmd_ACT_GEN_GET);
+ cpu_to_le16(HostCmd_ACT_GEN_GET);
} else if (cmd_action == HostCmd_ACT_SET) {
pSNMPMIB->QueryType =
- wlan_cpu_to_le16(HostCmd_ACT_GEN_SET);
+ cpu_to_le16(HostCmd_ACT_GEN_SET);
pSNMPMIB->BufSize =
- wlan_cpu_to_le16(sizeof(u16));
+ cpu_to_le16(sizeof(u16));
ulTemp = *((u32 *)
pdata_buf);
*(unsigned short *)(pSNMPMIB->Value) =
- wlan_cpu_to_le16((u16) ulTemp);
+ cpu_to_le16((u16) ulTemp);
}
break;
}
case OID_802_11_TX_RETRYCOUNT:
- pSNMPMIB->OID = wlan_cpu_to_le16((u16) ShortRetryLim_i);
+ pSNMPMIB->OID = cpu_to_le16((u16) ShortRetryLim_i);
if (cmd_action == HostCmd_ACT_GET) {
pSNMPMIB->QueryType =
- wlan_cpu_to_le16(HostCmd_ACT_GEN_GET);
+ cpu_to_le16(HostCmd_ACT_GEN_GET);
} else if (cmd_action == HostCmd_ACT_SET) {
pSNMPMIB->QueryType =
- wlan_cpu_to_le16(HostCmd_ACT_GEN_SET);
- pSNMPMIB->BufSize = wlan_cpu_to_le16(sizeof(u16));
+ cpu_to_le16(HostCmd_ACT_GEN_SET);
+ pSNMPMIB->BufSize = cpu_to_le16(sizeof(u16));
*((unsigned short *)(pSNMPMIB->Value)) =
- wlan_cpu_to_le16((u16) Adapter->TxRetryCount);
+ cpu_to_le16((u16) Adapter->TxRetryCount);
}
break;
@@ -656,31 +657,31 @@ static int wlan_cmd_802_11_radio_control
ENTER();
cmd->Size =
- wlan_cpu_to_le16((sizeof(struct HostCmd_DS_802_11_RADIO_CONTROL)) +
+ cpu_to_le16((sizeof(struct HostCmd_DS_802_11_RADIO_CONTROL)) +
S_DS_GEN);
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_RADIO_CONTROL);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_RADIO_CONTROL);
- pRadioControl->Action = wlan_cpu_to_le16(cmd_action);
+ pRadioControl->Action = cpu_to_le16(cmd_action);
switch (Adapter->Preamble) {
case HostCmd_TYPE_SHORT_PREAMBLE:
- pRadioControl->Control = wlan_cpu_to_le16(SET_SHORT_PREAMBLE);
+ pRadioControl->Control = cpu_to_le16(SET_SHORT_PREAMBLE);
break;
case HostCmd_TYPE_LONG_PREAMBLE:
- pRadioControl->Control = wlan_cpu_to_le16(SET_LONG_PREAMBLE);
+ pRadioControl->Control = cpu_to_le16(SET_LONG_PREAMBLE);
break;
case HostCmd_TYPE_AUTO_PREAMBLE:
default:
- pRadioControl->Control = wlan_cpu_to_le16(SET_AUTO_PREAMBLE);
+ pRadioControl->Control = cpu_to_le16(SET_AUTO_PREAMBLE);
break;
}
if (Adapter->RadioOn)
- pRadioControl->Control |= wlan_cpu_to_le16(TURN_ON_RF);
+ pRadioControl->Control |= cpu_to_le16(TURN_ON_RF);
else
- pRadioControl->Control &= wlan_cpu_to_le16(~TURN_ON_RF);
+ pRadioControl->Control &= cpu_to_le16(~TURN_ON_RF);
LEAVE();
return WLAN_STATUS_SUCCESS;
@@ -705,9 +706,9 @@ static int wlan_cmd_802_11_rf_tx_power(w
ENTER();
cmd->Size =
- wlan_cpu_to_le16((sizeof(struct HostCmd_DS_802_11_RF_TX_POWER)) +
+ cpu_to_le16((sizeof(struct HostCmd_DS_802_11_RF_TX_POWER)) +
S_DS_GEN);
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_RF_TX_POWER);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_RF_TX_POWER);
pRTP->Action = cmd_action;
dprintk(1, "RF_TX_POWER_CMD: Size:%d Cmd:0x%x Act:%d\n", cmd->Size,
@@ -715,25 +716,25 @@ static int wlan_cmd_802_11_rf_tx_power(w
switch (cmd_action) {
case HostCmd_ACT_TX_POWER_OPT_GET:
- pRTP->Action = wlan_cpu_to_le16(HostCmd_ACT_GEN_GET);
+ pRTP->Action = cpu_to_le16(HostCmd_ACT_GEN_GET);
pRTP->CurrentLevel = 0;
break;
case HostCmd_ACT_TX_POWER_OPT_SET_HIGH:
- pRTP->Action = wlan_cpu_to_le16(HostCmd_ACT_GEN_SET);
+ pRTP->Action = cpu_to_le16(HostCmd_ACT_GEN_SET);
pRTP->CurrentLevel =
- wlan_cpu_to_le16(HostCmd_ACT_TX_POWER_INDEX_HIGH);
+ cpu_to_le16(HostCmd_ACT_TX_POWER_INDEX_HIGH);
break;
case HostCmd_ACT_TX_POWER_OPT_SET_MID:
- pRTP->Action = wlan_cpu_to_le16(HostCmd_ACT_GEN_SET);
+ pRTP->Action = cpu_to_le16(HostCmd_ACT_GEN_SET);
pRTP->CurrentLevel =
- wlan_cpu_to_le16(HostCmd_ACT_TX_POWER_INDEX_MID);
+ cpu_to_le16(HostCmd_ACT_TX_POWER_INDEX_MID);
break;
case HostCmd_ACT_TX_POWER_OPT_SET_LOW:
- pRTP->Action = wlan_cpu_to_le16(HostCmd_ACT_GEN_SET);
- pRTP->CurrentLevel = wlan_cpu_to_le16(*((u16 *) pdata_buf));
+ pRTP->Action = cpu_to_le16(HostCmd_ACT_GEN_SET);
+ pRTP->CurrentLevel = cpu_to_le16(*((u16 *) pdata_buf));
break;
}
LEAVE();
@@ -755,16 +756,16 @@ static int wlan_cmd_802_11_rf_antenna(wl
{
struct HostCmd_DS_802_11_RF_ANTENNA *rant = &cmd->params.rant;
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_RF_ANTENNA);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_RF_ANTENNA);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_RF_ANTENNA) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_RF_ANTENNA) +
S_DS_GEN);
- rant->Action = wlan_cpu_to_le16(cmd_action);
+ rant->Action = cpu_to_le16(cmd_action);
if ((cmd_action == HostCmd_ACT_SET_RX) ||
(cmd_action == HostCmd_ACT_SET_TX)) {
rant->AntennaMode =
- wlan_cpu_to_le16((u16) (*(u32 *) pdata_buf));
+ cpu_to_le16((u16) (*(u32 *) pdata_buf));
}
return WLAN_STATUS_SUCCESS;
@@ -787,9 +788,9 @@ static int wlan_cmd_802_11_rate_adapt_ra
wlan_adapter *Adapter = priv->adapter;
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_RATE_ADAPT_RATESET)
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_RATE_ADAPT_RATESET)
+ S_DS_GEN);
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_RATE_ADAPT_RATESET);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_RATE_ADAPT_RATESET);
ENTER();
@@ -820,14 +821,14 @@ static int wlan_cmd_802_11_data_rate(wla
ENTER();
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_DATA_RATE) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_DATA_RATE) +
S_DS_GEN);
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_DATA_RATE);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_DATA_RATE);
memset(pDataRate, 0, sizeof(struct HostCmd_DS_802_11_DATA_RATE));
- pDataRate->Action = wlan_cpu_to_le16(cmd_action);
+ pDataRate->Action = cpu_to_le16(cmd_action);
if (Action == HostCmd_ACT_SET_TX_FIX_RATE) {
pDataRate->DataRate[0] = libertas_data_rate_to_index(Adapter->DataRate);
@@ -857,13 +858,13 @@ static int wlan_cmd_mac_multicast_adr(wl
wlan_adapter *Adapter = priv->adapter;
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_MAC_MULTICAST_ADR) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_MAC_MULTICAST_ADR) +
S_DS_GEN);
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_MAC_MULTICAST_ADR);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_MAC_MULTICAST_ADR);
- pMCastAdr->Action = wlan_cpu_to_le16(cmd_action);
+ pMCastAdr->Action = cpu_to_le16(cmd_action);
pMCastAdr->NumOfAdrs =
- wlan_cpu_to_le16((u16) Adapter->NumOfMulticastMACAddr);
+ cpu_to_le16((u16) Adapter->NumOfMulticastMACAddr);
memcpy(pMCastAdr->MACList, Adapter->MulticastList,
Adapter->NumOfMulticastMACAddr * ETH_ALEN);
@@ -885,15 +886,15 @@ static int wlan_cmd_802_11_rf_channel(wl
{
struct HostCmd_DS_802_11_RF_CHANNEL *rfchan = &cmd->params.rfchannel;
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_RF_CHANNEL);
- cmd->Size = wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_RF_CHANNEL)
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_RF_CHANNEL);
+ cmd->Size = cpu_to_le16(sizeof(struct HostCmd_DS_802_11_RF_CHANNEL)
+ S_DS_GEN);
if (option == HostCmd_OPT_802_11_RF_CHANNEL_SET) {
- rfchan->CurrentChannel = wlan_cpu_to_le16(*((u16 *) pdata_buf));
+ rfchan->CurrentChannel = cpu_to_le16(*((u16 *) pdata_buf));
}
- rfchan->Action = wlan_cpu_to_le16(option);
+ rfchan->Action = cpu_to_le16(option);
return WLAN_STATUS_SUCCESS;
}
@@ -910,9 +911,9 @@ static int wlan_cmd_802_11_rssi(wlan_pri
{
wlan_adapter *Adapter = priv->adapter;
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_RSSI);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_RSSI);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_RSSI) + S_DS_GEN);
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_RSSI) + S_DS_GEN);
cmd->params.rssi.N = priv->adapter->bcn_avg_factor;
/* reset Beacon SNR/NF/RSSI values */
@@ -951,16 +952,16 @@ static int wlan_cmd_reg_access(wlan_priv
struct HostCmd_DS_MAC_REG_ACCESS *macreg;
CmdPtr->Size =
- wlan_cpu_to_le16(sizeof
+ cpu_to_le16(sizeof
(struct HostCmd_DS_MAC_REG_ACCESS)
+ S_DS_GEN);
macreg =
(struct HostCmd_DS_MAC_REG_ACCESS *)&CmdPtr->params.
macreg;
- macreg->Action = wlan_cpu_to_le16(cmd_action);
- macreg->Offset = wlan_cpu_to_le16((u16) offval->offset);
- macreg->Value = wlan_cpu_to_le32(offval->value);
+ macreg->Action = cpu_to_le16(cmd_action);
+ macreg->Offset = cpu_to_le16((u16) offval->offset);
+ macreg->Value = cpu_to_le32(offval->value);
break;
}
@@ -970,15 +971,15 @@ static int wlan_cmd_reg_access(wlan_priv
struct HostCmd_DS_BBP_REG_ACCESS *bbpreg;
CmdPtr->Size =
- wlan_cpu_to_le16(sizeof
+ cpu_to_le16(sizeof
(struct HostCmd_DS_BBP_REG_ACCESS)
+ S_DS_GEN);
bbpreg =
(struct HostCmd_DS_BBP_REG_ACCESS *)&CmdPtr->params.
bbpreg;
- bbpreg->Action = wlan_cpu_to_le16(cmd_action);
- bbpreg->Offset = wlan_cpu_to_le16((u16) offval->offset);
+ bbpreg->Action = cpu_to_le16(cmd_action);
+ bbpreg->Offset = cpu_to_le16((u16) offval->offset);
bbpreg->Value = (u8) offval->value;
break;
@@ -989,15 +990,15 @@ static int wlan_cmd_reg_access(wlan_priv
struct HostCmd_DS_RF_REG_ACCESS *rfreg;
CmdPtr->Size =
- wlan_cpu_to_le16(sizeof
+ cpu_to_le16(sizeof
(struct HostCmd_DS_RF_REG_ACCESS) +
S_DS_GEN);
rfreg =
(struct HostCmd_DS_RF_REG_ACCESS *)&CmdPtr->params.
rfreg;
- rfreg->Action = wlan_cpu_to_le16(cmd_action);
- rfreg->Offset = wlan_cpu_to_le16((u16) offval->offset);
+ rfreg->Action = cpu_to_le16(cmd_action);
+ rfreg->Offset = cpu_to_le16((u16) offval->offset);
rfreg->Value = (u8) offval->value;
break;
@@ -1025,13 +1026,13 @@ static int wlan_cmd_802_11_mac_address(w
{
wlan_adapter *Adapter = priv->adapter;
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_MAC_ADDRESS);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_MAC_ADDRESS);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_MAC_ADDRESS) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_MAC_ADDRESS) +
S_DS_GEN);
cmd->Result = 0;
- cmd->params.macadd.Action = wlan_cpu_to_le16(cmd_action);
+ cmd->params.macadd.Action = cpu_to_le16(cmd_action);
if (cmd_action == HostCmd_ACT_SET) {
memcpy(cmd->params.macadd.MacAdd,
@@ -1059,22 +1060,22 @@ static int wlan_cmd_802_11_eeprom_access
ENTER();
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_EEPROM_ACCESS);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_EEPROM_ACCESS);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_EEPROM_ACCESS) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_EEPROM_ACCESS) +
S_DS_GEN);
cmd->Result = 0;
- cmd->params.rdeeprom.Action = wlan_cpu_to_le16(ea->Action);
- cmd->params.rdeeprom.Offset = wlan_cpu_to_le16(ea->Offset);
- cmd->params.rdeeprom.ByteCount = wlan_cpu_to_le16(ea->NOB);
+ cmd->params.rdeeprom.Action = cpu_to_le16(ea->Action);
+ cmd->params.rdeeprom.Offset = cpu_to_le16(ea->Offset);
+ cmd->params.rdeeprom.ByteCount = cpu_to_le16(ea->NOB);
cmd->params.rdeeprom.Value = 0;
return WLAN_STATUS_SUCCESS;
}
-/**
- * @brief This function prepares command of DFT access.
+/**
+ * @brief This function prepares command of BT access.
*
* @param priv A pointer to wlan_private structure
* @param cmd A pointer to HostCmd_DS_COMMAND structure
@@ -1082,50 +1083,97 @@ static int wlan_cmd_802_11_eeprom_access
* @param pdata_buf A pointer to data buffer
* @return WLAN_STATUS_SUCCESS or WLAN_STATUS_FAILURE
*/
-static int wlan_cmd_dft_access(wlan_private * priv,
+static int wlan_cmd_bt_access(wlan_private * priv,
struct HostCmd_DS_COMMAND *cmd,
u16 cmd_action, void *pdata_buf)
{
- struct HostCmd_DS_DFT_ACCESS *dft_access = &cmd->params.dft;
- dprintk(1, "DFT CMD(%d)\n", cmd_action);
+ struct HostCmd_DS_BT_ACCESS *bt_access = &cmd->params.bt;
+ dprintk(1, "BT CMD(%d)\n", cmd_action);
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_DFT_ACCESS);
- cmd->Size = wlan_cpu_to_le16(sizeof(struct HostCmd_DS_DFT_ACCESS)
+ cmd->Command = cpu_to_le16(HostCmd_CMD_BT_ACCESS);
+ cmd->Size = cpu_to_le16(sizeof(struct HostCmd_DS_BT_ACCESS)
+ S_DS_GEN);
cmd->Result = 0;
- dft_access->action = wlan_cpu_to_le16(cmd_action);
+ bt_access->action = cpu_to_le16(cmd_action);
switch (cmd_action) {
- case HostCmd_ACT_DFT_ACCESS_ADD:
- memcpy(dft_access->addr1, pdata_buf, 2 * ETH_ALEN);
- HEXDUMP("DFT_ADD: index mac address-", dft_access->addr1, 6);
- HEXDUMP("DFT_ADD: yield mac address-", dft_access->addr2, 6);
- break;
- case HostCmd_ACT_DFT_ACCESS_DEL:
- memcpy(dft_access->addr1, pdata_buf, 1 * ETH_ALEN);
- HEXDUMP("DFT_DEL: index mac address-", dft_access->addr1, 6);
- break;
- case HostCmd_ACT_DFT_ACCESS_LIST:
- dft_access->id = wlan_cpu_to_le32(*(u32 *) pdata_buf);
- break;
- case HostCmd_ACT_DFT_ACCESS_RESET:
- break;
case HostCmd_ACT_BT_ACCESS_ADD:
- memcpy(dft_access->addr1, pdata_buf, 2 * ETH_ALEN);
- HEXDUMP("BT_ADD: blinded mac address-", dft_access->addr1, 6);
+ memcpy(bt_access->addr1, pdata_buf, 2 * ETH_ALEN);
+ HEXDUMP("BT_ADD: blinded mac address-", bt_access->addr1, 6);
break;
case HostCmd_ACT_BT_ACCESS_DEL:
- memcpy(dft_access->addr1, pdata_buf, 1 * ETH_ALEN);
- HEXDUMP("BT_DEL: blinded mac address-", dft_access->addr1, 6);
+ memcpy(bt_access->addr1, pdata_buf, 1 * ETH_ALEN);
+ HEXDUMP("BT_DEL: blinded mac address-", bt_access->addr1, 6);
break;
case HostCmd_ACT_BT_ACCESS_LIST:
- dft_access->id = wlan_cpu_to_le32(*(u32 *) pdata_buf);
+ bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
break;
case HostCmd_ACT_BT_ACCESS_RESET:
break;
default:
break;
}
+ return WLAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief This function prepares command of FWT access.
+ *
+ * @param priv A pointer to wlan_private structure
+ * @param cmd A pointer to HostCmd_DS_COMMAND structure
+ * @param cmd_action the action: ADD, DEL, LOOKUP, LIST, LIST_ROUTE, LIST_NEIGHBOR, or RESET
+ * @param pdata_buf A pointer to data buffer
+ * @return WLAN_STATUS_SUCCESS or WLAN_STATUS_FAILURE
+ */
+static int wlan_cmd_fwt_access(wlan_private * priv,
+ struct HostCmd_DS_COMMAND *cmd,
+ u16 cmd_action, void *pdata_buf)
+{
+ struct HostCmd_DS_FWT_ACCESS *fwt_access = &cmd->params.fwt;
+ dprintk(1, "FWT CMD(%d)\n", cmd_action);
+
+ cmd->Command = cpu_to_le16(HostCmd_CMD_FWT_ACCESS);
+ cmd->Size = cpu_to_le16(sizeof(struct HostCmd_DS_FWT_ACCESS)
+ + S_DS_GEN);
+ cmd->Result = 0;
+
+ if (pdata_buf)
+ memcpy(fwt_access, pdata_buf, sizeof(*fwt_access));
+ else
+ memset(fwt_access, 0, sizeof(*fwt_access));
+
+ fwt_access->action = cpu_to_le16(cmd_action);
+
+ return WLAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief This function prepares command of MESH access.
+ *
+ * @param priv A pointer to wlan_private structure
+ * @param cmd A pointer to HostCmd_DS_COMMAND structure
+ * @param cmd_action the action: TTL is the only currently supported command
+ * @param pdata_buf A pointer to data buffer
+ * @return WLAN_STATUS_SUCCESS or WLAN_STATUS_FAILURE
+ */
+static int wlan_cmd_mesh_access(wlan_private * priv,
+ struct HostCmd_DS_COMMAND *cmd,
+ u16 cmd_action, void *pdata_buf)
+{
+ struct HostCmd_DS_MESH_ACCESS *mesh_access = &cmd->params.mesh;
+ dprintk(1, "FWT CMD(%d)\n", cmd_action);
+
+ cmd->Command = cpu_to_le16(HostCmd_CMD_MESH_ACCESS);
+ cmd->Size = cpu_to_le16(sizeof(struct HostCmd_DS_MESH_ACCESS)
+ + S_DS_GEN);
+ cmd->Result = 0;
+
+ if (pdata_buf)
+ memcpy(mesh_access, pdata_buf, sizeof(*mesh_access));
+ else
+ memset(mesh_access, 0, sizeof(*mesh_access));
+
+ mesh_access->action = cpu_to_le16(cmd_action);
return WLAN_STATUS_SUCCESS;
}
@@ -1244,10 +1292,10 @@ static int DownloadCommandToStation(wlan
CmdSize = CmdPtr->Size;
- Command = wlan_cpu_to_le16(CmdPtr->Command);
+ Command = cpu_to_le16(CmdPtr->Command);
CmdNode->CmdWaitQWoken = 0;
- CmdSize = wlan_cpu_to_le16(CmdSize);
+ CmdSize = cpu_to_le16(CmdSize);
ret = libertas_sbi_host_to_card(priv, MVMS_CMD, (u8 *) CmdPtr, CmdSize);
@@ -1293,10 +1341,10 @@ static int wlan_cmd_mac_control(wlan_pri
ENTER();
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_MAC_CONTROL);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_MAC_CONTROL);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_MAC_CONTROL) + S_DS_GEN);
- mac->Action = wlan_cpu_to_le16(priv->adapter->CurrentPacketFilter);
+ cpu_to_le16(sizeof(struct HostCmd_DS_MAC_CONTROL) + S_DS_GEN);
+ mac->Action = cpu_to_le16(priv->adapter->CurrentPacketFilter);
dprintk(1, "wlan_cmd_mac_control(): Action=0x%X Size=%d\n",
mac->Action, cmd->Size);
@@ -1424,7 +1472,7 @@ int libertas_prepare_and_send_command(wl
CmdNode = libertas_get_free_cmd_ctrl_node(priv);
if (CmdNode == NULL) {
- printk(KERN_ALERT "PREP_CMD: No free CmdNode\n");
+ dprintk(1, "PREP_CMD: No free CmdNode\n");
/* Wake up main thread to execute next command */
wake_up_interruptible(&priv->MainThread.waitQ);
@@ -1440,7 +1488,7 @@ int libertas_prepare_and_send_command(wl
(u32) CmdPtr, cmd_no);
if (!CmdPtr) {
- printk(KERN_ALERT "PREP_CMD: BufVirtualAddr of CmdNode is NULL\n");
+ dprintk(1, "PREP_CMD: BufVirtualAddr of CmdNode is NULL\n");
libertas_cleanup_and_insert_cmd(priv, CmdNode);
ret = WLAN_STATUS_FAILURE;
goto done;
@@ -1448,7 +1496,7 @@ int libertas_prepare_and_send_command(wl
/* Set sequence number, command and INT option */
Adapter->SeqNum++;
- CmdPtr->SeqNum = wlan_cpu_to_le16(Adapter->SeqNum);
+ CmdPtr->SeqNum = cpu_to_le16(Adapter->SeqNum);
CmdPtr->Command = cmd_no;
CmdPtr->Result = 0;
@@ -1585,9 +1633,9 @@ int libertas_prepare_and_send_command(wl
case HostCmd_CMD_802_11_SET_AFC:
case HostCmd_CMD_802_11_GET_AFC:
- CmdPtr->Command = wlan_cpu_to_le16(cmd_no);
+ CmdPtr->Command = cpu_to_le16(cmd_no);
CmdPtr->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_AFC) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_AFC) +
S_DS_GEN);
memmove(&CmdPtr->params.afc,
@@ -1611,9 +1659,9 @@ int libertas_prepare_and_send_command(wl
break;
case HostCmd_CMD_802_11_TPC_CFG:
- CmdPtr->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_TPC_CFG);
+ CmdPtr->Command = cpu_to_le16(HostCmd_CMD_802_11_TPC_CFG);
CmdPtr->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_TPC_CFG) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_TPC_CFG) +
S_DS_GEN);
memmove(&CmdPtr->params.tpccfg,
@@ -1632,21 +1680,21 @@ int libertas_prepare_and_send_command(wl
sizeof(struct HostCmd_DS_802_11_LED_CTRL));
CmdPtr->Command =
- wlan_cpu_to_le16(HostCmd_CMD_802_11_LED_GPIO_CTRL);
+ cpu_to_le16(HostCmd_CMD_802_11_LED_GPIO_CTRL);
#define ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN 8
CmdPtr->Size =
- wlan_cpu_to_le16(gpio->Header.Len + S_DS_GEN +
+ cpu_to_le16(gpio->Header.Len + S_DS_GEN +
ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN);
- gpio->Header.Len = wlan_cpu_to_le16(gpio->Header.Len);
+ gpio->Header.Len = cpu_to_le16(gpio->Header.Len);
ret = WLAN_STATUS_SUCCESS;
break;
}
case HostCmd_CMD_802_11_PWR_CFG:
- CmdPtr->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_PWR_CFG);
+ CmdPtr->Command = cpu_to_le16(HostCmd_CMD_802_11_PWR_CFG);
CmdPtr->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_PWR_CFG) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_PWR_CFG) +
S_DS_GEN);
memmove(&CmdPtr->params.pwrcfg, pdata_buf,
sizeof(struct HostCmd_DS_802_11_PWR_CFG));
@@ -1658,22 +1706,30 @@ #define ACTION_NUMLED_TLVTYPE_LEN_FIELDS
cmd_action, pdata_buf);
break;
- case HostCmd_CMD_DFT_ACCESS:
- ret = wlan_cmd_dft_access(priv, CmdPtr, cmd_action, pdata_buf);
+ case HostCmd_CMD_BT_ACCESS:
+ ret = wlan_cmd_bt_access(priv, CmdPtr, cmd_action, pdata_buf);
+ break;
+
+ case HostCmd_CMD_FWT_ACCESS:
+ ret = wlan_cmd_fwt_access(priv, CmdPtr, cmd_action, pdata_buf);
+ break;
+
+ case HostCmd_CMD_MESH_ACCESS:
+ ret = wlan_cmd_mesh_access(priv, CmdPtr, cmd_action, pdata_buf);
break;
case HostCmd_CMD_GET_TSF:
- CmdPtr->Command = wlan_cpu_to_le16(HostCmd_CMD_GET_TSF);
+ CmdPtr->Command = cpu_to_le16(HostCmd_CMD_GET_TSF);
CmdPtr->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_GET_TSF)
+ cpu_to_le16(sizeof(struct HostCmd_DS_GET_TSF)
+ S_DS_GEN);
ret = WLAN_STATUS_SUCCESS;
break;
case HostCmd_CMD_802_11_TX_RATE_QUERY:
CmdPtr->Command =
- wlan_cpu_to_le16(HostCmd_CMD_802_11_TX_RATE_QUERY);
+ cpu_to_le16(HostCmd_CMD_802_11_TX_RATE_QUERY);
CmdPtr->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_TX_RATE_QUERY) +
+ cpu_to_le16(sizeof(struct HostCmd_TX_RATE_QUERY) +
S_DS_GEN);
Adapter->TxRate = 0;
ret = WLAN_STATUS_SUCCESS;
@@ -1986,7 +2042,7 @@ int libertas_execute_next_command(wlan_p
* immediately.
*/
if (CmdPtr->Command !=
- wlan_cpu_to_le16(HostCmd_CMD_802_11_PS_MODE)) {
+ cpu_to_le16(HostCmd_CMD_802_11_PS_MODE)) {
/* Prepare to send Exit PS,
* this non PS command will be sent later */
if ((Adapter->PSState == PS_STATE_SLEEP)
@@ -2012,7 +2068,7 @@ int libertas_execute_next_command(wlan_p
"EXEC_NEXT_CMD: PS cmd- Action=0x%x\n",
psm->Action);
if (psm->Action !=
- wlan_cpu_to_le16(HostCmd_SubCmd_Exit_PS)) {
+ cpu_to_le16(HostCmd_SubCmd_Exit_PS)) {
dprintk(1,
"EXEC_NEXT_CMD: Ignore Enter PS cmd\n");
list_del((struct list_head *)CmdNode);
diff --git a/drivers/net/wireless/libertas/wlan_cmdresp.c b/drivers/net/wireless/libertas/wlan_cmdresp.c
index 6a25248..f5c8e60 100644
--- a/drivers/net/wireless/libertas/wlan_cmdresp.c
+++ b/drivers/net/wireless/libertas/wlan_cmdresp.c
@@ -34,6 +34,7 @@ Change log:
04/18/06: Remove old Subscrive Event and add new Subscribe Event
implementation through generic hostcmd API
05/08/06: Remove Adapter->PermanentAddr memcpy
+ 06/27/06: Remove dft features. Replaced by fwt.
********************************************************/
#include <linux/delay.h>
@@ -267,7 +268,7 @@ static int wlan_ret_get_hw_spec(wlan_pri
ENTER();
Adapter->HardwareStatus = WlanHardwareStatusReady;
- Adapter->fwCapInfo = wlan_le32_to_cpu(hwspec->fwCapInfo);
+ Adapter->fwCapInfo = le32_to_cpu(hwspec->fwCapInfo);
Adapter->FWReleaseNumber = hwspec->FWReleaseNumber;
@@ -280,7 +281,7 @@ static int wlan_ret_get_hw_spec(wlan_pri
dprintk(1, "GET_HW_SPEC: HWIfVersion=0x%X Version=0x%X\n",
hwspec->HWIfVersion, hwspec->Version);
- Adapter->RegionCode = wlan_le16_to_cpu(hwspec->RegionCode);
+ Adapter->RegionCode = le16_to_cpu(hwspec->RegionCode);
for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
/* use the region code to search for the index */
@@ -304,6 +305,7 @@ static int wlan_ret_get_hw_spec(wlan_pri
}
memcpy(priv->wlan_dev.netdev->dev_addr, Adapter->CurrentAddr, ETH_ALEN);
+ memcpy(priv->mesh_dev->dev_addr, Adapter->CurrentAddr, ETH_ALEN);
if (libertas_set_regiontable(priv, Adapter->RegionCode, 0)) {
ret = WLAN_STATUS_FAILURE;
@@ -338,12 +340,12 @@ static int wlan_ret_802_11_sleep_params(
dprintk(1, "error=%x offset=%x stabletime=%x calcontrol=%x\n"
" extsleepclk=%x\n", sp->Error, sp->Offset,
sp->StableTime, sp->CalControl, sp->ExternalSleepClk);
- Adapter->sp.sp_error = wlan_le16_to_cpu(sp->Error);
- Adapter->sp.sp_offset = wlan_le16_to_cpu(sp->Offset);
- Adapter->sp.sp_stabletime = wlan_le16_to_cpu(sp->StableTime);
- Adapter->sp.sp_calcontrol = wlan_le16_to_cpu(sp->CalControl);
- Adapter->sp.sp_extsleepclk = wlan_le16_to_cpu(sp->ExternalSleepClk);
- Adapter->sp.sp_reserved = wlan_le16_to_cpu(sp->Reserved);
+ Adapter->sp.sp_error = le16_to_cpu(sp->Error);
+ Adapter->sp.sp_offset = le16_to_cpu(sp->Offset);
+ Adapter->sp.sp_stabletime = le16_to_cpu(sp->StableTime);
+ Adapter->sp.sp_calcontrol = le16_to_cpu(sp->CalControl);
+ Adapter->sp.sp_extsleepclk = le16_to_cpu(sp->ExternalSleepClk);
+ Adapter->sp.sp_reserved = le16_to_cpu(sp->Reserved);
LEAVE();
return WLAN_STATUS_SUCCESS;
@@ -365,7 +367,7 @@ static int wlan_ret_802_11_sleep_period(
ENTER();
- Adapter->sleep_period.period = wlan_le16_to_cpu(sp_period->Period);
+ Adapter->sleep_period.period = le16_to_cpu(sp_period->Period);
LEAVE();
return WLAN_STATUS_SUCCESS;
@@ -446,35 +448,35 @@ static int wlan_ret_802_11_snmp_mib(wlan
struct HostCmd_DS_COMMAND *resp)
{
struct HostCmd_DS_802_11_SNMP_MIB *smib = &resp->params.smib;
- u16 OID = wlan_le16_to_cpu(smib->OID);
- u16 QueryType = wlan_le16_to_cpu(smib->QueryType);
+ u16 OID = le16_to_cpu(smib->OID);
+ u16 QueryType = le16_to_cpu(smib->QueryType);
ENTER();
dprintk(1, "SNMP_RESP: value of the OID = %x, QueryType=%x\n", OID,
QueryType);
dprintk(1, "SNMP_RESP: Buf size = %x\n",
- wlan_le16_to_cpu(smib->BufSize));
+ le16_to_cpu(smib->BufSize));
if (QueryType == HostCmd_ACT_GEN_GET) {
switch (OID) {
case FragThresh_i:
priv->adapter->FragThsd =
- wlan_le16_to_cpu(*
+ le16_to_cpu(*
((unsigned short *)(smib->Value)));
dprintk(1, "SNMP_RESP: FragThsd =%u\n",
priv->adapter->FragThsd);
break;
case RtsThresh_i:
priv->adapter->RTSThsd =
- wlan_le16_to_cpu(*
+ le16_to_cpu(*
((unsigned short *)(smib->Value)));
dprintk(1, "SNMP_RESP: RTSThsd =%u\n",
priv->adapter->RTSThsd);
break;
case ShortRetryLim_i:
priv->adapter->TxRetryCount =
- wlan_le16_to_cpu(*
+ le16_to_cpu(*
((unsigned short *)(smib->Value)));
dprintk(1, "SNMP_RESP: TxRetryCount =%u\n",
priv->adapter->RTSThsd);
@@ -517,23 +519,23 @@ static int wlan_ret_802_11_key_material(
struct HostCmd_DS_802_11_KEY_MATERIAL *pKeyMaterial =
&resp->params.keymaterial;
wlan_adapter *adapter = priv->adapter;
- u16 action = wlan_le16_to_cpu(pKeyMaterial->Action);
+ u16 action = le16_to_cpu(pKeyMaterial->Action);
ENTER();
/* Copy the returned key to driver private data */
if (action == HostCmd_ACT_GET) {
u8 * buf_ptr = (u8 *) &pKeyMaterial->KeyParamSet;
- u8 * resp_end = (u8 *) (resp + wlan_le16_to_cpu(resp->Size));
+ u8 * resp_end = (u8 *) (resp + le16_to_cpu(resp->Size));
while (buf_ptr < resp_end) {
struct MrvlIEtype_KeyParamSet * pKeyParamSet =
(struct MrvlIEtype_KeyParamSet *) buf_ptr;
struct WLAN_802_11_KEY * pKey;
- u16 key_info = wlan_le16_to_cpu(pKeyParamSet->KeyInfo);
- u16 param_set_len = wlan_le16_to_cpu(pKeyParamSet->Length);
+ u16 key_info = le16_to_cpu(pKeyParamSet->KeyInfo);
+ u16 param_set_len = le16_to_cpu(pKeyParamSet->Length);
u8 * end;
- u16 key_len = wlan_le16_to_cpu(pKeyParamSet->KeyLen);
+ u16 key_len = le16_to_cpu(pKeyParamSet->KeyLen);
end = (u8 *) pKeyParamSet + sizeof (pKeyParamSet->Type)
+ sizeof (pKeyParamSet->Length)
@@ -553,9 +555,9 @@ static int wlan_ret_802_11_key_material(
memset(pKey, 0, sizeof(struct WLAN_802_11_KEY));
if (key_len > sizeof(pKey->key))
break;
- pKey->type = wlan_le16_to_cpu(pKeyParamSet->KeyTypeId);
- pKey->flags = wlan_le16_to_cpu(pKeyParamSet->KeyInfo);
- pKey->len = wlan_le16_to_cpu(pKeyParamSet->KeyLen);
+ pKey->type = le16_to_cpu(pKeyParamSet->KeyTypeId);
+ pKey->flags = le16_to_cpu(pKeyParamSet->KeyInfo);
+ pKey->len = le16_to_cpu(pKeyParamSet->KeyLen);
memcpy(pKey->key, pKeyParamSet->Key, pKey->len);
buf_ptr = end + 1;
@@ -602,7 +604,7 @@ static int wlan_ret_802_11_rf_tx_power(w
ENTER();
- Adapter->TxPowerLevel = wlan_le16_to_cpu(rtp->CurrentLevel);
+ Adapter->TxPowerLevel = le16_to_cpu(rtp->CurrentLevel);
dprintk(1, "Current TxPower Level = %d\n", Adapter->TxPowerLevel);
@@ -622,18 +624,18 @@ static int wlan_ret_802_11_rf_antenna(wl
{
struct HostCmd_DS_802_11_RF_ANTENNA *pAntenna = &resp->params.rant;
wlan_adapter *Adapter = priv->adapter;
- u16 Action = wlan_le16_to_cpu(pAntenna->Action);
+ u16 Action = le16_to_cpu(pAntenna->Action);
if (Action == HostCmd_ACT_GET_RX)
Adapter->RxAntennaMode =
- wlan_le16_to_cpu(pAntenna->AntennaMode);
+ le16_to_cpu(pAntenna->AntennaMode);
if (Action == HostCmd_ACT_GET_TX)
Adapter->TxAntennaMode =
- wlan_le16_to_cpu(pAntenna->AntennaMode);
+ le16_to_cpu(pAntenna->AntennaMode);
dprintk(1, "RF_ANT_RESP: Action = 0x%x, Mode = 0x%04x\n",
- Action, wlan_le16_to_cpu(pAntenna->AntennaMode));
+ Action, le16_to_cpu(pAntenna->AntennaMode));
return WLAN_STATUS_SUCCESS;
}
@@ -720,8 +722,8 @@ static int wlan_ret_802_11_rf_channel(wl
struct HostCmd_DS_802_11_RF_CHANNEL *rfchannel =
&resp->params.rfchannel;
wlan_adapter *Adapter = priv->adapter;
- u16 Action = wlan_le16_to_cpu(rfchannel->Action);
- u16 newChannel = wlan_le16_to_cpu(rfchannel->CurrentChannel);
+ u16 Action = le16_to_cpu(rfchannel->Action);
+ u16 newChannel = le16_to_cpu(rfchannel->CurrentChannel);
ENTER();
@@ -752,13 +754,13 @@ static int wlan_ret_802_11_rssi(wlan_pri
wlan_adapter *Adapter = priv->adapter;
/* store the non average value */
- Adapter->SNR[TYPE_BEACON][TYPE_NOAVG] = wlan_le16_to_cpu(rssirsp->SNR);
+ Adapter->SNR[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->SNR);
Adapter->NF[TYPE_BEACON][TYPE_NOAVG] =
- wlan_le16_to_cpu(rssirsp->NoiseFloor);
+ le16_to_cpu(rssirsp->NoiseFloor);
- Adapter->SNR[TYPE_BEACON][TYPE_AVG] = wlan_le16_to_cpu(rssirsp->AvgSNR);
+ Adapter->SNR[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->AvgSNR);
Adapter->NF[TYPE_BEACON][TYPE_AVG] =
- wlan_le16_to_cpu(rssirsp->AvgNoiseFloor);
+ le16_to_cpu(rssirsp->AvgNoiseFloor);
Adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] =
CAL_RSSI(Adapter->SNR[TYPE_BEACON][TYPE_NOAVG],
@@ -787,19 +789,19 @@ static int wlan_ret_802_11_eeprom_access
wlan_adapter *Adapter = priv->adapter;
wlan_ioctl_regrdwr *pBuf = (wlan_ioctl_regrdwr *) Adapter->pRdeeprom;
dprintk(1, "eeprom read len=%x\n",
- wlan_le16_to_cpu(resp->params.rdeeprom.ByteCount));
- if (pBuf->NOB < wlan_le16_to_cpu(resp->params.rdeeprom.ByteCount)) {
+ le16_to_cpu(resp->params.rdeeprom.ByteCount));
+ if (pBuf->NOB < le16_to_cpu(resp->params.rdeeprom.ByteCount)) {
pBuf->NOB = 0;
dprintk(1, "eeprom read return length is too big\n");
return WLAN_STATUS_FAILURE;
}
- pBuf->NOB = wlan_le16_to_cpu(resp->params.rdeeprom.ByteCount);
+ pBuf->NOB = le16_to_cpu(resp->params.rdeeprom.ByteCount);
if (pBuf->NOB > 0) {
memcpy(&pBuf->Value, (u8 *) & resp->params.rdeeprom.Value,
- wlan_le16_to_cpu(resp->params.rdeeprom.ByteCount));
+ le16_to_cpu(resp->params.rdeeprom.ByteCount));
HEXDUMP("Adapter", (char *)&pBuf->Value,
- wlan_le16_to_cpu(resp->params.rdeeprom.ByteCount));
+ le16_to_cpu(resp->params.rdeeprom.ByteCount));
}
return WLAN_STATUS_SUCCESS;
}
@@ -864,9 +866,9 @@ int libertas_process_rx_command(wlan_pri
HEXDUMP("CMD_RESP:", Adapter->CurCmd->BufVirtualAddr,
priv->wlan_dev.upld_len);
- RespCmd = wlan_le16_to_cpu(resp->Command);
+ RespCmd = le16_to_cpu(resp->Command);
- Result = wlan_le16_to_cpu(resp->Result);
+ Result = le16_to_cpu(resp->Result);
dprintk(1, "CMD_RESP: %x Result: %d Length: %d\n", RespCmd,
Result, priv->wlan_dev.upld_len);
@@ -882,7 +884,7 @@ int libertas_process_rx_command(wlan_pri
}
/* Store the response code to CurCmdRetCode. */
- Adapter->CurCmdRetCode = wlan_le16_to_cpu(resp->Result);
+ Adapter->CurCmdRetCode = le16_to_cpu(resp->Result);
if (RespCmd == HostCmd_RET_802_11_PS_MODE) {
struct HostCmd_DS_802_11_PS_MODE *psmode;
@@ -891,7 +893,7 @@ int libertas_process_rx_command(wlan_pri
dprintk(1,
"CMD_RESP: PS_MODE cmd reply result=%#x action=0x%X\n",
resp->Result, psmode->Action);
- psmode->Action = wlan_cpu_to_le16(psmode->Action);
+ psmode->Action = cpu_to_le16(psmode->Action);
if (Result) {
dprintk(1, "CMD_RESP: PS command failed- %#x \n",
@@ -1105,7 +1107,7 @@ int libertas_process_rx_command(wlan_pri
case HostCmd_RET_802_11_INACTIVITY_TIMEOUT:
spin_lock_irqsave(&Adapter->driver_lock, flags);
*((u16 *) Adapter->CurCmd->pdata_buf) =
- wlan_le16_to_cpu(resp->params.inactivity_timeout.Timeout);
+ le16_to_cpu(resp->params.inactivity_timeout.Timeout);
spin_unlock_irqrestore(&Adapter->driver_lock, flags);
break;
@@ -1141,14 +1143,27 @@ int libertas_process_rx_command(wlan_pri
&resp->params.gettsf.TsfValue, sizeof(u64));
spin_unlock_irqrestore(&Adapter->driver_lock, flags);
break;
- case HostCmd_RET_DFT_ACCESS:
+ case HostCmd_RET_BT_ACCESS:
spin_lock_irqsave(&Adapter->driver_lock, flags);
if (Adapter->CurCmd->pdata_buf)
memcpy(Adapter->CurCmd->pdata_buf,
- &resp->params.dft.addr1, 2 * ETH_ALEN);
-
+ &resp->params.bt.addr1, 2 * ETH_ALEN);
spin_unlock_irqrestore(&Adapter->driver_lock, flags);
break;
+ case HostCmd_RET_FWT_ACCESS:
+ spin_lock_irqsave(&Adapter->driver_lock, flags);
+ if (Adapter->CurCmd->pdata_buf)
+ memcpy(Adapter->CurCmd->pdata_buf,
+ &resp->params.fwt,
+ sizeof(resp->params.fwt));
+ spin_unlock_irqrestore(&Adapter->driver_lock, flags);
+ break;
+ case HostCmd_RET_MESH_ACCESS:
+ if (Adapter->CurCmd->pdata_buf)
+ memcpy(Adapter->CurCmd->pdata_buf,
+ &resp->params.mesh,
+ sizeof(resp->params.mesh));
+ break;
case HostCmd_RTE_802_11_TX_RATE_QUERY:
priv->adapter->TxRate = resp->params.txrate.TxRate;
break;
diff --git a/drivers/net/wireless/libertas/wlan_defs.h b/drivers/net/wireless/libertas/wlan_defs.h
index 8b765ed..acaac10 100644
--- a/drivers/net/wireless/libertas/wlan_defs.h
+++ b/drivers/net/wireless/libertas/wlan_defs.h
@@ -202,6 +202,13 @@ #define MRVDRV_TxPD_POWER_MGMT_LAST_PACK
#define MRVDRV_TX_CTRL_NODE_STATUS_IDLE 0x0000
+/** Tx mesh flag */
+/* Currently we are using normal WDS flag as mesh flag.
+ * TODO: change to proper mesh flag when MAC understands it.
+ */
+#define TxPD_CONTROL_WDS_FRAME (1<<17)
+#define TxPD_MESH_FRAME TxPD_CONTROL_WDS_FRAME
+
/** RxPD Status */
#define MRVDRV_RXPD_STATUS_OK 0x0001
@@ -210,6 +217,12 @@ #define MRVDRV_RXPD_STATUS_MULTICAST_RX
/** RxPD Status - Received packet types */
#define MRVDRV_RXPD_STATUS_MAXTYPES_RX 6
+/** Rx mesh flag */
+/* Currently we are using normal WDS flag as mesh flag.
+ * TODO: change to proper mesh flag when MAC understands it.
+ */
+#define RxPD_CONTROL_WDS_FRAME (0x40)
+#define RxPD_MESH_FRAME RxPD_CONTROL_WDS_FRAME
/* Link spped */
#define MRVDRV_LINK_SPEED_1mbps 10000 /* in unit of 100bps */
@@ -328,14 +341,11 @@ #define SWAP_U8(a,b) {u8 t; t=a; a=b; b=
/* SWAP: swap u8 */
#define SWAP_U16(a,b) {u16 t; t=a; a=b; b=t;}
-#define wlan_le16_to_cpu(x) x
-#define wlan_le32_to_cpu(x) x
-#define wlan_le64_to_cpu(x) x
-#define wlan_cpu_to_le16(x) x
-#define wlan_cpu_to_le32(x) x
-#define wlan_cpu_to_le64(x) x
+#define IS_MESH_FRAME(x) (x->cb[6])
+#define SET_MESH_FRAME(x) (x->cb[6]=1)
+#define UNSET_MESH_FRAME(x) (x->cb[6]=0)
-/** Global Varibale Declaration */
+/** Global Variable Declaration */
typedef struct _wlan_private wlan_private;
typedef struct _wlan_adapter wlan_adapter;
extern const char libertas_driver_version[];
@@ -525,4 +535,15 @@ enum SNMP_MIB_VALUE_e {
SNMP_MIB_VALUE_ADHOC
};
+/* Default values for fwt commands. */
+#define FWT_DEFAULT_METRIC 0
+#define FWT_DEFAULT_DIR 1
+#define FWT_DEFAULT_SSN 0
+#define FWT_DEFAULT_DSN 0
+#define FWT_DEFAULT_HOPCOUNT 0
+#define FWT_DEFAULT_TTL 0
+#define FWT_DEFAULT_EXPIRATION 0
+#define FWT_DEFAULT_SLEEPMODE 0
+#define FWT_DEFAULT_SNR 0
+
#endif /* _WLAN_DEFS_H_ */
diff --git a/drivers/net/wireless/libertas/wlan_dev.h b/drivers/net/wireless/libertas/wlan_dev.h
index 8732520..0d83c8c 100644
--- a/drivers/net/wireless/libertas/wlan_dev.h
+++ b/drivers/net/wireless/libertas/wlan_dev.h
@@ -159,16 +159,31 @@ typedef struct _wlan_dev {
u8 dnld_sent;
} wlan_dev_t, *pwlan_dev_t;
+/* Mesh statistics */
+struct wlan_mesh_stats {
+ u32 fwd_bcast_cnt; /* Fwd: Broadcast counter */
+ u32 fwd_unicast_cnt; /* Fwd: Unicast counter */
+ u32 fwd_drop_ttl; /* Fwd: TTL zero */
+ u32 fwd_drop_rbt; /* Fwd: Recently Broadcasted */
+ u32 fwd_drop_noroute; /* Fwd: No route to Destination */
+ u32 fwd_drop_nobuf; /* Fwd: Run out of internal buffers */
+ u32 drop_blind; /* Rx: Dropped by blinding table */
+};
+
/** Private structure for the MV device */
struct _wlan_private {
int open;
+ int mesh_open;
+ int infra_open;
wlan_adapter *adapter;
wlan_dev_t wlan_dev;
struct net_device_stats stats;
+ struct net_device *mesh_dev ; /* Virtual device */
struct iw_statistics wstats;
+ struct wlan_mesh_stats mstats;
struct dentry *debugfs_dir;
struct dentry *debugfs_devinfo;
struct dentry *debugfs_debug;
diff --git a/drivers/net/wireless/libertas/wlan_ethtool.c b/drivers/net/wireless/libertas/wlan_ethtool.c
index d13dbc8..0d7cde6 100644
--- a/drivers/net/wireless/libertas/wlan_ethtool.c
+++ b/drivers/net/wireless/libertas/wlan_ethtool.c
@@ -10,6 +10,15 @@ #include "wlan_defs.h"
#include "wlan_dev.h"
#include "wlan_join.h"
#include "wlan_wext.h"
+static const char * mesh_stat_strings[]= {
+ "drop_duplicate_bcast",
+ "drop_ttl_zero",
+ "drop_no_fwd_route",
+ "drop_no_buffers",
+ "fwded_unicast_cnt",
+ "fwded_bcast_cnt",
+ "drop_blind_table"
+};
static void libertas_ethtool_get_drvinfo(struct net_device *dev,
struct ethtool_drvinfo *info)
@@ -96,10 +105,80 @@ static int libertas_ethtool_get_eeprom(s
return 0;
}
+void libertas_ethtool_get_stats(struct net_device * dev,
+ struct ethtool_stats * stats, u64 * data)
+{
+ wlan_private *priv = dev->priv;
+
+ ENTER();
+
+ stats->cmd = ETHTOOL_GSTATS;
+ BUG_ON(stats->n_stats != MESH_STATS_NUM);
+
+ data[0] = priv->mstats.fwd_drop_rbt;
+ data[1] = priv->mstats.fwd_drop_ttl;
+ data[2] = priv->mstats.fwd_drop_noroute;
+ data[3] = priv->mstats.fwd_drop_nobuf;
+ data[4] = priv->mstats.fwd_unicast_cnt;
+ data[5] = priv->mstats.fwd_bcast_cnt;
+ data[6] = priv->mstats.drop_blind;
+
+ LEAVE();
+}
+
+int libertas_ethtool_get_stats_count(struct net_device * dev)
+{
+ int ret;
+ wlan_private *priv = dev->priv;
+ struct HostCmd_DS_MESH_ACCESS mesh_access;
+
+ ENTER();
+ /* Get Mesh Statistics */
+ ret = libertas_prepare_and_send_command(priv,
+ HostCmd_CMD_MESH_ACCESS, HostCmd_ACT_MESH_GET_STATS,
+ HostCmd_OPTION_WAITFORRSP, 0, &mesh_access);
+
+ if (ret) {
+ LEAVE();
+ return 0;
+ }
+
+ priv->mstats.fwd_drop_rbt = mesh_access.data[0];
+ priv->mstats.fwd_drop_ttl = mesh_access.data[1];
+ priv->mstats.fwd_drop_noroute = mesh_access.data[2];
+ priv->mstats.fwd_drop_nobuf = mesh_access.data[3];
+ priv->mstats.fwd_unicast_cnt = mesh_access.data[4];
+ priv->mstats.fwd_bcast_cnt = mesh_access.data[5];
+ priv->mstats.drop_blind = mesh_access.data[6];
+
+ LEAVE();
+ return MESH_STATS_NUM;
+}
+
+void libertas_ethtool_get_strings (struct net_device * dev, u32 stringset,
+ u8 * s)
+{
+ int i;
+
+ ENTER();
+ switch (stringset) {
+ case ETH_SS_STATS:
+ for (i=0; i < MESH_STATS_NUM; i++) {
+ memcpy(s + i * ETH_GSTRING_LEN,
+ mesh_stat_strings[i],
+ ETH_GSTRING_LEN);
+ }
+ break;
+ }
+ LEAVE();
+}
struct ethtool_ops libertas_ethtool_ops = {
.get_drvinfo = libertas_ethtool_get_drvinfo,
.get_eeprom = libertas_ethtool_get_eeprom,
.get_eeprom_len = libertas_ethtool_get_eeprom_len,
+ .get_stats_count = libertas_ethtool_get_stats_count,
+ .get_ethtool_stats = libertas_ethtool_get_stats,
+ .get_strings = libertas_ethtool_get_strings,
};
diff --git a/drivers/net/wireless/libertas/wlan_fw.c b/drivers/net/wireless/libertas/wlan_fw.c
index e6356ca..85907ab 100644
--- a/drivers/net/wireless/libertas/wlan_fw.c
+++ b/drivers/net/wireless/libertas/wlan_fw.c
@@ -156,14 +156,14 @@ static int wlan_allocate_adapter(wlan_pr
libertas_allocate_cmd_buffer(priv);
memset(&Adapter->libertas_ps_confirm_sleep, 0, sizeof(struct PS_CMD_ConfirmSleep));
- Adapter->libertas_ps_confirm_sleep.SeqNum = wlan_cpu_to_le16(++Adapter->SeqNum);
+ Adapter->libertas_ps_confirm_sleep.SeqNum = cpu_to_le16(++Adapter->SeqNum);
Adapter->libertas_ps_confirm_sleep.Command =
- wlan_cpu_to_le16(HostCmd_CMD_802_11_PS_MODE);
+ cpu_to_le16(HostCmd_CMD_802_11_PS_MODE);
Adapter->libertas_ps_confirm_sleep.Size =
- wlan_cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep));
+ cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep));
Adapter->libertas_ps_confirm_sleep.Result = 0;
Adapter->libertas_ps_confirm_sleep.Action =
- wlan_cpu_to_le16(HostCmd_SubCmd_Sleep_Confirmed);
+ cpu_to_le16(HostCmd_SubCmd_Sleep_Confirmed);
return WLAN_STATUS_SUCCESS;
}
diff --git a/drivers/net/wireless/libertas/wlan_ioctl.c b/drivers/net/wireless/libertas/wlan_ioctl.c
index 88dd680..99a597b 100644
--- a/drivers/net/wireless/libertas/wlan_ioctl.c
+++ b/drivers/net/wireless/libertas/wlan_ioctl.c
@@ -1231,7 +1231,7 @@ static int wlan_sleep_period(wlan_privat
memset(&Adapter->sleep_period, 0, sizeof(struct sleep_period));
if (wrq->u.data.length == 0) {
- sleeppd.Action = wlan_cpu_to_le16(HostCmd_ACT_GEN_GET);
+ sleeppd.Action = cpu_to_le16(HostCmd_ACT_GEN_GET);
} else {
if (copy_from_user(&data, wrq->u.data.pointer, sizeof(int))) {
dprintk(1, "Copy from user failed\n");
@@ -1240,7 +1240,7 @@ static int wlan_sleep_period(wlan_privat
/* sleep period is between 0 or 10 ... 60 */
if ((data <= 60 && data >= 10) || (data == 0)) {
- sleeppd.Action = wlan_cpu_to_le16(HostCmd_ACT_GEN_SET);
+ sleeppd.Action = cpu_to_le16(HostCmd_ACT_GEN_SET);
sleeppd.Period = data;
} else
return -EINVAL;
@@ -1719,58 +1719,42 @@ static int eth_addr2str(u8 * addr, char
}
/**
- * @brief Add an entry to the DFT table
+ * @brief Add an entry to the BT table
* @param priv A pointer to wlan_private structure
* @param req A pointer to ifreq structure
* @return WLAN_STATUS_SUCCESS --success, otherwise fail
*/
-static int wlan_dft_add_ioctl(wlan_private * priv, struct ifreq *req)
+static int wlan_bt_add_ioctl(wlan_private * priv, struct ifreq *req)
{
struct iwreq *wrq = (struct iwreq *)req;
- char ethaddrs_str[36];
+ char ethaddrs_str[18];
char *pos;
- u8 ethaddrs[2 * ETH_ALEN];
-#define ethaddr1 (ethaddrs+0)
-#define ethaddr2 (ethaddrs+6)
+ u8 ethaddr[ETH_ALEN];
ENTER();
if (copy_from_user(ethaddrs_str, wrq->u.data.pointer,
sizeof(ethaddrs_str)))
return -EFAULT;
- if ((pos = eth_str2addr(ethaddrs_str, ethaddr1)) == NULL) {
- printk(KERN_INFO "DFT_ADD: Invalid MAC address 1\n");
+ if ((pos = eth_str2addr(ethaddrs_str, ethaddr)) == NULL) {
+ printk(KERN_INFO "BT_ADD: Invalid MAC address\n");
return -EINVAL;
}
- if (eth_str2addr(pos, ethaddr2) == NULL) {
- printk(KERN_INFO "DFT_ADD: Invalid MAC address 2\n");
- return -EINVAL;
- }
-#ifdef DEBUG_LEVEL4
- {
- char ethaddr1_str[18], ethaddr2_str[18];
- dprintk(1, "DFT: adding %s\n", ethaddrs_str);
- eth_addr2str(ethaddr1, ethaddr1_str);
- eth_addr2str(ethaddr2, ethaddr2_str);
- dprintk(1, "DFT: adding (%s,%s)\n", ethaddr1_str,
- ethaddr2_str);
- }
-#endif
-
+ dprintk(1, "BT: adding %s\n", ethaddrs_str);
LEAVE();
- return (libertas_prepare_and_send_command(priv, HostCmd_CMD_DFT_ACCESS,
- HostCmd_ACT_DFT_ACCESS_ADD,
- HostCmd_OPTION_WAITFORRSP, 0, ethaddrs));
+ return (libertas_prepare_and_send_command(priv, HostCmd_CMD_BT_ACCESS,
+ HostCmd_ACT_BT_ACCESS_ADD,
+ HostCmd_OPTION_WAITFORRSP, 0, ethaddr));
}
/**
- * @brief Delete an entry from the DFT table
+ * @brief Delete an entry from the BT table
* @param priv A pointer to wlan_private structure
* @param req A pointer to ifreq structure
* @return WLAN_STATUS_SUCCESS --success, otherwise fail
*/
-static int wlan_dft_del_ioctl(wlan_private * priv, struct ifreq *req)
+static int wlan_bt_del_ioctl(wlan_private * priv, struct ifreq *req)
{
struct iwreq *wrq = (struct iwreq *)req;
char ethaddrs_str[18];
@@ -1787,45 +1771,48 @@ static int wlan_dft_del_ioctl(wlan_priva
return -EINVAL;
}
- dprintk(1, "DFT: deleting %s\n", ethaddrs_str);
+ dprintk(1, "BT: deleting %s\n", ethaddrs_str);
- LEAVE();
return (libertas_prepare_and_send_command(priv,
- HostCmd_CMD_DFT_ACCESS,
- HostCmd_ACT_DFT_ACCESS_DEL,
+ HostCmd_CMD_BT_ACCESS,
+ HostCmd_ACT_BT_ACCESS_DEL,
HostCmd_OPTION_WAITFORRSP, 0, ethaddr));
+ LEAVE();
+ return WLAN_STATUS_SUCCESS;
}
/**
- * @brief Reset all entries from the DFT table
+ * @brief Reset all entries from the BT table
* @param priv A pointer to wlan_private structure
* @return WLAN_STATUS_SUCCESS --success, otherwise fail
*/
-static int wlan_dft_reset_ioctl(wlan_private * priv)
+static int wlan_bt_reset_ioctl(wlan_private * priv)
{
ENTER();
- printk(KERN_ALERT "DFT: resetting\n");
+ printk(KERN_ALERT "BT: resetting\n");
- LEAVE();
return (libertas_prepare_and_send_command(priv,
- HostCmd_CMD_DFT_ACCESS,
- HostCmd_ACT_DFT_ACCESS_RESET,
+ HostCmd_CMD_BT_ACCESS,
+ HostCmd_ACT_BT_ACCESS_RESET,
HostCmd_OPTION_WAITFORRSP, 0, NULL));
+
+ LEAVE();
+ return WLAN_STATUS_SUCCESS;
}
/**
- * @brief List an entry from the DFT table
+ * @brief List an entry from the BT table
* @param priv A pointer to wlan_private structure
* @param req A pointer to ifreq structure
* @return WLAN_STATUS_SUCCESS --success, otherwise fail
*/
-static int wlan_dft_list_ioctl(wlan_private * priv, struct ifreq *req)
+static int wlan_bt_list_ioctl(wlan_private * priv, struct ifreq *req)
{
int pos;
- char *addr1, *addr2;
+ char *addr1;
struct iwreq *wrq = (struct iwreq *)req;
- /* used to pass id and store the dft entry returned by the FW */
+ /* used to pass id and store the bt entry returned by the FW */
union {
int id;
char addr1addr2[2 * ETH_ALEN];
@@ -1844,31 +1831,27 @@ static int wlan_dft_list_ioctl(wlan_priv
pos = sprintf(pbuf, "%d: ", param.id);
pbuf += pos;
- ret = libertas_prepare_and_send_command(priv, HostCmd_CMD_DFT_ACCESS,
- HostCmd_ACT_DFT_ACCESS_LIST,
+ ret = libertas_prepare_and_send_command(priv, HostCmd_CMD_BT_ACCESS,
+ HostCmd_ACT_BT_ACCESS_LIST,
HostCmd_OPTION_WAITFORRSP, 0,
(char *)¶m);
if (ret == WLAN_STATUS_SUCCESS) {
addr1 = param.addr1addr2;
- addr2 = param.addr1addr2 + ETH_ALEN;
- pos = sprintf(pbuf, "da ");
+ pos = sprintf(pbuf, "ignoring traffic from ");
pbuf += pos;
pos = eth_addr2str(addr1, pbuf);
pbuf += pos;
- pos = sprintf(pbuf, " next hop ");
- pbuf += pos;
- pos = eth_addr2str(addr2, pbuf);
- pbuf += pos;
} else {
sprintf(pbuf, "(null)");
pbuf += pos;
}
+
wrq->u.data.length = strlen(outstr);
if (copy_to_user(wrq->u.data.pointer, (char *)outstr,
wrq->u.data.length)) {
- dprintk(1, "DFT_LIST: Copy to user failed!\n");
+ dprintk(1, "BT_LIST: Copy to user failed!\n");
return -EFAULT;
}
@@ -1877,146 +1860,549 @@ static int wlan_dft_list_ioctl(wlan_priv
}
/**
- * @brief Add an entry to the BT table
+ * @brief Find the next parameter in an input string
+ * @param ptr A pointer to the input parameter string
+ * @return A pointer to the next parameter, or 0 if no parameters left.
+ */
+static char * next_param(char * ptr)
+{
+ if (!ptr) return 0;
+ while (*ptr == ' ' || *ptr == '\t') ++ptr;
+ return (*ptr == '\0') ? 0 : ptr;
+}
+
+/**
+ * @brief Add an entry to the FWT table
* @param priv A pointer to wlan_private structure
* @param req A pointer to ifreq structure
* @return WLAN_STATUS_SUCCESS --success, otherwise fail
*/
-static int wlan_bt_add_ioctl(wlan_private * priv, struct ifreq *req)
+static int wlan_fwt_add_ioctl(wlan_private * priv, struct ifreq *req)
{
struct iwreq *wrq = (struct iwreq *)req;
- char ethaddrs_str[18];
- char *pos;
- u8 ethaddr[ETH_ALEN];
+ char in_str[128];
+ static struct HostCmd_DS_FWT_ACCESS fwt_access;
+ char *ptr;
ENTER();
- if (copy_from_user(ethaddrs_str, wrq->u.data.pointer,
- sizeof(ethaddrs_str)))
+ if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
return -EFAULT;
- if ((pos = eth_str2addr(ethaddrs_str, ethaddr)) == NULL) {
- printk(KERN_INFO "BT_ADD: Invalid MAC address\n");
+ if ((ptr = eth_str2addr(in_str, fwt_access.da)) == NULL) {
+ printk(KERN_ALERT "FWT_ADD: Invalid MAC address 1\n");
return -EINVAL;
}
- dprintk(1, "BT: adding %s\n", ethaddrs_str);
+ if ((ptr = eth_str2addr(ptr, fwt_access.ra)) == NULL) {
+ printk(KERN_ALERT "FWT_ADD: Invalid MAC address 2\n");
+ return -EINVAL;
+ }
+
+ if ((ptr = next_param(ptr)))
+ fwt_access.metric =
+ cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
+ else
+ fwt_access.metric = FWT_DEFAULT_METRIC;
+
+ if ((ptr = next_param(ptr)))
+ fwt_access.dir = (u8)simple_strtoul(ptr, &ptr, 10);
+ else
+ fwt_access.dir = FWT_DEFAULT_DIR;
+
+ if ((ptr = next_param(ptr)))
+ fwt_access.ssn =
+ cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
+ else
+ fwt_access.ssn = FWT_DEFAULT_SSN;
+
+ if ((ptr = next_param(ptr)))
+ fwt_access.dsn =
+ cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
+ else
+ fwt_access.dsn = FWT_DEFAULT_DSN;
+
+ if ((ptr = next_param(ptr)))
+ fwt_access.hopcount = simple_strtoul(ptr, &ptr, 10);
+ else
+ fwt_access.hopcount = FWT_DEFAULT_HOPCOUNT;
+
+ if ((ptr = next_param(ptr)))
+ fwt_access.ttl = simple_strtoul(ptr, &ptr, 10);
+ else
+ fwt_access.ttl = FWT_DEFAULT_TTL;
+
+ if ((ptr = next_param(ptr)))
+ fwt_access.expiration =
+ cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
+ else
+ fwt_access.expiration = FWT_DEFAULT_EXPIRATION;
+
+ if ((ptr = next_param(ptr)))
+ fwt_access.sleepmode = (u8)simple_strtoul(ptr, &ptr, 10);
+ else
+ fwt_access.sleepmode = FWT_DEFAULT_SLEEPMODE;
+
+ if ((ptr = next_param(ptr)))
+ fwt_access.snr =
+ cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
+ else
+ fwt_access.snr = FWT_DEFAULT_SNR;
+
+#ifdef DEBUG
+ {
+ char ethaddr1_str[18], ethaddr2_str[18];
+ eth_addr2str(fwt_access.da, ethaddr1_str);
+ eth_addr2str(fwt_access.ra, ethaddr2_str);
+ dprintk(1, "FWT_ADD: adding (da:%s,%i,ra:%s)\n", ethaddr1_str,
+ fwt_access.dir, ethaddr2_str);
+ dprintk(1, "FWT_ADD: ssn:%u dsn:%u met:%u hop:%u ttl:%u exp:%u slp:%u snr:%u\n",
+ fwt_access.ssn, fwt_access.dsn, fwt_access.metric,
+ fwt_access.hopcount, fwt_access.ttl, fwt_access.expiration,
+ fwt_access.sleepmode, fwt_access.snr);
+ }
+#endif
+
LEAVE();
- return (libertas_prepare_and_send_command(priv, HostCmd_CMD_DFT_ACCESS,
- HostCmd_ACT_BT_ACCESS_ADD,
- HostCmd_OPTION_WAITFORRSP, 0, ethaddr));
+ return (libertas_prepare_and_send_command(priv, HostCmd_CMD_FWT_ACCESS,
+ HostCmd_ACT_FWT_ACCESS_ADD,
+ HostCmd_OPTION_WAITFORRSP, 0,
+ (void *)&fwt_access));
}
/**
- * @brief Delete an entry from the BT table
+ * @brief Delete an entry from the FWT table
* @param priv A pointer to wlan_private structure
* @param req A pointer to ifreq structure
* @return WLAN_STATUS_SUCCESS --success, otherwise fail
*/
-static int wlan_bt_del_ioctl(wlan_private * priv, struct ifreq *req)
+static int wlan_fwt_del_ioctl(wlan_private * priv, struct ifreq *req)
{
struct iwreq *wrq = (struct iwreq *)req;
- char ethaddrs_str[18];
- u8 ethaddr[ETH_ALEN];
- char *pos;
+ char in_str[64];
+ static struct HostCmd_DS_FWT_ACCESS fwt_access;
+ char *ptr;
ENTER();
- if (copy_from_user(ethaddrs_str, wrq->u.data.pointer,
- sizeof(ethaddrs_str)))
+ if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
return -EFAULT;
- if ((pos = eth_str2addr(ethaddrs_str, ethaddr)) == NULL) {
- printk(KERN_INFO "Invalid MAC address\n");
+ if ((ptr = eth_str2addr(in_str, fwt_access.da)) == NULL) {
+ printk(KERN_ALERT "FWT_DEL: Invalid MAC address 1\n");
return -EINVAL;
}
- dprintk(1, "BT: deleting %s\n", ethaddrs_str);
+ if ((ptr = eth_str2addr(ptr, fwt_access.ra)) == NULL) {
+ printk(KERN_ALERT "FWT_DEL: Invalid MAC address 2\n");
+ return -EINVAL;
+ }
+
+ if ((ptr = next_param(ptr)))
+ fwt_access.dir = (u8)simple_strtoul(ptr, &ptr, 10);
+ else
+ fwt_access.dir = FWT_DEFAULT_DIR;
+
+#ifdef DEBUG
+ {
+ char ethaddr1_str[18], ethaddr2_str[18];
+ dprintk(1, "FWT_DEL: line is %s\n", in_str);
+ eth_addr2str(fwt_access.da, ethaddr1_str);
+ eth_addr2str(fwt_access.ra, ethaddr2_str);
+ dprintk(1, "FWT_DEL: removing (da:%s,ra:%s,dir:%d)\n", ethaddr1_str,
+ ethaddr2_str, fwt_access.dir);
+ }
+#endif
+ LEAVE();
return (libertas_prepare_and_send_command(priv,
- HostCmd_CMD_DFT_ACCESS,
- HostCmd_ACT_BT_ACCESS_DEL,
- HostCmd_OPTION_WAITFORRSP, 0, ethaddr));
+ HostCmd_CMD_FWT_ACCESS,
+ HostCmd_ACT_FWT_ACCESS_DEL,
+ HostCmd_OPTION_WAITFORRSP, 0,
+ (void *)&fwt_access));
+}
+
+
+/**
+ * @brief Print route parameters
+ * @param fwt_access struct HostCmd_DS_FWT_ACCESS with route info
+ * @param buf destination buffer for route info
+ */
+static void print_route(struct HostCmd_DS_FWT_ACCESS fwt_access, char *buf)
+{
+ buf += sprintf(buf, " ");
+ buf += eth_addr2str(fwt_access.da, buf);
+ buf += sprintf(buf, " ");
+ buf += eth_addr2str(fwt_access.ra, buf);
+ buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.metric));
+ buf += sprintf(buf, " %u", fwt_access.dir);
+ buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.ssn));
+ buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.dsn));
+ buf += sprintf(buf, " %u", fwt_access.hopcount);
+ buf += sprintf(buf, " %u", fwt_access.ttl);
+ buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.expiration));
+ buf += sprintf(buf, " %u", fwt_access.sleepmode);
+ buf += sprintf(buf, " %u", le32_to_cpu(fwt_access.snr));
+}
+
+/**
+ * @brief Lookup an entry in the FWT table
+ * @param priv A pointer to wlan_private structure
+ * @param req A pointer to ifreq structure
+ * @return WLAN_STATUS_SUCCESS --success, otherwise fail
+ */
+static int wlan_fwt_lookup_ioctl(wlan_private * priv, struct ifreq *req)
+{
+ struct iwreq *wrq = (struct iwreq *)req;
+ char in_str[64];
+ char *ptr;
+ static struct HostCmd_DS_FWT_ACCESS fwt_access;
+ static char out_str[128];
+ int ret;
+
+ ENTER();
+ if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
+ return -EFAULT;
+
+ if ((ptr = eth_str2addr(in_str, fwt_access.da)) == NULL) {
+ printk(KERN_ALERT "FWT_LOOKUP: Invalid MAC address\n");
+ return -EINVAL;
+ }
+
+#ifdef DEBUG
+ {
+ char ethaddr1_str[18];
+ dprintk(1, "FWT_LOOKUP: line is %s\n", in_str);
+ eth_addr2str(fwt_access.da, ethaddr1_str);
+ dprintk(1, "FWT_LOOKUP: looking for (da:%s)\n", ethaddr1_str);
+ }
+#endif
+
+ ret = libertas_prepare_and_send_command(priv,
+ HostCmd_CMD_FWT_ACCESS,
+ HostCmd_ACT_FWT_ACCESS_LOOKUP,
+ HostCmd_OPTION_WAITFORRSP, 0,
+ (void *)&fwt_access);
+
+ if (ret == WLAN_STATUS_SUCCESS)
+ print_route(fwt_access, out_str);
+ else
+ sprintf(out_str, "(null)");
+
+ wrq->u.data.length = strlen(out_str);
+ if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
+ wrq->u.data.length)) {
+ dprintk(1, "FWT_LOOKUP: Copy to user failed!\n");
+ return -EFAULT;
+ }
+
LEAVE();
return WLAN_STATUS_SUCCESS;
}
/**
- * @brief Reset all entries from the BT table
+ * @brief Reset all entries from the FWT table
* @param priv A pointer to wlan_private structure
* @return WLAN_STATUS_SUCCESS --success, otherwise fail
*/
-static int wlan_bt_reset_ioctl(wlan_private * priv)
+static int wlan_fwt_reset_ioctl(wlan_private * priv)
{
ENTER();
- printk(KERN_ALERT "BT: resetting\n");
+ dprintk(1, "FWT: resetting\n");
+ LEAVE();
return (libertas_prepare_and_send_command(priv,
- HostCmd_CMD_DFT_ACCESS,
- HostCmd_ACT_BT_ACCESS_RESET,
+ HostCmd_CMD_FWT_ACCESS,
+ HostCmd_ACT_FWT_ACCESS_RESET,
HostCmd_OPTION_WAITFORRSP, 0, NULL));
+}
+
+/**
+ * @brief List an entry from the FWT table
+ * @param priv A pointer to wlan_private structure
+ * @param req A pointer to ifreq structure
+ * @return WLAN_STATUS_SUCCESS --success, otherwise fail
+ */
+static int wlan_fwt_list_ioctl(wlan_private * priv, struct ifreq *req)
+{
+ struct iwreq *wrq = (struct iwreq *)req;
+ char in_str[8];
+ static struct HostCmd_DS_FWT_ACCESS fwt_access;
+ char *ptr = in_str;
+ static char out_str[128];
+ char *pbuf = out_str;
+ int ret;
+
+ ENTER();
+ if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
+ return -EFAULT;
+
+ fwt_access.id = cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
+
+#ifdef DEBUG
+ {
+ dprintk(1, "FWT_LIST: line is %s\n", in_str);
+ dprintk(1, "FWT_LIST: listing id:%i\n", le32_to_cpu(fwt_access.id));
+ }
+#endif
+
+ ret = libertas_prepare_and_send_command(priv, HostCmd_CMD_FWT_ACCESS,
+ HostCmd_ACT_FWT_ACCESS_LIST,
+ HostCmd_OPTION_WAITFORRSP, 0, (void *)&fwt_access);
+
+ if (ret == WLAN_STATUS_SUCCESS)
+ print_route(fwt_access, pbuf);
+ else
+ pbuf += sprintf(pbuf, " (null)");
+
+ wrq->u.data.length = strlen(out_str);
+ if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
+ wrq->u.data.length)) {
+ dprintk(1, "FWT_LIST: Copy to user failed!\n");
+ return -EFAULT;
+ }
LEAVE();
return WLAN_STATUS_SUCCESS;
}
/**
- * @brief List an entry from the BT table
+ * @brief List an entry from the FRT table
* @param priv A pointer to wlan_private structure
* @param req A pointer to ifreq structure
* @return WLAN_STATUS_SUCCESS --success, otherwise fail
*/
-static int wlan_bt_list_ioctl(wlan_private * priv, struct ifreq *req)
+static int wlan_fwt_list_route_ioctl(wlan_private * priv, struct ifreq *req)
{
- int pos;
- char *addr1;
struct iwreq *wrq = (struct iwreq *)req;
- /* used to pass id and store the bt entry returned by the FW */
- union {
- int id;
- char addr1addr2[2 * ETH_ALEN];
- } param;
- static char outstr[64];
- char *pbuf = outstr;
+ char in_str[64];
+ static struct HostCmd_DS_FWT_ACCESS fwt_access;
+ char *ptr = in_str;
+ static char out_str[128];
+ char *pbuf = out_str;
int ret;
ENTER();
+ if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
+ return -EFAULT;
- if (copy_from_user(outstr, wrq->u.data.pointer, sizeof(outstr))) {
- dprintk(1, "Copy from user failed\n");
- return WLAN_STATUS_FAILURE;
+ fwt_access.id = cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
+
+#ifdef DEBUG
+ {
+ dprintk(1, "FWT_LIST_ROUTE: line is %s\n", in_str);
+ dprintk(1, "FWT_LIST_ROUTE: listing id:%i\n", le32_to_cpu(fwt_access.id));
}
- param.id = simple_strtoul(outstr, NULL, 10);
- pos = sprintf(pbuf, "%d: ", param.id);
- pbuf += pos;
+#endif
- ret = libertas_prepare_and_send_command(priv, HostCmd_CMD_DFT_ACCESS,
- HostCmd_ACT_BT_ACCESS_LIST,
- HostCmd_OPTION_WAITFORRSP, 0,
- (char *)¶m);
+ ret = libertas_prepare_and_send_command(priv, HostCmd_CMD_FWT_ACCESS,
+ HostCmd_ACT_FWT_ACCESS_LIST_ROUTE,
+ HostCmd_OPTION_WAITFORRSP, 0, (void *)&fwt_access);
if (ret == WLAN_STATUS_SUCCESS) {
- addr1 = param.addr1addr2;
+ pbuf += sprintf(pbuf, " ");
+ pbuf += eth_addr2str(fwt_access.da, pbuf);
+ pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.metric));
+ pbuf += sprintf(pbuf, " %u", fwt_access.dir);
+ /* note that the firmware returns the nid in the id field */
+ pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.id));
+ pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.ssn));
+ pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.dsn));
+ pbuf += sprintf(pbuf, " hop %u", fwt_access.hopcount);
+ pbuf += sprintf(pbuf, " ttl %u", fwt_access.ttl);
+ pbuf += sprintf(pbuf, " %u", le32_to_cpu(fwt_access.expiration));
+ } else
+ pbuf += sprintf(pbuf, " (null)");
+
+ wrq->u.data.length = strlen(out_str);
+ if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
+ wrq->u.data.length)) {
+ dprintk(1, "FWT_LIST_ROUTE: Copy to user failed!\n");
+ return -EFAULT;
+ }
- pos = sprintf(pbuf, "ignoring traffic from ");
- pbuf += pos;
- pos = eth_addr2str(addr1, pbuf);
- pbuf += pos;
- } else {
- sprintf(pbuf, "(null)");
- pbuf += pos;
+ LEAVE();
+ return WLAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief List an entry from the FNT table
+ * @param priv A pointer to wlan_private structure
+ * @param req A pointer to ifreq structure
+ * @return WLAN_STATUS_SUCCESS --success, otherwise fail
+ */
+static int wlan_fwt_list_neighbor_ioctl(wlan_private * priv, struct ifreq *req)
+{
+ struct iwreq *wrq = (struct iwreq *)req;
+ char in_str[8];
+ static struct HostCmd_DS_FWT_ACCESS fwt_access;
+ char *ptr = in_str;
+ static char out_str[128];
+ char *pbuf = out_str;
+ int ret;
+
+ ENTER();
+ if (copy_from_user(in_str, wrq->u.data.pointer, sizeof(in_str)))
+ return -EFAULT;
+
+ memset(&fwt_access, 0, sizeof(fwt_access));
+ fwt_access.id = cpu_to_le32(simple_strtoul(ptr, &ptr, 10));
+
+#ifdef DEBUG
+ {
+ dprintk(1, "FWT_LIST_NEIGHBOR: line is %s\n", in_str);
+ dprintk(1, "FWT_LIST_NEIGHBOR: listing id:%i\n", le32_to_cpu(fwt_access.id));
}
+#endif
- wrq->u.data.length = strlen(outstr);
- if (copy_to_user(wrq->u.data.pointer, (char *)outstr,
+ ret = libertas_prepare_and_send_command(priv, HostCmd_CMD_FWT_ACCESS,
+ HostCmd_ACT_FWT_ACCESS_LIST_NEIGHBOR,
+ HostCmd_OPTION_WAITFORRSP, 0,
+ (void *)&fwt_access);
+
+ if (ret == WLAN_STATUS_SUCCESS) {
+ pbuf += sprintf(pbuf, " ra ");
+ pbuf += eth_addr2str(fwt_access.ra, pbuf);
+ pbuf += sprintf(pbuf, " slp %u", fwt_access.sleepmode);
+ pbuf += sprintf(pbuf, " snr %u", le32_to_cpu(fwt_access.snr));
+ pbuf += sprintf(pbuf, " ref %u", le32_to_cpu(fwt_access.references));
+ } else
+ pbuf += sprintf(pbuf, " (null)");
+
+ wrq->u.data.length = strlen(out_str);
+ if (copy_to_user(wrq->u.data.pointer, (char *)out_str,
wrq->u.data.length)) {
- dprintk(1, "BT_LIST: Copy to user failed!\n");
+ dprintk(1, "FWT_LIST_NEIGHBOR: Copy to user failed!\n");
+ return -EFAULT;
+ }
+
+ LEAVE();
+ return WLAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief Cleans up the route (FRT) and neighbor (FNT) tables
+ * (Garbage Collection)
+ * @param priv A pointer to wlan_private structure
+ * @param req A pointer to ifreq structure
+ * @return WLAN_STATUS_SUCCESS --success, otherwise fail
+ */
+static int wlan_fwt_cleanup_ioctl(wlan_private * priv, struct ifreq *req)
+{
+ static struct HostCmd_DS_FWT_ACCESS fwt_access;
+ int ret;
+
+ ENTER();
+
+ dprintk(1, "FWT: cleaning up\n");
+
+ memset(&fwt_access, 0, sizeof(fwt_access));
+
+ ret = libertas_prepare_and_send_command(priv, HostCmd_CMD_FWT_ACCESS,
+ HostCmd_ACT_FWT_ACCESS_CLEANUP,
+ HostCmd_OPTION_WAITFORRSP, 0,
+ (void *)&fwt_access);
+
+ if (ret == WLAN_STATUS_SUCCESS)
+ req->ifr_data = (char *)(le32_to_cpu(fwt_access.references));
+ else
+ return -EFAULT;
+
+ LEAVE();
+ return WLAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief Gets firmware internal time (debug purposes)
+ * @param priv A pointer to wlan_private structure
+ * @param req A pointer to ifreq structure
+ * @return WLAN_STATUS_SUCCESS --success, otherwise fail
+ */
+static int wlan_fwt_time_ioctl(wlan_private * priv, struct ifreq *req)
+{
+ static struct HostCmd_DS_FWT_ACCESS fwt_access;
+ int ret;
+
+ ENTER();
+
+ dprintk(1, "FWT: getting time\n");
+
+ memset(&fwt_access, 0, sizeof(fwt_access));
+
+ ret = libertas_prepare_and_send_command(priv, HostCmd_CMD_FWT_ACCESS,
+ HostCmd_ACT_FWT_ACCESS_TIME,
+ HostCmd_OPTION_WAITFORRSP, 0,
+ (void *)&fwt_access);
+
+ if (ret == WLAN_STATUS_SUCCESS)
+ req->ifr_data = (char *)(le32_to_cpu(fwt_access.references));
+ else
return -EFAULT;
+
+ LEAVE();
+ return WLAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief Gets mesh ttl from firmware
+ * @param priv A pointer to wlan_private structure
+ * @param req A pointer to ifreq structure
+ * @return WLAN_STATUS_SUCCESS --success, otherwise fail
+ */
+static int wlan_mesh_get_ttl_ioctl(wlan_private * priv, struct ifreq *req)
+{
+ static struct HostCmd_DS_MESH_ACCESS mesh_access;
+ int ret;
+
+ ENTER();
+
+ memset(&mesh_access, 0, sizeof(mesh_access));
+
+ ret = libertas_prepare_and_send_command(priv, HostCmd_CMD_MESH_ACCESS,
+ HostCmd_ACT_MESH_GET_TTL,
+ HostCmd_OPTION_WAITFORRSP, 0,
+ (void *)&mesh_access);
+
+ if (ret == WLAN_STATUS_SUCCESS) {
+ req->ifr_data = (char *)(le32_to_cpu(mesh_access.data[0]));
}
+ else
+ return -EFAULT;
LEAVE();
return WLAN_STATUS_SUCCESS;
}
+/**
+ * @brief Gets mesh ttl from firmware
+ * @param priv A pointer to wlan_private structure
+ * @param ttl New ttl value
+ * @return WLAN_STATUS_SUCCESS --success, otherwise fail
+ */
+static int wlan_mesh_set_ttl_ioctl(wlan_private * priv, int ttl)
+{
+ static struct HostCmd_DS_MESH_ACCESS mesh_access;
+ int ret;
+
+ ENTER();
+
+ if( (ttl > 0xff) || (ttl < 0) )
+ return -EINVAL;
+
+ memset(&mesh_access, 0, sizeof(mesh_access));
+ mesh_access.data[0] = ttl;
+
+ ret = libertas_prepare_and_send_command(priv, HostCmd_CMD_MESH_ACCESS,
+ HostCmd_ACT_MESH_SET_TTL,
+ HostCmd_OPTION_WAITFORRSP, 0,
+ (void *)&mesh_access);
+
+ if (ret != WLAN_STATUS_SUCCESS)
+ ret = -EFAULT;
+
+ LEAVE();
+ return ret;
+}
+
#ifdef REASSOCIATION
/**
* @brief Set Auto Reassociation On
@@ -2139,12 +2525,12 @@ #endif /* REASSOCIATION */
case WLANWLANIDLEOFF:
libertas_idle_off(priv);
break;
- case WLAN_SUBCMD_DFT_RESET: /* dft_reset */
- wlan_dft_reset_ioctl(priv);
- break;
case WLAN_SUBCMD_BT_RESET: /* bt_reset */
wlan_bt_reset_ioctl(priv);
break;
+ case WLAN_SUBCMD_FWT_RESET: /* fwt_reset */
+ wlan_fwt_reset_ioctl(priv);
+ break;
} /* End of switch */
break;
@@ -2312,6 +2698,11 @@ #define MAX_U16_VAL 65535
ret = wlan_set_debugmode_ioctl(priv, req);
break;
+ case WLAN_SUBCMD_MESH_SET_TTL:
+ idata = *((int *)(wrq->u.name + SUBCMD_OFFSET));
+ ret = wlan_mesh_set_ttl_ioctl(priv, idata);
+ break;
+
default:
ret = -EOPNOTSUPP;
break;
@@ -2340,7 +2731,7 @@ #define MAX_U16_VAL 65535
}
break;
- case WLAN_SET64CHAR_GET64CHAR:
+ case WLAN_SET128CHAR_GET128CHAR:
switch ((int)wrq->u.data.flags) {
case WLANSLEEPPARAMS:
@@ -2355,15 +2746,6 @@ #define MAX_U16_VAL 65535
case WLAN_GET_ADHOC_STATUS:
ret = wlan_get_adhoc_status_ioctl(priv, wrq);
break;
- case WLAN_SUBCMD_DFT_ADD:
- ret = wlan_dft_add_ioctl(priv, req);
- break;
- case WLAN_SUBCMD_DFT_DEL:
- ret = wlan_dft_del_ioctl(priv, req);
- break;
- case WLAN_SUBCMD_DFT_LIST:
- ret = wlan_dft_list_ioctl(priv, req);
- break;
case WLAN_SUBCMD_BT_ADD:
ret = wlan_bt_add_ioctl(priv, req);
break;
@@ -2373,6 +2755,24 @@ #define MAX_U16_VAL 65535
case WLAN_SUBCMD_BT_LIST:
ret = wlan_bt_list_ioctl(priv, req);
break;
+ case WLAN_SUBCMD_FWT_ADD:
+ ret = wlan_fwt_add_ioctl(priv, req);
+ break;
+ case WLAN_SUBCMD_FWT_DEL:
+ ret = wlan_fwt_del_ioctl(priv, req);
+ break;
+ case WLAN_SUBCMD_FWT_LOOKUP:
+ ret = wlan_fwt_lookup_ioctl(priv, req);
+ break;
+ case WLAN_SUBCMD_FWT_LIST_NEIGHBOR:
+ ret = wlan_fwt_list_neighbor_ioctl(priv, req);
+ break;
+ case WLAN_SUBCMD_FWT_LIST:
+ ret = wlan_fwt_list_ioctl(priv, req);
+ break;
+ case WLAN_SUBCMD_FWT_LIST_ROUTE:
+ ret = wlan_fwt_list_route_ioctl(priv, req);
+ break;
}
break;
@@ -2420,6 +2820,18 @@ #define MAX_U16_VAL 65535
case WLAN_GET_TX_RATE:
ret = wlan_get_txrate_ioctl(priv, req);
break;
+ case WLAN_SUBCMD_FWT_CLEANUP: /* fwt_cleanup */
+ ret = wlan_fwt_cleanup_ioctl(priv, req);
+ break;
+
+ case WLAN_SUBCMD_FWT_TIME: /* fwt_time */
+ ret = wlan_fwt_time_ioctl(priv, req);
+ break;
+
+ case WLAN_SUBCMD_MESH_GET_TTL:
+ ret = wlan_mesh_get_ttl_ioctl(priv, req);
+ break;
+
default:
ret = -EOPNOTSUPP;
@@ -2455,7 +2867,7 @@ #define MAX_U16_VAL 65535
if (wrq->u.data.length == 0) {
cfg.Action =
- wlan_cpu_to_le16
+ cpu_to_le16
(HostCmd_ACT_GEN_GET);
} else {
if (copy_from_user
@@ -2467,7 +2879,7 @@ #define MAX_U16_VAL 65535
}
cfg.Action =
- wlan_cpu_to_le16
+ cpu_to_le16
(HostCmd_ACT_GEN_SET);
cfg.Enable = data[0];
cfg.UseSNR = data[1];
@@ -2509,7 +2921,7 @@ #define MAX_U16_VAL 65535
return WLAN_STATUS_FAILURE;
if (wrq->u.data.length == 0) {
cfg.Action =
- wlan_cpu_to_le16
+ cpu_to_le16
(HostCmd_ACT_GEN_GET);
} else {
if (copy_from_user
@@ -2521,7 +2933,7 @@ #define MAX_U16_VAL 65535
}
cfg.Action =
- wlan_cpu_to_le16
+ cpu_to_le16
(HostCmd_ACT_GEN_SET);
cfg.Enable = data[0];
cfg.PA_P0 = data[1];
@@ -2644,7 +3056,7 @@ #define MAX_U16_VAL 65535
return -ENOTSUPP;
if (wrq->u.data.length == 0) {
ctrl.Action =
- wlan_cpu_to_le16
+ cpu_to_le16
(HostCmd_ACT_GEN_GET);
} else {
if (copy_from_user
@@ -2657,11 +3069,11 @@ #define MAX_U16_VAL 65535
}
ctrl.Action =
- wlan_cpu_to_le16
+ cpu_to_le16
(HostCmd_ACT_GEN_SET);
- ctrl.NumLed = wlan_cpu_to_le16(0);
+ ctrl.NumLed = cpu_to_le16(0);
gpio->Header.Type =
- wlan_cpu_to_le16(TLV_TYPE_LED_GPIO);
+ cpu_to_le16(TLV_TYPE_LED_GPIO);
gpio->Header.Len = wrq->u.data.length;
for (i = 0; i < wrq->u.data.length;
i += 2) {
diff --git a/drivers/net/wireless/libertas/wlan_join.c b/drivers/net/wireless/libertas/wlan_join.c
index b19f285..ce100f7 100644
--- a/drivers/net/wireless/libertas/wlan_join.c
+++ b/drivers/net/wireless/libertas/wlan_join.c
@@ -479,9 +479,9 @@ int libertas_cmd_80211_authenticate(wlan
&cmd->params.auth;
u8 *bssid = (u8 *) pdata_buf;
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_AUTHENTICATE);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_AUTHENTICATE);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_AUTHENTICATE)
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_AUTHENTICATE)
+ S_DS_GEN);
pAuthenticate->AuthType = Adapter->SecInfo.AuthenticationMode;
@@ -508,9 +508,9 @@ int libertas_cmd_80211_deauthenticate(wl
ENTER();
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_DEAUTHENTICATE);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_DEAUTHENTICATE);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_DEAUTHENTICATE) +
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_DEAUTHENTICATE) +
S_DS_GEN);
/* set AP MAC address */
@@ -519,7 +519,7 @@ int libertas_cmd_80211_deauthenticate(wl
/* Reason code 3 = Station is leaving */
#define REASON_CODE_STA_LEAVING 3
- dauth->ReasonCode = wlan_cpu_to_le16(REASON_CODE_STA_LEAVING);
+ dauth->ReasonCode = cpu_to_le16(REASON_CODE_STA_LEAVING);
LEAVE();
return WLAN_STATUS_SUCCESS;
@@ -560,7 +560,7 @@ int libertas_cmd_80211_associate(wlan_pr
goto done;
}
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_ASSOCIATE);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_ASSOCIATE);
/* Save so we know which BSS Desc to use in the response handler */
Adapter->pAttemptedBSSDesc = pBSSDesc;
@@ -578,29 +578,29 @@ int libertas_cmd_80211_associate(wlan_pr
pos += sizeof(pAsso->DtimPeriod);
ssid = (struct MrvlIEtypes_SsIdParamSet *) pos;
- ssid->Header.Type = wlan_cpu_to_le16(TLV_TYPE_SSID);
+ ssid->Header.Type = cpu_to_le16(TLV_TYPE_SSID);
ssid->Header.Len = pBSSDesc->Ssid.SsidLength;
memcpy(ssid->SsId, pBSSDesc->Ssid.Ssid, ssid->Header.Len);
pos += sizeof(ssid->Header) + ssid->Header.Len;
- ssid->Header.Len = wlan_cpu_to_le16(ssid->Header.Len);
+ ssid->Header.Len = cpu_to_le16(ssid->Header.Len);
phy = (struct MrvlIEtypes_PhyParamSet *) pos;
- phy->Header.Type = wlan_cpu_to_le16(TLV_TYPE_PHY_DS);
+ phy->Header.Type = cpu_to_le16(TLV_TYPE_PHY_DS);
phy->Header.Len = sizeof(phy->fh_ds.DsParamSet);
memcpy(&phy->fh_ds.DsParamSet,
&pBSSDesc->PhyParamSet.DsParamSet.CurrentChan,
sizeof(phy->fh_ds.DsParamSet));
pos += sizeof(phy->Header) + phy->Header.Len;
- phy->Header.Len = wlan_cpu_to_le16(phy->Header.Len);
+ phy->Header.Len = cpu_to_le16(phy->Header.Len);
ss = (struct MrvlIEtypes_SsParamSet *) pos;
- ss->Header.Type = wlan_cpu_to_le16(TLV_TYPE_CF);
+ ss->Header.Type = cpu_to_le16(TLV_TYPE_CF);
ss->Header.Len = sizeof(ss->cf_ibss.CfParamSet);
pos += sizeof(ss->Header) + ss->Header.Len;
- ss->Header.Len = wlan_cpu_to_le16(ss->Header.Len);
+ ss->Header.Len = cpu_to_le16(ss->Header.Len);
rates = (struct MrvlIEtypes_RatesParamSet *) pos;
- rates->Header.Type = wlan_cpu_to_le16(TLV_TYPE_RATES);
+ rates->Header.Type = cpu_to_le16(TLV_TYPE_RATES);
memcpy(&rates->Rates, &pBSSDesc->libertas_supported_rates, WLAN_SUPPORTED_RATES);
@@ -617,18 +617,18 @@ int libertas_cmd_80211_associate(wlan_pr
Adapter->CurBssParams.NumOfRates = rates->Header.Len;
pos += sizeof(rates->Header) + rates->Header.Len;
- rates->Header.Len = wlan_cpu_to_le16(rates->Header.Len);
+ rates->Header.Len = cpu_to_le16(rates->Header.Len);
if (Adapter->SecInfo.WPAEnabled || Adapter->SecInfo.WPA2Enabled) {
rsn = (struct MrvlIEtypes_RsnParamSet *) pos;
rsn->Header.Type = (u16) Adapter->Wpa_ie[0]; /* WPA_IE or WPA2_IE */
- rsn->Header.Type = wlan_cpu_to_le16(rsn->Header.Type);
+ rsn->Header.Type = cpu_to_le16(rsn->Header.Type);
rsn->Header.Len = (u16) Adapter->Wpa_ie[1];
memcpy(rsn->RsnIE, &Adapter->Wpa_ie[2], rsn->Header.Len);
HEXDUMP("ASSOC_CMD: RSN IE", (u8 *) rsn,
sizeof(rsn->Header) + rsn->Header.Len);
pos += sizeof(rsn->Header) + rsn->Header.Len;
- rsn->Header.Len = wlan_cpu_to_le16(rsn->Header.Len);
+ rsn->Header.Len = cpu_to_le16(rsn->Header.Len);
}
/* update CurBssParams */
@@ -652,14 +652,14 @@ #define CAPINFO_ESS_MODE 1
goto done;
}
- cmd->Size = wlan_cpu_to_le16((u16) (pos - (u8 *) pAsso) + S_DS_GEN);
+ cmd->Size = cpu_to_le16((u16) (pos - (u8 *) pAsso) + S_DS_GEN);
/* set the Capability info at last */
memcpy(&TmpCap, &pBSSDesc->Cap, sizeof(pAsso->CapInfo));
TmpCap &= CAPINFO_MASK;
dprintk(1, "ASSOC_CMD: TmpCap=%4X CAPINFO_MASK=%4X\n",
TmpCap, CAPINFO_MASK);
- TmpCap = wlan_cpu_to_le16(TmpCap);
+ TmpCap = cpu_to_le16(TmpCap);
memcpy(&pAsso->CapInfo, &TmpCap, sizeof(pAsso->CapInfo));
done:
@@ -693,7 +693,7 @@ int libertas_cmd_80211_ad_hoc_start(wlan
goto done;
}
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_START);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_START);
pBSSDesc = &Adapter->CurBssParams.BSSDescriptor;
Adapter->pAttemptedBSSDesc = pBSSDesc;
@@ -768,7 +768,7 @@ #define IBSS_PARA_IE_LEN 2
pBSSDesc->Cap.Ibss = 1;
/* ProbeDelay */
- adhs->ProbeDelay = wlan_cpu_to_le16(HostCmd_SCAN_PROBE_DELAY_TIME);
+ adhs->ProbeDelay = cpu_to_le16(HostCmd_SCAN_PROBE_DELAY_TIME);
/* set up privacy in Adapter->ScanTable[i] */
if (Adapter->SecInfo.WEPStatus == Wlan802_11WEPEnabled) {
@@ -815,11 +815,11 @@ #define AD_HOC_CAP_PRIVACY_ON 1
}
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_AD_HOC_START)
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_AD_HOC_START)
+ S_DS_GEN + cmdAppendSize);
memcpy(&TmpCap, &adhs->Cap, sizeof(u16));
- TmpCap = wlan_cpu_to_le16(TmpCap);
+ TmpCap = cpu_to_le16(TmpCap);
memcpy(&adhs->Cap, &TmpCap, sizeof(u16));
ret = WLAN_STATUS_SUCCESS;
@@ -838,9 +838,9 @@ #define AD_HOC_CAP_PRIVACY_ON 1
int libertas_cmd_80211_ad_hoc_stop(wlan_private * priv,
struct HostCmd_DS_COMMAND *cmd)
{
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_STOP);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_STOP);
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_AD_HOC_STOP)
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_AD_HOC_STOP)
+ S_DS_GEN);
return WLAN_STATUS_SUCCESS;
@@ -872,7 +872,7 @@ int libertas_cmd_80211_ad_hoc_join(wlan_
Adapter->pAttemptedBSSDesc = pBSSDesc;
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_JOIN);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_JOIN);
pAdHocJoin->BssDescriptor.BSSType = HostCmd_BSS_TYPE_IBSS;
@@ -914,11 +914,11 @@ int libertas_cmd_80211_ad_hoc_join(wlan_
(u32) pAdHocJoin->BssDescriptor.DataRates);
/* FailTimeOut */
- pAdHocJoin->FailTimeOut = wlan_cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT);
+ pAdHocJoin->FailTimeOut = cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT);
/* ProbeDelay */
pAdHocJoin->ProbeDelay =
- wlan_cpu_to_le16(HostCmd_SCAN_PROBE_DELAY_TIME);
+ cpu_to_le16(HostCmd_SCAN_PROBE_DELAY_TIME);
/* Copy Data Rates from the Rates recorded in scan response */
memset(pAdHocJoin->BssDescriptor.DataRates, 0,
@@ -954,7 +954,7 @@ int libertas_cmd_80211_ad_hoc_join(wlan_
Adapter->CurBssParams.NumOfRates);
pAdHocJoin->BssDescriptor.SsParamSet.IbssParamSet.AtimWindow =
- wlan_cpu_to_le16(pBSSDesc->ATIMWindow);
+ cpu_to_le16(pBSSDesc->ATIMWindow);
if (Adapter->SecInfo.WEPStatus == Wlan802_11WEPEnabled) {
pAdHocJoin->BssDescriptor.Cap.Privacy = AD_HOC_CAP_PRIVACY_ON;
@@ -982,12 +982,12 @@ int libertas_cmd_80211_ad_hoc_join(wlan_
}
cmd->Size =
- wlan_cpu_to_le16(sizeof(struct HostCmd_DS_802_11_AD_HOC_JOIN)
+ cpu_to_le16(sizeof(struct HostCmd_DS_802_11_AD_HOC_JOIN)
+ S_DS_GEN + cmdAppendSize);
memcpy(&TmpCap, &pAdHocJoin->BssDescriptor.Cap,
sizeof(struct IEEEtypes_CapInfo));
- TmpCap = wlan_cpu_to_le16(TmpCap);
+ TmpCap = cpu_to_le16(TmpCap);
memcpy(&pAdHocJoin->BssDescriptor.Cap,
&TmpCap, sizeof(struct IEEEtypes_CapInfo));
@@ -1043,7 +1043,7 @@ int libertas_ret_80211_associate(wlan_pr
}
HEXDUMP("ASSOC_RESP:", (void *)&resp->params,
- wlan_le16_to_cpu(resp->Size) - S_DS_GEN);
+ le16_to_cpu(resp->Size) - S_DS_GEN);
/* Send a Media Connected event, according to the Spec */
Adapter->MediaConnectStatus = WlanMediaStateConnected;
@@ -1124,8 +1124,8 @@ int libertas_ret_80211_ad_hoc_start(wlan
{
wlan_adapter *Adapter = priv->adapter;
int ret = WLAN_STATUS_SUCCESS;
- u16 Command = wlan_le16_to_cpu(resp->Command);
- u16 Result = wlan_le16_to_cpu(resp->Result);
+ u16 Command = le16_to_cpu(resp->Command);
+ u16 Result = le16_to_cpu(resp->Result);
struct HostCmd_DS_802_11_AD_HOC_RESULT *pAdHocResult;
union iwreq_data wrqu;
struct bss_descriptor *pBSSDesc;
@@ -1134,7 +1134,7 @@ int libertas_ret_80211_ad_hoc_start(wlan
pAdHocResult = &resp->params.result;
- dprintk(1, "ADHOC_S_RESP: Size = %d\n", wlan_le16_to_cpu(resp->Size));
+ dprintk(1, "ADHOC_S_RESP: Size = %d\n", le16_to_cpu(resp->Size));
dprintk(1, "ADHOC_S_RESP: Command = %x\n", Command);
dprintk(1, "ADHOC_S_RESP: Result = %x\n", Result);
diff --git a/drivers/net/wireless/libertas/wlan_main.c b/drivers/net/wireless/libertas/wlan_main.c
index eba4a33..eb9b5b9 100644
--- a/drivers/net/wireless/libertas/wlan_main.c
+++ b/drivers/net/wireless/libertas/wlan_main.c
@@ -225,45 +225,96 @@ static u8 *default_fw_name = "usb8388.bi
extern u8 *libertas_fw_name;
/**
- * @brief This function opens the network device
+ * @brief Check if the device can be open and wait if necessary.
*
* @param dev A pointer to net_device structure
* @return WLAN_STATUS_SUCCESS
+ *
+ * For USB adapter, on some systems the device open handler will be
+ * called before FW ready. Use the following flag check and wait
+ * function to work around the issue.
+ *
*/
-static int wlan_open(struct net_device *dev)
-{
+static int pre_open_check(struct net_device *dev) {
wlan_private *priv = (wlan_private *) dev->priv;
wlan_adapter *adapter = priv->adapter;
int i = 0;
- ENTER();
-
- /* For USB adapter, on some systems the device open handler will be
- * called before FW ready. Use the following flag check and wait
- * function to work around the issue.
- */
while (!adapter->fw_ready && i < 20) {
i++;
msleep_interruptible(100);
}
if (!adapter->fw_ready) {
printk(KERN_INFO
- "FW not ready, wlan_open() return failure\n");
+ "FW not ready, pre_open_check() return failure\n");
LEAVE();
return WLAN_STATUS_FAILURE;
}
+ return WLAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief This function opens the device
+ *
+ * @param dev A pointer to net_device structure
+ * @return WLAN_STATUS_SUCCESS
+ */
+static int wlan_dev_open(struct net_device *dev)
+{
+ wlan_private *priv = (wlan_private *) dev->priv;
+ wlan_adapter *adapter = priv->adapter;
+
+ ENTER();
+
+
priv->open = 1;
if (adapter->MediaConnectStatus == WlanMediaStateConnected) {
netif_carrier_on(priv->wlan_dev.netdev);
- netif_wake_queue(priv->wlan_dev.netdev);
} else
netif_carrier_off(priv->wlan_dev.netdev);
LEAVE();
return WLAN_STATUS_SUCCESS;
}
+/**
+ * @brief This function opens the mshX interface
+ *
+ * @param dev A pointer to net_device structure
+ * @return WLAN_STATUS_SUCCESS
+ */
+static int mesh_open(struct net_device *dev)
+{
+ wlan_private *priv = (wlan_private *) dev->priv ;
+
+ if(pre_open_check(dev) == WLAN_STATUS_FAILURE)
+ return WLAN_STATUS_FAILURE;
+ priv->mesh_open = 1 ;
+ netif_start_queue(priv->mesh_dev);
+ if (priv->infra_open == 0)
+ return wlan_dev_open(priv->wlan_dev.netdev) ;
+ return WLAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief This function opens the ethX interface
+ *
+ * @param dev A pointer to net_device structure
+ * @return WLAN_STATUS_SUCCESS
+ */
+static int wlan_open(struct net_device *dev)
+{
+ wlan_private *priv = (wlan_private *) dev->priv ;
+
+ if(pre_open_check(dev) == WLAN_STATUS_FAILURE)
+ return WLAN_STATUS_FAILURE;
+ priv->infra_open = 1 ;
+ netif_wake_queue(priv->wlan_dev.netdev);
+ if (priv->open == 0)
+ return wlan_dev_open(priv->wlan_dev.netdev) ;
+ return WLAN_STATUS_SUCCESS;
+}
/**
* @brief This function closes the network device
@@ -271,21 +322,55 @@ static int wlan_open(struct net_device *
* @param dev A pointer to net_device structure
* @return WLAN_STATUS_SUCCESS
*/
-static int wlan_close(struct net_device *dev)
+static int wlan_dev_close(struct net_device *dev)
{
wlan_private *priv = dev->priv;
ENTER();
- netif_stop_queue(priv->wlan_dev.netdev);
netif_carrier_off(priv->wlan_dev.netdev);
-
priv->open = 0;
LEAVE();
return WLAN_STATUS_SUCCESS;
}
+/**
+ * @brief This function closes the mshX interface
+ *
+ * @param dev A pointer to net_device structure
+ * @return WLAN_STATUS_SUCCESS
+ */
+static int mesh_close(struct net_device *dev)
+{
+ wlan_private *priv = (wlan_private *) (dev->priv);
+
+ priv->mesh_open = 0;
+ netif_stop_queue(priv->mesh_dev);
+ if (priv->infra_open == 0)
+ return wlan_dev_close( ((wlan_private *) dev->priv)->wlan_dev.netdev) ;
+ else
+ return WLAN_STATUS_SUCCESS;
+}
+
+/**
+ * @brief This function closes the ethX interface
+ *
+ * @param dev A pointer to net_device structure
+ * @return WLAN_STATUS_SUCCESS
+ */
+static int wlan_close(struct net_device *dev) {
+ wlan_private *priv = (wlan_private *) dev->priv;
+
+ netif_stop_queue(priv->wlan_dev.netdev);
+ priv->infra_open = 0;
+ if (priv->mesh_open == 0)
+ return wlan_dev_close( ((wlan_private *) dev->priv)->wlan_dev.netdev) ;
+ else
+ return WLAN_STATUS_SUCCESS;
+}
+
+
#ifdef ENABLE_PM
/**
@@ -425,6 +510,31 @@ done:
return ret;
}
+/**
+ * @brief Mark mesh packets and handover them to wlan_hard_start_xmit
+ *
+ */
+static int mesh_pre_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+ wlan_private *priv = dev->priv;
+ ENTER();
+ SET_MESH_FRAME(skb);
+ LEAVE();
+
+ return wlan_hard_start_xmit(skb, priv->wlan_dev.netdev);
+}
+
+/**
+ * @brief Mark non-mesh packets and handover them to wlan_hard_start_xmit
+ *
+ */
+static int wlan_pre_start_xmit(struct sk_buff *skb, struct net_device *dev) {
+ ENTER();
+ UNSET_MESH_FRAME(skb);
+ LEAVE();
+ return wlan_hard_start_xmit(skb, dev);
+}
+
/**
* @brief This function handles the timeout of packet
* transmission
@@ -506,6 +616,7 @@ static int wlan_set_mac_address(struct n
HEXDUMP("Adapter->MacAddr:", Adapter->CurrentAddr, ETH_ALEN);
memcpy(dev->dev_addr, Adapter->CurrentAddr, ETH_ALEN);
+ memcpy(((wlan_private *) dev->priv)->mesh_dev->dev_addr, Adapter->CurrentAddr, ETH_ALEN);
done:
LEAVE();
@@ -766,6 +877,7 @@ static int wlan_service_main_thread(void
libertas_tx_runqueue(priv);
}
+ del_timer(&Adapter->command_timer);
wlan_deactivate_thread(thread);
LEAVE();
@@ -782,6 +894,7 @@ static int wlan_service_main_thread(void
static wlan_private *wlan_add_card(void *card)
{
struct net_device *dev = NULL;
+ struct net_device *mesh_dev = NULL;
wlan_private *priv = NULL;
ENTER();
@@ -806,21 +919,40 @@ static wlan_private *wlan_add_card(void
goto err_kmalloc;
}
+ /* Allocate a virtual mesh device */
+ if (!(mesh_dev = alloc_netdev(0, "msh%d", ether_setup))) {
+ dprintk(1, "Init ethernet device failed!\n");
+ return NULL;
+ }
+
+ /* Both intervaces share the priv structure */
+ mesh_dev->priv = priv;
+
/* init wlan_adapter */
memset(priv->adapter, 0, sizeof(wlan_adapter));
priv->wlan_dev.netdev = dev;
priv->wlan_dev.card = card;
+ priv->mesh_open = 0;
+ priv->infra_open = 0;
+ priv->mesh_dev = mesh_dev;
wlanpriv = priv;
SET_MODULE_OWNER(dev);
+ SET_MODULE_OWNER(mesh_dev);
/* Setup the OS Interface to our functions */
dev->open = wlan_open;
- dev->hard_start_xmit = wlan_hard_start_xmit;
+ dev->hard_start_xmit = wlan_pre_start_xmit;
dev->stop = wlan_close;
dev->do_ioctl = libertas_do_ioctl;
dev->set_mac_address = wlan_set_mac_address;
+ mesh_dev->open = mesh_open;
+ mesh_dev->hard_start_xmit = mesh_pre_start_xmit;
+ mesh_dev->stop = mesh_close;
+ mesh_dev->do_ioctl = libertas_do_ioctl;
+ memcpy(mesh_dev->dev_addr, wlanpriv->wlan_dev.netdev->dev_addr,
+ sizeof(wlanpriv->wlan_dev.netdev->dev_addr));
#define WLAN_WATCHDOG_TIMEOUT (5 * HZ)
@@ -828,9 +960,12 @@ #define WLAN_WATCHDOG_TIMEOUT (5 * HZ)
dev->get_stats = wlan_get_stats;
dev->watchdog_timeo = WLAN_WATCHDOG_TIMEOUT;
dev->ethtool_ops = &libertas_ethtool_ops;
+ mesh_dev->get_stats = wlan_get_stats;
+ mesh_dev->ethtool_ops = &libertas_ethtool_ops;
#ifdef WIRELESS_EXT
dev->wireless_handlers = (struct iw_handler_def *)&libertas_handler_def;
+ mesh_dev->wireless_handlers = (struct iw_handler_def *)&libertas_handler_def;
#endif
#define NETIF_F_DYNALLOC 16
dev->features |= NETIF_F_DYNALLOC;
@@ -879,6 +1014,12 @@ #endif /* REASSOCIATION */
goto err_init_fw;
}
+ /* Register virtual mesh interface */
+ if (register_netdev(mesh_dev)) {
+ printk(KERN_INFO "Cannot register mesh virtual interface!\n");
+ goto err_init_fw;
+ }
+
printk(KERN_INFO "%s: Marvell Wlan 802.11 Adapter ", dev->name);
libertas_debugfs_init_one(priv, dev);
@@ -904,6 +1045,7 @@ #endif /* REASSOCIATION */
kfree(priv->adapter);
err_kmalloc:
free_netdev(dev);
+ free_netdev(mesh_dev);
wlanpriv = NULL;
LEAVE();
@@ -918,9 +1060,10 @@ err_kmalloc:
*/
static int wlan_remove_card(void *card)
{
- wlan_private *priv = wlanpriv;
+ wlan_private *priv = libertas_sbi_get_priv(card);
wlan_adapter *Adapter;
struct net_device *dev;
+ struct net_device *mesh_dev;
union iwreq_data wrqu;
ENTER();
@@ -938,6 +1081,7 @@ static int wlan_remove_card(void *card)
}
dev = priv->wlan_dev.netdev;
+ mesh_dev = priv->mesh_dev;
if (Adapter->CurCmd) {
dprintk(1, "Wake up current cmdwait_q\n");
@@ -995,11 +1139,13 @@ #endif /* REASSOCIATION */
dprintk(1, "netdev_finish_unregister: %s%s.\n", dev->name,
(dev->features & NETIF_F_DYNALLOC) ? "" : ", old style");
+ unregister_netdev(mesh_dev);
unregister_netdev(dev);
dprintk(1, "Unregister finish\n");
priv->wlan_dev.netdev = NULL;
+ free_netdev(mesh_dev);
free_netdev(dev);
wlanpriv = NULL;
diff --git a/drivers/net/wireless/libertas/wlan_rx.c b/drivers/net/wireless/libertas/wlan_rx.c
index c56215d..65df7a7 100644
--- a/drivers/net/wireless/libertas/wlan_rx.c
+++ b/drivers/net/wireless/libertas/wlan_rx.c
@@ -168,7 +168,10 @@ int libertas_upload_rx_packet(wlan_priva
{
dprintk(1, "skb->data=%p\n", skb->data);
- skb->dev = priv->wlan_dev.netdev;
+ if(IS_MESH_FRAME(skb))
+ skb->dev = priv->mesh_dev;
+ else
+ skb->dev = priv->wlan_dev.netdev;
skb->protocol = eth_type_trans(skb, priv->wlan_dev.netdev);
skb->ip_summed = CHECKSUM_UNNECESSARY;
@@ -209,6 +212,10 @@ int libertas_process_rxed_packet(wlan_pr
pRxPkt = (struct RxPacketHdr *) skb->data;
pRxPD = &pRxPkt->rx_pd;
+ if (pRxPD->RxControl & RxPD_MESH_FRAME)
+ SET_MESH_FRAME(skb);
+ else
+ UNSET_MESH_FRAME(skb);
HEXDUMP("RX Data: Before chop RxPD", skb->data,
min_t(unsigned int, skb->len, 100));
diff --git a/drivers/net/wireless/libertas/wlan_scan.c b/drivers/net/wireless/libertas/wlan_scan.c
index c15afa8..9568724 100644
--- a/drivers/net/wireless/libertas/wlan_scan.c
+++ b/drivers/net/wireless/libertas/wlan_scan.c
@@ -392,13 +392,13 @@ static void wlan_scan_create_channel_lis
if (scanType == HostCmd_SCAN_TYPE_PASSIVE) {
scanChanList[chanIdx].MaxScanTime =
- wlan_cpu_to_le16
+ cpu_to_le16
(MRVDRV_PASSIVE_SCAN_CHAN_TIME);
scanChanList[chanIdx].ChanScanMode.PassiveScan =
1;
} else {
scanChanList[chanIdx].MaxScanTime =
- wlan_cpu_to_le16
+ cpu_to_le16
(MRVDRV_ACTIVE_SCAN_CHAN_TIME);
scanChanList[chanIdx].ChanScanMode.PassiveScan =
0;
@@ -535,8 +535,8 @@ wlan_scan_setup_scan_config(wlan_private
pSsidTlv =
(struct MrvlIEtypes_SsIdParamSet *) pScanCfgOut->
tlvBuffer;
- pSsidTlv->Header.Type = wlan_cpu_to_le16(TLV_TYPE_SSID);
- pSsidTlv->Header.Len = wlan_cpu_to_le16(ssidLen);
+ pSsidTlv->Header.Type = cpu_to_le16(TLV_TYPE_SSID);
+ pSsidTlv->Header.Len = cpu_to_le16(ssidLen);
memcpy(pSsidTlv->SsId, pUserScanIn->specificSSID,
ssidLen);
pTlvPos += sizeof(pSsidTlv->Header) + ssidLen;
@@ -562,15 +562,15 @@ wlan_scan_setup_scan_config(wlan_private
if (numProbes) {
pNumProbesTlv = (struct MrvlIEtypes_NumProbes *) pTlvPos;
pNumProbesTlv->Header.Type =
- wlan_cpu_to_le16(TLV_TYPE_NUMPROBES);
+ cpu_to_le16(TLV_TYPE_NUMPROBES);
pNumProbesTlv->Header.Len = sizeof(pNumProbesTlv->NumProbes);
- pNumProbesTlv->NumProbes = wlan_cpu_to_le16(numProbes);
+ pNumProbesTlv->NumProbes = cpu_to_le16(numProbes);
pTlvPos +=
sizeof(pNumProbesTlv->Header) + pNumProbesTlv->Header.Len;
pNumProbesTlv->Header.Len =
- wlan_cpu_to_le16(pNumProbesTlv->Header.Len);
+ cpu_to_le16(pNumProbesTlv->Header.Len);
}
/*
@@ -617,9 +617,9 @@ wlan_scan_setup_scan_config(wlan_private
}
(pScanChanList + chanIdx)->MinScanTime =
- wlan_cpu_to_le16(scanDur);
+ cpu_to_le16(scanDur);
(pScanChanList + chanIdx)->MaxScanTime =
- wlan_cpu_to_le16(scanDur);
+ cpu_to_le16(scanDur);
}
/* Check if we are only scanning the current channel */
@@ -684,7 +684,7 @@ static int wlan_scan_channel_list(wlan_p
return WLAN_STATUS_FAILURE;
}
- pChanTlvOut->Header.Type = wlan_cpu_to_le16(TLV_TYPE_CHANLIST);
+ pChanTlvOut->Header.Type = cpu_to_le16(TLV_TYPE_CHANLIST);
/* Set the temp channel struct pointer to the start of the desired list */
pTmpChan = pScanChanList;
@@ -959,8 +959,8 @@ void wlan_ret_802_11_scan_get_tlv_ptrs(s
HEXDUMP("SCAN_RESP: TLV Buf", (u8 *) pTlv, tlvBufSize);
while (tlvBufLeft >= sizeof(struct MrvlIEtypesHeader)) {
- tlvType = wlan_le16_to_cpu(pCurrentTlv->Header.Type);
- tlvLen = wlan_le16_to_cpu(pCurrentTlv->Header.Len);
+ tlvType = le16_to_cpu(pCurrentTlv->Header.Type);
+ tlvLen = le16_to_cpu(pCurrentTlv->Header.Len);
switch (tlvType) {
case TLV_TYPE_TSFTIMESTAMP:
@@ -1026,7 +1026,7 @@ static int InterpretBSSDescriptionWithIE
if (*bytesLeft >= sizeof(beaconSize)) {
/* Extract & convert beacon size from the command buffer */
memcpy(&beaconSize, *pBeaconInfo, sizeof(beaconSize));
- beaconSize = wlan_le16_to_cpu(beaconSize);
+ beaconSize = le16_to_cpu(beaconSize);
*bytesLeft -= sizeof(beaconSize);
*pBeaconInfo += sizeof(beaconSize);
}
@@ -1071,7 +1071,7 @@ static int InterpretBSSDescriptionWithIE
*/
/* RSSI is 1 byte long */
- pBSSEntry->Rssi = wlan_le32_to_cpu((long)(*pCurrentPtr));
+ pBSSEntry->Rssi = le32_to_cpu((long)(*pCurrentPtr));
dprintk(1, "InterpretIE: RSSI=%02X\n", *pCurrentPtr);
pCurrentPtr += 1;
bytesLeftForCurrentBeacon -= 1;
@@ -1084,7 +1084,7 @@ static int InterpretBSSDescriptionWithIE
/* beacon interval is 2 bytes long */
memcpy(&fixedIE.BeaconInterval, pCurrentPtr, 2);
- pBSSEntry->BeaconPeriod = wlan_le16_to_cpu(fixedIE.BeaconInterval);
+ pBSSEntry->BeaconPeriod = le16_to_cpu(fixedIE.BeaconInterval);
pCurrentPtr += 2;
bytesLeftForCurrentBeacon -= 2;
@@ -1092,7 +1092,7 @@ static int InterpretBSSDescriptionWithIE
memcpy(&fixedIE.Capabilities, pCurrentPtr, 2);
dprintk(1, "InterpretIE: fixedIE.Capabilities=0x%X\n",
fixedIE.Capabilities);
- fixedIE.Capabilities = wlan_le16_to_cpu(fixedIE.Capabilities);
+ fixedIE.Capabilities = le16_to_cpu(fixedIE.Capabilities);
pCap = (struct IEEEtypes_CapInfo *) & fixedIE.Capabilities;
memcpy(&pBSSEntry->Cap, pCap, sizeof(struct IEEEtypes_CapInfo));
pCurrentPtr += 2;
@@ -1160,7 +1160,7 @@ static int InterpretBSSDescriptionWithIE
sizeof(struct IEEEtypes_FhParamSet));
pBSSEntry->PhyParamSet.FhParamSet.DwellTime
=
- wlan_le16_to_cpu(pBSSEntry->PhyParamSet.FhParamSet.
+ le16_to_cpu(pBSSEntry->PhyParamSet.FhParamSet.
DwellTime);
break;
@@ -1184,14 +1184,14 @@ static int InterpretBSSDescriptionWithIE
case IBSS_PARAM_SET:
pIbss = (struct IEEEtypes_IbssParamSet *) pCurrentPtr;
pBSSEntry->ATIMWindow =
- wlan_le32_to_cpu(pIbss->AtimWindow);
+ le32_to_cpu(pIbss->AtimWindow);
memmove(&pBSSEntry->SsParamSet.IbssParamSet, pIbss,
sizeof(struct IEEEtypes_IbssParamSet));
pBSSEntry->SsParamSet.IbssParamSet.AtimWindow
=
- wlan_le16_to_cpu(pBSSEntry->SsParamSet.IbssParamSet.
+ le16_to_cpu(pBSSEntry->SsParamSet.IbssParamSet.
AtimWindow);
break;
@@ -2102,10 +2102,10 @@ int libertas_cmd_80211_scan(wlan_private
memcpy(pScan->BSSID, pScanCfg->specificBSSID, sizeof(pScan->BSSID));
memcpy(pScan->TlvBuffer, pScanCfg->tlvBuffer, pScanCfg->tlvBufferLen);
- cmd->Command = wlan_cpu_to_le16(HostCmd_CMD_802_11_SCAN);
+ cmd->Command = cpu_to_le16(HostCmd_CMD_802_11_SCAN);
/* Size is equal to the sizeof(fixed portions) + the TLV len + header */
- cmd->Size = wlan_cpu_to_le16(sizeof(pScan->BSSType)
+ cmd->Size = cpu_to_le16(sizeof(pScan->BSSType)
+ sizeof(pScan->BSSID)
+ pScanCfg->tlvBufferLen + S_DS_GEN);
@@ -2167,10 +2167,10 @@ int libertas_ret_80211_scan(wlan_private
return WLAN_STATUS_FAILURE;
}
- bytesLeft = wlan_le16_to_cpu(pScan->BSSDescriptSize);
+ bytesLeft = le16_to_cpu(pScan->BSSDescriptSize);
dprintk(1, "SCAN_RESP: BSSDescriptSize %d\n", bytesLeft);
- scanRespSize = wlan_le16_to_cpu(resp->Size);
+ scanRespSize = le16_to_cpu(resp->Size);
dprintk(1, "SCAN_RESP: returned %d AP before parsing\n",
pScan->NumberOfSets);
@@ -2271,7 +2271,7 @@ int libertas_ret_80211_scan(wlan_private
if (pTsfTlv) {
memcpy(&tsfVal, &pTsfTlv->tsfTable[idx],
sizeof(tsfVal));
- tsfVal = wlan_le64_to_cpu(tsfVal);
+ tsfVal = le64_to_cpu(tsfVal);
memcpy(&newBssEntry.networkTSF,
&tsfVal, sizeof(newBssEntry.networkTSF));
diff --git a/drivers/net/wireless/libertas/wlan_tx.c b/drivers/net/wireless/libertas/wlan_tx.c
index 282957b..114851d 100644
--- a/drivers/net/wireless/libertas/wlan_tx.c
+++ b/drivers/net/wireless/libertas/wlan_tx.c
@@ -154,6 +154,10 @@ #endif
memcpy(pLocalTxPD->TxDestAddrHigh, p802x_hdr, ETH_ALEN);
HEXDUMP("TxPD", (u8 *) pLocalTxPD, sizeof(struct TxPD));
+
+ if (IS_MESH_FRAME(skb)) {
+ pLocalTxPD->TxControl |= TxPD_MESH_FRAME;
+ }
memcpy(ptr, pLocalTxPD, sizeof(struct TxPD));
diff --git a/drivers/net/wireless/libertas/wlan_version.h b/drivers/net/wireless/libertas/wlan_version.h
index 34195f6..34d5e01 100644
--- a/drivers/net/wireless/libertas/wlan_version.h
+++ b/drivers/net/wireless/libertas/wlan_version.h
@@ -24,7 +24,7 @@ Change log:
********************************************************/
-#define DRIVER_RELEASE_VERSION "318.p4"
+#define DRIVER_RELEASE_VERSION "319.p0"
const char libertas_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION
#ifdef DEBUG_LEVEL2
diff --git a/drivers/net/wireless/libertas/wlan_wext.c b/drivers/net/wireless/libertas/wlan_wext.c
index 5e1389c..f18ba7b 100644
--- a/drivers/net/wireless/libertas/wlan_wext.c
+++ b/drivers/net/wireless/libertas/wlan_wext.c
@@ -1404,6 +1404,11 @@ static const struct iw_priv_args wlan_pr
IW_PRIV_TYPE_NONE,
"debugmode"},
{
+ WLAN_SUBCMD_MESH_SET_TTL,
+ IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+ IW_PRIV_TYPE_NONE,
+ "mesh_set_ttl"},
+ {
WLAN_SETNONE_GETONEINT,
IW_PRIV_TYPE_NONE,
IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
@@ -1449,6 +1454,21 @@ static const struct iw_priv_args wlan_pr
IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
"get_debugmode"},
{
+ WLAN_SUBCMD_FWT_CLEANUP,
+ IW_PRIV_TYPE_NONE,
+ IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+ "fwt_cleanup"},
+ {
+ WLAN_SUBCMD_FWT_TIME,
+ IW_PRIV_TYPE_NONE,
+ IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+ "fwt_time"},
+ {
+ WLAN_SUBCMD_MESH_GET_TTL,
+ IW_PRIV_TYPE_NONE,
+ IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+ "mesh_get_ttl"},
+ {
WLAN_SETNONE_GETTWELVE_CHAR,
IW_PRIV_TYPE_NONE,
IW_PRIV_TYPE_CHAR | 12,
@@ -1516,66 +1536,81 @@ #endif /* REASSOCIATION */
IW_PRIV_TYPE_NONE,
"wlanidle-off"},
{
- WLAN_SUBCMD_DFT_RESET,
+ WLAN_SUBCMD_FWT_RESET,
IW_PRIV_TYPE_NONE,
IW_PRIV_TYPE_NONE,
- "dft_reset"},
+ "fwt_reset"},
{
WLAN_SUBCMD_BT_RESET,
IW_PRIV_TYPE_NONE,
IW_PRIV_TYPE_NONE,
"bt_reset"},
{
- WLAN_SET64CHAR_GET64CHAR,
- IW_PRIV_TYPE_CHAR | 64,
- IW_PRIV_TYPE_CHAR | 64,
+ WLAN_SET128CHAR_GET128CHAR,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
""},
{
WLANSLEEPPARAMS,
- IW_PRIV_TYPE_CHAR | 64,
- IW_PRIV_TYPE_CHAR | 64,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
"sleepparams"},
- /* DFT Management */
- {
- WLAN_SUBCMD_DFT_ADD,
- IW_PRIV_TYPE_CHAR | 64,
- IW_PRIV_TYPE_CHAR | 64,
- "dft_add"},
- {
- WLAN_SUBCMD_DFT_DEL,
- IW_PRIV_TYPE_CHAR | 64,
- IW_PRIV_TYPE_CHAR | 64,
- "dft_del"},
- {
- WLAN_SUBCMD_DFT_LIST,
- IW_PRIV_TYPE_CHAR | 64,
- IW_PRIV_TYPE_CHAR | 64,
- "dft_list"},
/* BT Management */
{
WLAN_SUBCMD_BT_ADD,
- IW_PRIV_TYPE_CHAR | 64,
- IW_PRIV_TYPE_CHAR | 64,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
"bt_add"},
{
WLAN_SUBCMD_BT_DEL,
- IW_PRIV_TYPE_CHAR | 64,
- IW_PRIV_TYPE_CHAR | 64,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
"bt_del"},
{
WLAN_SUBCMD_BT_LIST,
- IW_PRIV_TYPE_CHAR | 64,
- IW_PRIV_TYPE_CHAR | 64,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
"bt_list"},
+ /* FWT Management */
+ {
+ WLAN_SUBCMD_FWT_ADD,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
+ "fwt_add"},
+ {
+ WLAN_SUBCMD_FWT_DEL,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
+ "fwt_del"},
+ {
+ WLAN_SUBCMD_FWT_LOOKUP,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
+ "fwt_lookup"},
+ {
+ WLAN_SUBCMD_FWT_LIST_NEIGHBOR,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
+ "fwt_list_neigh"},
+ {
+ WLAN_SUBCMD_FWT_LIST,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
+ "fwt_list"},
+ {
+ WLAN_SUBCMD_FWT_LIST_ROUTE,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
+ "fwt_list_route"},
{
WLANSCAN_MODE,
- IW_PRIV_TYPE_CHAR | 64,
- IW_PRIV_TYPE_CHAR | 64,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
"scanmode"},
{
WLAN_GET_ADHOC_STATUS,
- IW_PRIV_TYPE_CHAR | 64,
- IW_PRIV_TYPE_CHAR | 64,
+ IW_PRIV_TYPE_CHAR | 128,
+ IW_PRIV_TYPE_CHAR | 128,
"getadhocstatus"},
{
WLAN_SETWORDCHAR_GETNONE,
diff --git a/drivers/net/wireless/libertas/wlan_wext.h b/drivers/net/wireless/libertas/wlan_wext.h
index 291928a..359c798 100644
--- a/drivers/net/wireless/libertas/wlan_wext.h
+++ b/drivers/net/wireless/libertas/wlan_wext.h
@@ -64,8 +64,8 @@ #endif /* REASSOCIATION */
#define WLANWLANIDLEON 10
#define WLANWLANIDLEOFF 11
-#define WLAN_SUBCMD_DFT_RESET 12
#define WLAN_SUBCMD_BT_RESET 13
+#define WLAN_SUBCMD_FWT_RESET 14
#define WLANGETLOG (WLANIOCTL + 9)
#define WLAN_SETCONF_GETCONF (WLANIOCTL + 10)
@@ -88,6 +88,9 @@ #define WLANGETBCNAVG 5
#define WLAN_GET_LINKMODE 6
#define WLAN_GET_RADIOMODE 7
#define WLAN_GET_DEBUGMODE 8
+#define WLAN_SUBCMD_FWT_CLEANUP 15
+#define WLAN_SUBCMD_FWT_TIME 16
+#define WLAN_SUBCMD_MESH_GET_TTL 17
#define WLAN_SETTENCHAR_GETNONE (WLANIOCTL + 16)
@@ -129,19 +132,23 @@ #define WLANSETDATAAVG 14
#define WLAN_SET_LINKMODE 15
#define WLAN_SET_RADIOMODE 16
#define WLAN_SET_DEBUGMODE 17
+#define WLAN_SUBCMD_MESH_SET_TTL 18
-#define WLAN_SET64CHAR_GET64CHAR (WLANIOCTL + 25)
+#define WLAN_SET128CHAR_GET128CHAR (WLANIOCTL + 25)
#define WLANSLEEPPARAMS 2
#define WLANSCAN_MODE 6
#define WLAN_GET_ADHOC_STATUS 9
-#define WLAN_SUBCMD_DFT_ADD 15
-#define WLAN_SUBCMD_DFT_DEL 16
-#define WLAN_SUBCMD_DFT_LIST 17
#define WLAN_SUBCMD_BT_ADD 18
#define WLAN_SUBCMD_BT_DEL 19
#define WLAN_SUBCMD_BT_LIST 20
+#define WLAN_SUBCMD_FWT_ADD 21
+#define WLAN_SUBCMD_FWT_DEL 22
+#define WLAN_SUBCMD_FWT_LOOKUP 23
+#define WLAN_SUBCMD_FWT_LIST_NEIGHBOR 24
+#define WLAN_SUBCMD_FWT_LIST 25
+#define WLAN_SUBCMD_FWT_LIST_ROUTE 26
#define WLANEXTSCAN (WLANIOCTL + 26)
More information about the Commits-kernel
mailing list