/*
* ---------------------------------------------------------------------------
* FILE: mlme.c
*
* PURPOSE:
* This file provides functions to send MLME requests to the UniFi.
*
* Copyright (C) 2007-2008 by Cambridge Silicon Radio Ltd.
*
* Refer to LICENSE.txt included with this source code for details on
* the license terms.
*
* ---------------------------------------------------------------------------
*/
#include "csr_wifi_hip_unifi.h"
#include "unifi_priv.h"
/*
* ---------------------------------------------------------------------------
* unifi_mlme_wait_for_reply
*
* Wait for a reply after sending a signal.
*
* Arguments:
* priv Pointer to device private context struct
* ul_client Pointer to linux client
* sig_reply_id ID of the expected reply (defined in sigs.h).
* timeout timeout in ms
*
* Returns:
* 0 on success, -ve POSIX code on error.
*
* Notes:
* This function waits for a specific (sig_reply_id) signal from UniFi.
* It also match the sequence number of the received (cfm) signal, with
* the latest sequence number of the signal (req) we have sent.
* These two number match be equal.
* Should only be used for waiting xxx.cfm signals and only after
* we have sent the matching xxx.req signal to UniFi.
* If no response is received within the expected time (timeout), we assume
* that the UniFi is busy and return an error.
* If the wait is aborted by a kernel signal arriving, we stop waiting.
* If a response from UniFi is not what we expected, we discard it and
* wait again. This could be a response from an aborted request. If we
* see several bad responses we assume we have lost synchronisation with
* UniFi.
* ---------------------------------------------------------------------------
*/
static int
unifi_mlme_wait_for_reply(unifi_priv_t *priv, ul_client_t *pcli, int sig_reply_id, int timeout)
{
int retries = 0;
long r;
long t = timeout;
unsigned int sent_seq_no;
/* Convert t in ms to jiffies */
t = msecs_to_jiffies(t);
do {
/* Wait for the confirm or timeout. */
r = wait_event_interruptible_timeout(pcli->udi_wq,
(pcli->wake_up_wq_id) || (priv->io_aborted == 1),
t);
/* Check for general i/o error */
if (priv->io_aborted) {
unifi_error(priv, "MLME operation aborted\n");
return -EIO;
}
/*
* If r=0 the request has timed-out.
* If r>0 the request has completed successfully.
* If r=-ERESTARTSYS an event (kill signal) has interrupted the wait_event.
*/
if ((r == 0) && (pcli->wake_up_wq_id == 0)) {
unifi_error(priv, "mlme_wait: timed-out waiting for 0x%.4X, after %lu msec.\n",
sig_reply_id, jiffies_to_msecs(t));
pcli->wake_up_wq_id = 0;
return -ETIMEDOUT;
} else if (r == -ERESTARTSYS) {
unifi_error(priv, "mlme_wait: waiting for 0x%.4X was aborted.\n", sig_reply_id);
pcli->wake_up_wq_id = 0;
return -EINTR;
} else {
/* Get the sequence number of the signal that we previously set. */
if (pcli->seq_no != 0) {
sent_seq_no = pcli->seq_no - 1;
} else {
sent_seq_no = 0x0F;
}
unifi_trace(priv, UDBG5, "Received 0x%.4X, seq: (r:%d, s:%d)\n",
pcli->wake_up_wq_id,
pcli->wake_seq_no, sent_seq_no);
/* The two sequence ids must match. */
if (pcli->wake_seq_no == sent_seq_no) {
/* and the signal ids must match. */
if (sig_reply_id == pcli->wake_up_wq_id) {
/* Found the expected signal */
break;
} else {
/* This should never happen ... */
unifi_error(priv, "mlme_wait: mismatching signal id (0x%.4X - exp 0x%.4X) (seq %d)\n",
pcli->wake_up_wq_id,
sig_reply_id,
pcli->wake_seq_no);
pcli->wake_up_wq_id = 0;
return -EIO;
}
}
/* Wait for the next signal. */
pcli->wake_up_wq_id = 0;
retries ++;
if (retries >= 3) {
unifi_error(priv, "mlme_wait: confirm wait retries exhausted (0x%.4X - exp 0x%.4X)\n",
pcli->wake_up_wq_id,
sig_reply_id);
pcli->wake_up_wq_id = 0;
return -EIO;
}
}
} while (1);
pcli->wake_up_wq_id = 0;
return 0;
} /* unifi_mlme_wait_for_reply() */
/*
* ---------------------------------------------------------------------------
* unifi_mlme_blocking_request
*
* Send a MLME request signal to UniFi.
*
* Arguments:
* priv Pointer to device private context struct
* pcli Pointer to context of calling process
* sig Pointer to the signal to send
* data_ptrs Pointer to the bulk data of the signal
* timeout The request's timeout.
*
* Returns:
* 0 on success, 802.11 result code on error.
* ---------------------------------------------------------------------------
*/
int
unifi_mlme_blocking_request(unifi_priv_t *priv, ul_client_t *pcli,
CSR_SIGNAL *sig, bulk_data_param_t *data_ptrs,
int timeout)
{
int r;
if (sig->SignalPrimitiveHeader.SignalId == 0) {
unifi_error(priv, "unifi_mlme_blocking_request: Invalid Signal Id (0x%x)\n",
sig->SignalPrimitiveHeader.SignalId);
return -EINVAL;
}
down(&priv->mlme_blocking_mutex);
sig->SignalPrimitiveHeader.ReceiverProcessId = 0;
sig->SignalPrimitiveHeader.SenderProcessId = pcli->sender_id | pcli->seq_no;
unifi_trace(priv, UDBG2, "Send client=%d, S:0x%04X, sig 0x%.4X\n",
pcli->client_id,
sig->SignalPrimitiveHeader.SenderProcessId,
sig->SignalPrimitiveHeader.SignalId);
/* Send the signal to UniFi */
r = ul_send_signal_unpacked(priv, sig, data_ptrs);
if (r) {
up(&priv->mlme_blocking_mutex);
unifi_error(priv, "Error queueing MLME REQUEST signal\n");
return r;
}
unifi_trace(priv, UDBG5, "Send 0x%.4X, seq = %d\n",
sig->SignalPrimitiveHeader.SignalId, pcli->seq_no);
/*
* Advance the sequence number of the last sent signal, only
* if the signal has been successfully set.
*/
pcli->seq_no++;
if (pcli->seq_no > 0x0F) {
pcli->seq_no = 0;
}
r = unifi_mlme_wait_for_reply(priv, pcli, (sig->SignalPrimitiveHeader.SignalId + 1), timeout);
up(&priv->mlme_blocking_mutex);
if (r) {
unifi_error(priv, "Error waiting for MLME CONFIRM signal\n");
return r;
}
return 0;
} /* unifi_mlme_blocking_request() */
/*
* ---------------------------------------------------------------------------
* unifi_mlme_copy_reply_and_wakeup_client
*
* Copy the reply signal from UniFi to the client's structure
* and wake up the waiting client.
*
* Arguments:
* None.
*
* Returns:
* None.
* ---------------------------------------------------------------------------
*/
void
unifi_mlme_copy_reply_and_wakeup_client(ul_client_t *pcli,
CSR_SIGNAL *signal, int signal_len,
const bulk_data_param_t *bulkdata)
{
int i;
/* Copy the signal to the reply */
memcpy(pcli->reply_signal, signal, signal_len);
/* Get the sequence number of the signal that woke us up. */
pcli->wake_seq_no = pcli->reply_signal->SignalPrimitiveHeader.ReceiverProcessId & 0x0F;
/* Append any bulk data */
for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
if (bulkdata->d[i].data_length > 0) {
if (bulkdata->d[i].os_data_ptr) {
memcpy(pcli->reply_bulkdata[i]->ptr, bulkdata->d[i].os_data_ptr, bulkdata->d[i].data_length);
pcli->reply_bulkdata[i]->length = bulkdata->d[i].data_length;
} else {
pcli->reply_bulkdata[i]->length = 0;
}
}
}
/* Wake the requesting MLME function. */
pcli->wake_up_wq_id = pcli->reply_signal->SignalPrimitiveHeader.SignalId;
wake_up_interruptible(&pcli->udi_wq);
} /* unifi_mlme_copy_reply_and_wakeup_client() */
/*
* ---------------------------------------------------------------------------
* uf_abort_mlme
*
* Abort any MLME operation in progress.
* This is used in the error recovery mechanism.
*
* Arguments:
* priv Pointer to driver context.
*
* Returns:
* 0 on success.
* ---------------------------------------------------------------------------
*/
int
uf_abort_mlme(unifi_priv_t *priv)
{
ul_client_t *ul_cli;
/* Ensure no MLME functions are waiting on a the mlme_event semaphore. */
priv->io_aborted = 1;
ul_cli = priv->netdev_client;
if (ul_cli) {
wake_up_interruptible(&ul_cli->udi_wq);
}
ul_cli = priv->wext_client;
if (ul_cli) {
wake_up_interruptible(&ul_cli->udi_wq);
}
return 0;
} /* uf_abort_mlme() */
/*
* ---------------------------------------------------------------------------
*
* Human-readable decoding of Reason and Result codes.
*
* ---------------------------------------------------------------------------
*/
struct mlme_code {
const char *name;
int id;
};
static const struct mlme_code Result_codes[] = {
{ "Success", 0x0000 },
{ "Unspecified Failure", 0x0001 },
/* (Reserved) 0x0002 - 0x0009 */
{ "Refused Capabilities Mismatch", 0x000A },
/* (Reserved) 0x000B */
{ "Refused External Reason", 0x000C },
/* (Reserved) 0x000D - 0x0010 */
{ "Refused AP Out Of Memory", 0x0011 },
{ "Refused Basic Rates Mismatch", 0x0012 },
/* (Reserved) 0x0013 - 0x001F */
{ "Failure", 0x0020 },
/* (Reserved) 0x0021 - 0x0024 */
{ "Refused Reason Unspecified", 0x0025 },
{ "Invalid Parameters", 0x0026 },
{ "Rejected With Suggested Changes", 0x0027 },
/* (Reserved) 0x0028 - 0x002E */
{ "Rejected For Delay Period", 0x002F },
{ "Not Allowed", 0x0030 },
{ "Not Present", 0x0031 },
{ "Not QSTA", 0x0032 },
/* (Reserved) 0x0033 - 0x7FFF */
{ "Timeout", 0x8000 },
{ "Too Many Simultaneous Requests", 0x8001 },
{ "BSS Already Started Or Joined", 0x8002 },
{ "Not Supported", 0x8003 },
{ "Transmission Failure", 0x8004 },
{ "Refused Not Authenticated", 0x8005 },
{ "Reset Required Before Start", 0x8006 },
{ "LM Info Unavailable", 0x8007 },
{ NULL, -1 }
};
static const struct mlme_code Reason_codes[] = {
/* (Reserved) 0x0000 */
{ "Unspecified Reason", 0x0001 },
{ "Authentication Not Valid", 0x0002 },
{ "Deauthenticated Leave BSS", 0x0003 },
{ "Disassociated Inactivity", 0x0004 },
{ "AP Overload", 0x0005 },
{ "Class2 Frame Error", 0x0006 },
{ "Class3 Frame Error", 0x0007 },
{ "Disassociated Leave BSS", 0x0008 },
{ "Association Not Authenticated", 0x0009 },
{ "Disassociated Power Capability", 0x000A },
{ "Disassociated Supported Channels", 0x000B },
/* (Reserved) 0x000C */
{ "Invalid Information Element", 0x000D },
{ "Michael MIC Failure", 0x000E },
{ "Fourway Handshake Timeout", 0x000F },
{ "Group Key Update Timeout", 0x0010 },
{ "Handshake Element Different", 0x0011 },
{ "Invalid Group Cipher", 0x0012 },
{ "Invalid Pairwise Cipher", 0x0013 },
{ "Invalid AKMP", 0x0014 },
{ "Unsupported RSN IE Version", 0x0015 },
{ "Invalid RSN IE Capabilities", 0x0016 },
{ "Dot1X Auth Failed", 0x0017 },
{ "Cipher Rejected By Policy", 0x0018 },
/* (Reserved) 0x0019 - 0x001F */
{ "QoS Unspecified Reason", 0x0020 },
{ "QoS Insufficient Bandwidth", 0x0021 },
{ "QoS Excessive Not Ack", 0x0022 },
{ "QoS TXOP Limit Exceeded", 0x0023 },
{ "QSTA Leaving", 0x0024 },
{ "End TS, End DLS, End BA", 0x0025 },
{ "Unknown TS, Unknown DLS, Unknown BA", 0x0026 },
{ "Timeout", 0x0027 },
/* (Reserved) 0x0028 - 0x002C */
{ "STAKey Mismatch", 0x002D },
{ NULL, -1 }
};
static const char *
lookup_something(const struct mlme_code *n, int id)
{
for (; n->name; n++) {
if (n->id == id) {
return n->name;
}
}
/* not found */
return NULL;
} /* lookup_something() */
const char *
lookup_result_code(int result)
{
static char fallback[16];
const char *str;
str = lookup_something(Result_codes, result);
if (str == NULL) {
snprintf(fallback, 16, "%d", result);
str = fallback;
}
return str;
} /* lookup_result_code() */
/*
* ---------------------------------------------------------------------------
* lookup_reason
*
* Return a description string for a WiFi MLME ReasonCode.
*
* Arguments:
* reason The ReasonCode to interpret.
*
* Returns:
* Pointer to description string.
* ---------------------------------------------------------------------------
*/
const char *
lookup_reason_code(int reason)
{
static char fallback[16];
const char *str;
str = lookup_something(Reason_codes, reason);
if (str == NULL) {
snprintf(fallback, 16, "%d", reason);
str = fallback;
}
return str;
} /* lookup_reason_code() */