[mirror_ubuntu-bionic-kernel.git] / drivers / net / wireless / iwmc3200wifi / hal.c

/*
 * Intel Wireless Multicomm 3200 WiFi driver
 *
 * Copyright (C) 2009 Intel Corporation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *   * Neither the name of Intel Corporation nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Intel Corporation <ilw@linux.intel.com>
 * Samuel Ortiz <samuel.ortiz@intel.com>
 * Zhu Yi <yi.zhu@intel.com>
 *
 */

/*
 * Hardware Abstraction Layer for iwm.
 *
 * This file mostly defines an abstraction API for
 * sending various commands to the target.
 *
 * We have 2 types of commands: wifi and non-wifi ones.
 *
 * - wifi commands:
 *   They are used for sending LMAC and UMAC commands,
 *   and thus are the most commonly used ones.
 *   There are 2 different wifi command types, the regular
 *   one and the LMAC one. The former is used to send
 *   UMAC commands (see UMAC_CMD_OPCODE_* from umac.h)
 *   while the latter is used for sending commands to the
 *   LMAC. If you look at LMAC commands you'll se that they
 *   are actually regular iwlwifi target commands encapsulated
 *   into a special UMAC command called UMAC passthrough.
 *   This is due to the fact the host talks exclusively
 *   to the UMAC and so there needs to be a special UMAC
 *   command for talking to the LMAC.
 *   This is how a wifi command is laid out:
 *    ------------------------
 *   | iwm_udma_out_wifi_hdr  |
 *    ------------------------
 *   | SW meta_data (32 bits) |
 *    ------------------------
 *   | iwm_dev_cmd_hdr        |
 *    ------------------------
 *   | payload                |
 *   | ....                   |
 *
 * - non-wifi, or general commands:
 *   Those commands are handled by the device's bootrom,
 *   and are typically sent when the UMAC and the LMAC
 *   are not yet available.
 *    *   This is how a non-wifi command is laid out:
 *    ---------------------------
 *   | iwm_udma_out_nonwifi_hdr  |
 *    ---------------------------
 *   | payload                   |
 *   | ....                      |

 *
 * All the commands start with a UDMA header, which is
 * basically a 32 bits field. The 4 LSB there define
 * an opcode that allows the target to differentiate
 * between wifi (opcode is 0xf) and non-wifi commands
 * (opcode is [0..0xe]).
 *
 * When a command (wifi or non-wifi) is supposed to receive
 * an answer, we queue the command buffer. When we do receive
 * a command response from the UMAC, we go through the list
 * of pending command, and pass both the command and the answer
 * to the rx handler. Each command is sent with a unique
 * sequence id, and the answer is sent with the same one. This
 * is how we're supposed to match an answer with its command.
 * See rx.c:iwm_rx_handle_[non]wifi() and iwm_get_pending_[non]wifi()
 * for the implementation details.
 */
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/slab.h>

#include "iwm.h"
#include "bus.h"
#include "hal.h"
#include "umac.h"
#include "debug.h"
#include "trace.h"

static int iwm_nonwifi_cmd_init(struct iwm_priv *iwm,
				struct iwm_nonwifi_cmd *cmd,
				struct iwm_udma_nonwifi_cmd *udma_cmd)
{
	INIT_LIST_HEAD(&cmd->pending);

	spin_lock(&iwm->cmd_lock);

	cmd->resp_received = 0;

	cmd->seq_num = iwm->nonwifi_seq_num;
	udma_cmd->seq_num = cpu_to_le16(cmd->seq_num);

	iwm->nonwifi_seq_num++;
	iwm->nonwifi_seq_num %= UMAC_NONWIFI_SEQ_NUM_MAX;

	if (udma_cmd->resp)
		list_add_tail(&cmd->pending, &iwm->nonwifi_pending_cmd);

	spin_unlock(&iwm->cmd_lock);

	cmd->buf.start = cmd->buf.payload;
	cmd->buf.len = 0;

	memcpy(&cmd->udma_cmd, udma_cmd, sizeof(*udma_cmd));

	return cmd->seq_num;
}

u16 iwm_alloc_wifi_cmd_seq(struct iwm_priv *iwm)
{
	u16 seq_num = iwm->wifi_seq_num;

	iwm->wifi_seq_num++;
	iwm->wifi_seq_num %= UMAC_WIFI_SEQ_NUM_MAX;

	return seq_num;
}

static void iwm_wifi_cmd_init(struct iwm_priv *iwm,
			      struct iwm_wifi_cmd *cmd,
			      struct iwm_udma_wifi_cmd *udma_cmd,
			      struct iwm_umac_cmd *umac_cmd,
			      struct iwm_lmac_cmd *lmac_cmd,
			      u16 payload_size)
{
	INIT_LIST_HEAD(&cmd->pending);

	spin_lock(&iwm->cmd_lock);

	cmd->seq_num = iwm_alloc_wifi_cmd_seq(iwm);
	umac_cmd->seq_num = cpu_to_le16(cmd->seq_num);

	if (umac_cmd->resp)
		list_add_tail(&cmd->pending, &iwm->wifi_pending_cmd);

	spin_unlock(&iwm->cmd_lock);

	cmd->buf.start = cmd->buf.payload;
	cmd->buf.len = 0;

	if (lmac_cmd) {
		cmd->buf.start -= sizeof(struct iwm_lmac_hdr);

		lmac_cmd->seq_num = cpu_to_le16(cmd->seq_num);
		lmac_cmd->count = cpu_to_le16(payload_size);

		memcpy(&cmd->lmac_cmd, lmac_cmd, sizeof(*lmac_cmd));

		umac_cmd->count = cpu_to_le16(sizeof(struct iwm_lmac_hdr));
	} else
		umac_cmd->count = 0;

	umac_cmd->count = cpu_to_le16(payload_size +
				      le16_to_cpu(umac_cmd->count));
	udma_cmd->count = cpu_to_le16(sizeof(struct iwm_umac_fw_cmd_hdr) +
				      le16_to_cpu(umac_cmd->count));

	memcpy(&cmd->udma_cmd, udma_cmd, sizeof(*udma_cmd));
	memcpy(&cmd->umac_cmd, umac_cmd, sizeof(*umac_cmd));
}

void iwm_cmd_flush(struct iwm_priv *iwm)
{
	struct iwm_wifi_cmd *wcmd, *wnext;
	struct iwm_nonwifi_cmd *nwcmd, *nwnext;

	list_for_each_entry_safe(wcmd, wnext, &iwm->wifi_pending_cmd, pending) {
		list_del(&wcmd->pending);
		kfree(wcmd);
	}

	list_for_each_entry_safe(nwcmd, nwnext, &iwm->nonwifi_pending_cmd,
				 pending) {
		list_del(&nwcmd->pending);
		kfree(nwcmd);
	}
}

struct iwm_wifi_cmd *iwm_get_pending_wifi_cmd(struct iwm_priv *iwm, u16 seq_num)
{
	struct iwm_wifi_cmd *cmd;

	list_for_each_entry(cmd, &iwm->wifi_pending_cmd, pending)
		if (cmd->seq_num == seq_num) {
			list_del(&cmd->pending);
			return cmd;
		}

	return NULL;
}

struct iwm_nonwifi_cmd *iwm_get_pending_nonwifi_cmd(struct iwm_priv *iwm,
						    u8 seq_num, u8 cmd_opcode)
{
	struct iwm_nonwifi_cmd *cmd;

	list_for_each_entry(cmd, &iwm->nonwifi_pending_cmd, pending)
		if ((cmd->seq_num == seq_num) &&
		    (cmd->udma_cmd.opcode == cmd_opcode) &&
		    (cmd->resp_received)) {
			list_del(&cmd->pending);
			return cmd;
		}

	return NULL;
}

static void iwm_build_udma_nonwifi_hdr(struct iwm_priv *iwm,
				       struct iwm_udma_out_nonwifi_hdr *hdr,
				       struct iwm_udma_nonwifi_cmd *cmd)
{
	memset(hdr, 0, sizeof(*hdr));

	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_OPCODE, cmd->opcode);
	SET_VAL32(hdr->cmd, UDMA_HDI_OUT_NW_CMD_RESP, cmd->resp);
	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_EOT, 1);
	SET_VAL32(hdr->cmd, UDMA_HDI_OUT_NW_CMD_HANDLE_BY_HW,
		  cmd->handle_by_hw);
	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_SIGNATURE, UMAC_HDI_OUT_SIGNATURE);
	SET_VAL32(hdr->cmd, UDMA_HDI_OUT_CMD_NON_WIFI_HW_SEQ_NUM,
		  le16_to_cpu(cmd->seq_num));

	hdr->addr = cmd->addr;
	hdr->op1_sz = cmd->op1_sz;
	hdr->op2 = cmd->op2;
}

static int iwm_send_udma_nonwifi_cmd(struct iwm_priv *iwm,
				     struct iwm_nonwifi_cmd *cmd)
{
	struct iwm_udma_out_nonwifi_hdr *udma_hdr;
	struct iwm_nonwifi_cmd_buff *buf;
	struct iwm_udma_nonwifi_cmd *udma_cmd = &cmd->udma_cmd;

	buf = &cmd->buf;

	buf->start -= sizeof(struct iwm_umac_nonwifi_out_hdr);
	buf->len += sizeof(struct iwm_umac_nonwifi_out_hdr);

	udma_hdr = (struct iwm_udma_out_nonwifi_hdr *)(buf->start);

	iwm_build_udma_nonwifi_hdr(iwm, udma_hdr, udma_cmd);

	IWM_DBG_CMD(iwm, DBG,
		    "Send UDMA nonwifi cmd: opcode = 0x%x, resp = 0x%x, "
		    "hw = 0x%x, seqnum = %d, addr = 0x%x, op1_sz = 0x%x, "
		    "op2 = 0x%x\n", udma_cmd->opcode, udma_cmd->resp,
		    udma_cmd->handle_by_hw, cmd->seq_num, udma_cmd->addr,
		    udma_cmd->op1_sz, udma_cmd->op2);

	trace_iwm_tx_nonwifi_cmd(iwm, udma_hdr);
	return iwm_bus_send_chunk(iwm, buf->start, buf->len);
}

void iwm_udma_wifi_hdr_set_eop(struct iwm_priv *iwm, u8 *buf, u8 eop)
{
	struct iwm_udma_out_wifi_hdr *hdr = (struct iwm_udma_out_wifi_hdr *)buf;

	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_EOT, eop);
}

void iwm_build_udma_wifi_hdr(struct iwm_priv *iwm,
			     struct iwm_udma_out_wifi_hdr *hdr,
			     struct iwm_udma_wifi_cmd *cmd)
{
	memset(hdr, 0, sizeof(*hdr));

	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_OPCODE, UMAC_HDI_OUT_OPCODE_WIFI);
	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_EOT, cmd->eop);
	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_SIGNATURE, UMAC_HDI_OUT_SIGNATURE);

	SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_BYTE_COUNT,
		  le16_to_cpu(cmd->count));
	SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_CREDIT_GRP, cmd->credit_group);
	SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_RATID, cmd->ra_tid);
	SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_LMAC_OFFSET, cmd->lmac_offset);
}

void iwm_build_umac_hdr(struct iwm_priv *iwm,
			struct iwm_umac_fw_cmd_hdr *hdr,
			struct iwm_umac_cmd *cmd)
{
	memset(hdr, 0, sizeof(*hdr));

	SET_VAL32(hdr->meta_data, UMAC_FW_CMD_BYTE_COUNT,
		  le16_to_cpu(cmd->count));
	SET_VAL32(hdr->meta_data, UMAC_FW_CMD_TX_STA_COLOR, cmd->color);
	SET_VAL8(hdr->cmd.flags, UMAC_DEV_CMD_FLAGS_RESP_REQ, cmd->resp);

	hdr->cmd.cmd = cmd->id;
	hdr->cmd.seq_num = cmd->seq_num;
}

static int iwm_send_udma_wifi_cmd(struct iwm_priv *iwm,
				  struct iwm_wifi_cmd *cmd)
{
	struct iwm_umac_wifi_out_hdr *umac_hdr;
	struct iwm_wifi_cmd_buff *buf;
	struct iwm_udma_wifi_cmd *udma_cmd = &cmd->udma_cmd;
	struct iwm_umac_cmd *umac_cmd = &cmd->umac_cmd;
	int ret;

	buf = &cmd->buf;

	buf->start -= sizeof(struct iwm_umac_wifi_out_hdr);
	buf->len += sizeof(struct iwm_umac_wifi_out_hdr);

	umac_hdr = (struct iwm_umac_wifi_out_hdr *)(buf->start);

	iwm_build_udma_wifi_hdr(iwm, &umac_hdr->hw_hdr, udma_cmd);
	iwm_build_umac_hdr(iwm, &umac_hdr->sw_hdr, umac_cmd);

	IWM_DBG_CMD(iwm, DBG,
		    "Send UDMA wifi cmd: opcode = 0x%x, UMAC opcode = 0x%x, "
		    "eop = 0x%x, count = 0x%x, credit_group = 0x%x, "
		    "ra_tid = 0x%x, lmac_offset = 0x%x, seqnum = %d\n",
		    UMAC_HDI_OUT_OPCODE_WIFI, umac_cmd->id,
		    udma_cmd->eop, udma_cmd->count, udma_cmd->credit_group,
		    udma_cmd->ra_tid, udma_cmd->lmac_offset, cmd->seq_num);

	if (umac_cmd->id == UMAC_CMD_OPCODE_WIFI_PASS_THROUGH)
		IWM_DBG_CMD(iwm, DBG, "\tLMAC opcode: 0x%x\n",
			    cmd->lmac_cmd.id);

	ret = iwm_tx_credit_alloc(iwm, udma_cmd->credit_group, buf->len);

	/* We keep sending UMAC reset regardless of the command credits.
	 * The UMAC is supposed to be reset anyway and the Tx credits are
	 * reinitialized afterwards. If we are lucky, the reset could
	 * still be done even though we have run out of credits for the
	 * command pool at this moment.*/
	if (ret && (umac_cmd->id != UMAC_CMD_OPCODE_RESET)) {
		IWM_DBG_TX(iwm, DBG, "Failed to alloc tx credit for cmd %d\n",
			   umac_cmd->id);
		return ret;
	}

	trace_iwm_tx_wifi_cmd(iwm, umac_hdr);
	return iwm_bus_send_chunk(iwm, buf->start, buf->len);
}

/* target_cmd a.k.a udma_nonwifi_cmd can be sent when UMAC is not available */
int iwm_hal_send_target_cmd(struct iwm_priv *iwm,
			    struct iwm_udma_nonwifi_cmd *udma_cmd,
			    const void *payload)
{
	struct iwm_nonwifi_cmd *cmd;
	int ret, seq_num;

	cmd = kzalloc(sizeof(struct iwm_nonwifi_cmd), GFP_KERNEL);
	if (!cmd) {
		IWM_ERR(iwm, "Couldn't alloc memory for hal cmd\n");
		return -ENOMEM;
	}

	seq_num = iwm_nonwifi_cmd_init(iwm, cmd, udma_cmd);

	if (cmd->udma_cmd.opcode == UMAC_HDI_OUT_OPCODE_WRITE ||
	    cmd->udma_cmd.opcode == UMAC_HDI_OUT_OPCODE_WRITE_PERSISTENT) {
		cmd->buf.len = le32_to_cpu(cmd->udma_cmd.op1_sz);
		memcpy(&cmd->buf.payload, payload, cmd->buf.len);
	}

	ret = iwm_send_udma_nonwifi_cmd(iwm, cmd);

	if (!udma_cmd->resp)
		kfree(cmd);

	if (ret < 0)
		return ret;

	return seq_num;
}

static void iwm_build_lmac_hdr(struct iwm_priv *iwm, struct iwm_lmac_hdr *hdr,
			       struct iwm_lmac_cmd *cmd)
{
	memset(hdr, 0, sizeof(*hdr));

	hdr->id = cmd->id;
	hdr->flags = 0; /* Is this ever used? */
	hdr->seq_num = cmd->seq_num;
}

/*
 * iwm_hal_send_host_cmd(): sends commands to the UMAC or the LMAC.
 * Sending command to the LMAC is equivalent to sending a
 * regular UMAC command with the LMAC passthrough or the LMAC
 * wrapper UMAC command IDs.
 */
int iwm_hal_send_host_cmd(struct iwm_priv *iwm,
			  struct iwm_udma_wifi_cmd *udma_cmd,
			  struct iwm_umac_cmd *umac_cmd,
			  struct iwm_lmac_cmd *lmac_cmd,
			  const void *payload, u16 payload_size)
{
	struct iwm_wifi_cmd *cmd;
	struct iwm_lmac_hdr *hdr;
	int lmac_hdr_len = 0;
	int ret;

	cmd = kzalloc(sizeof(struct iwm_wifi_cmd), GFP_KERNEL);
	if (!cmd) {
		IWM_ERR(iwm, "Couldn't alloc memory for wifi hal cmd\n");
		return -ENOMEM;
	}

	iwm_wifi_cmd_init(iwm, cmd, udma_cmd, umac_cmd, lmac_cmd, payload_size);

	if (lmac_cmd) {
		hdr = (struct iwm_lmac_hdr *)(cmd->buf.start);

		iwm_build_lmac_hdr(iwm, hdr, &cmd->lmac_cmd);
		lmac_hdr_len = sizeof(struct iwm_lmac_hdr);
	}

	memcpy(cmd->buf.payload, payload, payload_size);
	cmd->buf.len = le16_to_cpu(umac_cmd->count);

	ret = iwm_send_udma_wifi_cmd(iwm, cmd);

	/* We free the cmd if we're not expecting any response */
	if (!umac_cmd->resp)
		kfree(cmd);
	return ret;
}

/*
 * iwm_hal_send_umac_cmd(): This is a special case for
 * iwm_hal_send_host_cmd() to send direct UMAC cmd (without
 * LMAC involved).
 */
int iwm_hal_send_umac_cmd(struct iwm_priv *iwm,
			  struct iwm_udma_wifi_cmd *udma_cmd,
			  struct iwm_umac_cmd *umac_cmd,
			  const void *payload, u16 payload_size)
{
	return iwm_hal_send_host_cmd(iwm, udma_cmd, umac_cmd, NULL,
				     payload, payload_size);
}
Commit	Line	Data
bb9f8692 ZY	1	/*
	2	* Intel Wireless Multicomm 3200 WiFi driver
	3	*
	4	* Copyright (C) 2009 Intel Corporation. All rights reserved.
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions
	8	* are met:
	9	*
	10	* * Redistributions of source code must retain the above copyright
	11	* notice, this list of conditions and the following disclaimer.
	12	* * Redistributions in binary form must reproduce the above copyright
	13	* notice, this list of conditions and the following disclaimer in
	14	* the documentation and/or other materials provided with the
	15	* distribution.
	16	* * Neither the name of Intel Corporation nor the names of its
	17	* contributors may be used to endorse or promote products derived
	18	* from this software without specific prior written permission.
	19	*
	20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	21	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	22	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	23	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	24	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	25	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	26	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	27	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	28	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	29	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	30	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	31	*
	32	*
	33	* Intel Corporation <ilw@linux.intel.com>
	34	* Samuel Ortiz <samuel.ortiz@intel.com>
	35	* Zhu Yi <yi.zhu@intel.com>
	36	*
	37	*/
	38
	39	/*
	40	* Hardware Abstraction Layer for iwm.
	41	*
	42	* This file mostly defines an abstraction API for
	43	* sending various commands to the target.
	44	*
	45	* We have 2 types of commands: wifi and non-wifi ones.
	46	*
	47	* - wifi commands:
	48	* They are used for sending LMAC and UMAC commands,
	49	* and thus are the most commonly used ones.
	50	* There are 2 different wifi command types, the regular
	51	* one and the LMAC one. The former is used to send
	52	* UMAC commands (see UMAC_CMD_OPCODE_* from umac.h)
	53	* while the latter is used for sending commands to the
	54	* LMAC. If you look at LMAC commands you'll se that they
	55	* are actually regular iwlwifi target commands encapsulated
	56	* into a special UMAC command called UMAC passthrough.
77c2061d	57	* This is due to the fact the host talks exclusively
bb9f8692 ZY	58	* to the UMAC and so there needs to be a special UMAC
bb9f8692 ZY	59	* command for talking to the LMAC.
25985edc	60	* This is how a wifi command is laid out:
bb9f8692 ZY	61	* ------------------------
	62	* \| iwm_udma_out_wifi_hdr \|
	63	* ------------------------
	64	* \| SW meta_data (32 bits) \|
	65	* ------------------------
	66	* \| iwm_dev_cmd_hdr \|
	67	* ------------------------
	68	* \| payload \|
	69	* \| .... \|
	70	*
	71	* - non-wifi, or general commands:
	72	* Those commands are handled by the device's bootrom,
	73	* and are typically sent when the UMAC and the LMAC
	74	* are not yet available.
25985edc	75	* * This is how a non-wifi command is laid out:
bb9f8692 ZY	76	* ---------------------------
	77	* \| iwm_udma_out_nonwifi_hdr \|
	78	* ---------------------------
	79	* \| payload \|
	80	* \| .... \|
	81
	82	*
	83	* All the commands start with a UDMA header, which is
	84	* basically a 32 bits field. The 4 LSB there define
	85	* an opcode that allows the target to differentiate
	86	* between wifi (opcode is 0xf) and non-wifi commands
	87	* (opcode is [0..0xe]).
	88	*
	89	* When a command (wifi or non-wifi) is supposed to receive
	90	* an answer, we queue the command buffer. When we do receive
	91	* a command response from the UMAC, we go through the list
	92	* of pending command, and pass both the command and the answer
	93	* to the rx handler. Each command is sent with a unique
	94	* sequence id, and the answer is sent with the same one. This
	95	* is how we're supposed to match an answer with its command.
	96	* See rx.c:iwm_rx_handle_[non]wifi() and iwm_get_pending_[non]wifi()
	97	* for the implementation details.
	98	*/
	99	#include <linux/kernel.h>
	100	#include <linux/netdevice.h>
5a0e3ad6	101	#include <linux/slab.h>
bb9f8692 ZY	102
	103	#include "iwm.h"
	104	#include "bus.h"
	105	#include "hal.h"
	106	#include "umac.h"
	107	#include "debug.h"
34dd5feb	108	#include "trace.h"
bb9f8692	109
971ad011 ZY	110	static int iwm_nonwifi_cmd_init(struct iwm_priv *iwm,
	111	struct iwm_nonwifi_cmd *cmd,
	112	struct iwm_udma_nonwifi_cmd *udma_cmd)
bb9f8692 ZY	113	{
	114	INIT_LIST_HEAD(&cmd->pending);
	115
	116	spin_lock(&iwm->cmd_lock);
	117
	118	cmd->resp_received = 0;
	119
	120	cmd->seq_num = iwm->nonwifi_seq_num;
	121	udma_cmd->seq_num = cpu_to_le16(cmd->seq_num);
	122
971ad011	123	iwm->nonwifi_seq_num++;
bb9f8692 ZY	124	iwm->nonwifi_seq_num %= UMAC_NONWIFI_SEQ_NUM_MAX;
	125
	126	if (udma_cmd->resp)
	127	list_add_tail(&cmd->pending, &iwm->nonwifi_pending_cmd);
	128
	129	spin_unlock(&iwm->cmd_lock);
	130
	131	cmd->buf.start = cmd->buf.payload;
	132	cmd->buf.len = 0;
	133
	134	memcpy(&cmd->udma_cmd, udma_cmd, sizeof(*udma_cmd));
971ad011 ZY	135
971ad011 ZY	136	return cmd->seq_num;
bb9f8692 ZY	137	}
	138
	139	u16 iwm_alloc_wifi_cmd_seq(struct iwm_priv *iwm)
	140	{
	141	u16 seq_num = iwm->wifi_seq_num;
	142
	143	iwm->wifi_seq_num++;
	144	iwm->wifi_seq_num %= UMAC_WIFI_SEQ_NUM_MAX;
	145
	146	return seq_num;
	147	}
	148
	149	static void iwm_wifi_cmd_init(struct iwm_priv *iwm,
	150	struct iwm_wifi_cmd *cmd,
	151	struct iwm_udma_wifi_cmd *udma_cmd,
	152	struct iwm_umac_cmd *umac_cmd,
	153	struct iwm_lmac_cmd *lmac_cmd,
	154	u16 payload_size)
	155	{
	156	INIT_LIST_HEAD(&cmd->pending);
	157
	158	spin_lock(&iwm->cmd_lock);
	159
	160	cmd->seq_num = iwm_alloc_wifi_cmd_seq(iwm);
	161	umac_cmd->seq_num = cpu_to_le16(cmd->seq_num);
	162
	163	if (umac_cmd->resp)
	164	list_add_tail(&cmd->pending, &iwm->wifi_pending_cmd);
	165
	166	spin_unlock(&iwm->cmd_lock);
	167
	168	cmd->buf.start = cmd->buf.payload;
	169	cmd->buf.len = 0;
	170
	171	if (lmac_cmd) {
	172	cmd->buf.start -= sizeof(struct iwm_lmac_hdr);
	173
	174	lmac_cmd->seq_num = cpu_to_le16(cmd->seq_num);
	175	lmac_cmd->count = cpu_to_le16(payload_size);
	176
	177	memcpy(&cmd->lmac_cmd, lmac_cmd, sizeof(*lmac_cmd));
	178
	179	umac_cmd->count = cpu_to_le16(sizeof(struct iwm_lmac_hdr));
	180	} else
	181	umac_cmd->count = 0;
	182
	183	umac_cmd->count = cpu_to_le16(payload_size +
	184	le16_to_cpu(umac_cmd->count));
	185	udma_cmd->count = cpu_to_le16(sizeof(struct iwm_umac_fw_cmd_hdr) +
	186	le16_to_cpu(umac_cmd->count));
	187
	188	memcpy(&cmd->udma_cmd, udma_cmd, sizeof(*udma_cmd));
	189	memcpy(&cmd->umac_cmd, umac_cmd, sizeof(*umac_cmd));
	190	}
	191
	192	void iwm_cmd_flush(struct iwm_priv *iwm)
	193	{
	194	struct iwm_wifi_cmd wcmd, wnext;
	195	struct iwm_nonwifi_cmd nwcmd, nwnext;
	196
	197	list_for_each_entry_safe(wcmd, wnext, &iwm->wifi_pending_cmd, pending) {
	198	list_del(&wcmd->pending);
	199	kfree(wcmd);
	200	}
201
202	list_for_each_entry_safe(nwcmd, nwnext, &iwm->nonwifi_pending_cmd,
203	pending) {
204	list_del(&nwcmd->pending);
205	kfree(nwcmd);
206	}
207	}
208
209	struct iwm_wifi_cmd iwm_get_pending_wifi_cmd(struct iwm_priv iwm, u16 seq_num)
210	{
04d1c227	211	struct iwm_wifi_cmd *cmd;
bb9f8692	212
04d1c227	213	list_for_each_entry(cmd, &iwm->wifi_pending_cmd, pending)
bb9f8692 ZY	214	if (cmd->seq_num == seq_num) {
	215	list_del(&cmd->pending);
	216	return cmd;
	217	}
	218
	219	return NULL;
	220	}
	221
04d1c227 ZY	222	struct iwm_nonwifi_cmd iwm_get_pending_nonwifi_cmd(struct iwm_priv iwm,
04d1c227 ZY	223	u8 seq_num, u8 cmd_opcode)
bb9f8692	224	{
04d1c227	225	struct iwm_nonwifi_cmd *cmd;
bb9f8692	226
04d1c227	227	list_for_each_entry(cmd, &iwm->nonwifi_pending_cmd, pending)
bb9f8692 ZY	228	if ((cmd->seq_num == seq_num) &&
	229	(cmd->udma_cmd.opcode == cmd_opcode) &&
	230	(cmd->resp_received)) {
	231	list_del(&cmd->pending);
	232	return cmd;
	233	}
	234
	235	return NULL;
	236	}
	237
	238	static void iwm_build_udma_nonwifi_hdr(struct iwm_priv *iwm,
	239	struct iwm_udma_out_nonwifi_hdr *hdr,
	240	struct iwm_udma_nonwifi_cmd *cmd)
	241	{
	242	memset(hdr, 0, sizeof(*hdr));
	243
	244	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_OPCODE, cmd->opcode);
	245	SET_VAL32(hdr->cmd, UDMA_HDI_OUT_NW_CMD_RESP, cmd->resp);
	246	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_EOT, 1);
	247	SET_VAL32(hdr->cmd, UDMA_HDI_OUT_NW_CMD_HANDLE_BY_HW,
	248	cmd->handle_by_hw);
	249	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_SIGNATURE, UMAC_HDI_OUT_SIGNATURE);
	250	SET_VAL32(hdr->cmd, UDMA_HDI_OUT_CMD_NON_WIFI_HW_SEQ_NUM,
	251	le16_to_cpu(cmd->seq_num));
	252
	253	hdr->addr = cmd->addr;
	254	hdr->op1_sz = cmd->op1_sz;
	255	hdr->op2 = cmd->op2;
	256	}
	257
	258	static int iwm_send_udma_nonwifi_cmd(struct iwm_priv *iwm,
	259	struct iwm_nonwifi_cmd *cmd)
	260	{
	261	struct iwm_udma_out_nonwifi_hdr *udma_hdr;
	262	struct iwm_nonwifi_cmd_buff *buf;
	263	struct iwm_udma_nonwifi_cmd *udma_cmd = &cmd->udma_cmd;
	264
	265	buf = &cmd->buf;
	266
	267	buf->start -= sizeof(struct iwm_umac_nonwifi_out_hdr);
	268	buf->len += sizeof(struct iwm_umac_nonwifi_out_hdr);
	269
	270	udma_hdr = (struct iwm_udma_out_nonwifi_hdr *)(buf->start);
	271
	272	iwm_build_udma_nonwifi_hdr(iwm, udma_hdr, udma_cmd);
	273
	274	IWM_DBG_CMD(iwm, DBG,
	275	"Send UDMA nonwifi cmd: opcode = 0x%x, resp = 0x%x, "
	276	"hw = 0x%x, seqnum = %d, addr = 0x%x, op1_sz = 0x%x, "
	277	"op2 = 0x%x\n", udma_cmd->opcode, udma_cmd->resp,
	278	udma_cmd->handle_by_hw, cmd->seq_num, udma_cmd->addr,
	279	udma_cmd->op1_sz, udma_cmd->op2);
	280
34dd5feb	281	trace_iwm_tx_nonwifi_cmd(iwm, udma_hdr);
bb9f8692 ZY	282	return iwm_bus_send_chunk(iwm, buf->start, buf->len);
	283	}
	284
	285	void iwm_udma_wifi_hdr_set_eop(struct iwm_priv iwm, u8 buf, u8 eop)
	286	{
	287	struct iwm_udma_out_wifi_hdr hdr = (struct iwm_udma_out_wifi_hdr )buf;
	288
	289	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_EOT, eop);
	290	}
	291
	292	void iwm_build_udma_wifi_hdr(struct iwm_priv *iwm,
	293	struct iwm_udma_out_wifi_hdr *hdr,
	294	struct iwm_udma_wifi_cmd *cmd)
	295	{
	296	memset(hdr, 0, sizeof(*hdr));
	297
	298	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_OPCODE, UMAC_HDI_OUT_OPCODE_WIFI);
	299	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_EOT, cmd->eop);
	300	SET_VAL32(hdr->cmd, UMAC_HDI_OUT_CMD_SIGNATURE, UMAC_HDI_OUT_SIGNATURE);
	301
	302	SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_BYTE_COUNT,
	303	le16_to_cpu(cmd->count));
	304	SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_CREDIT_GRP, cmd->credit_group);
	305	SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_RATID, cmd->ra_tid);
	306	SET_VAL32(hdr->meta_data, UMAC_HDI_OUT_LMAC_OFFSET, cmd->lmac_offset);
	307	}
	308
	309	void iwm_build_umac_hdr(struct iwm_priv *iwm,
	310	struct iwm_umac_fw_cmd_hdr *hdr,
	311	struct iwm_umac_cmd *cmd)
	312	{
	313	memset(hdr, 0, sizeof(*hdr));
	314
	315	SET_VAL32(hdr->meta_data, UMAC_FW_CMD_BYTE_COUNT,
	316	le16_to_cpu(cmd->count));
	317	SET_VAL32(hdr->meta_data, UMAC_FW_CMD_TX_STA_COLOR, cmd->color);
	318	SET_VAL8(hdr->cmd.flags, UMAC_DEV_CMD_FLAGS_RESP_REQ, cmd->resp);
	319
	320	hdr->cmd.cmd = cmd->id;
	321	hdr->cmd.seq_num = cmd->seq_num;
	322	}
	323
	324	static int iwm_send_udma_wifi_cmd(struct iwm_priv *iwm,
	325	struct iwm_wifi_cmd *cmd)
	326	{
	327	struct iwm_umac_wifi_out_hdr *umac_hdr;
	328	struct iwm_wifi_cmd_buff *buf;
	329	struct iwm_udma_wifi_cmd *udma_cmd = &cmd->udma_cmd;
	330	struct iwm_umac_cmd *umac_cmd = &cmd->umac_cmd;
	331	int ret;
	332
	333	buf = &cmd->buf;
	334
	335	buf->start -= sizeof(struct iwm_umac_wifi_out_hdr);
	336	buf->len += sizeof(struct iwm_umac_wifi_out_hdr);
	337
	338	umac_hdr = (struct iwm_umac_wifi_out_hdr *)(buf->start);
	339
	340	iwm_build_udma_wifi_hdr(iwm, &umac_hdr->hw_hdr, udma_cmd);
	341	iwm_build_umac_hdr(iwm, &umac_hdr->sw_hdr, umac_cmd);
	342
	343	IWM_DBG_CMD(iwm, DBG,
	344	"Send UDMA wifi cmd: opcode = 0x%x, UMAC opcode = 0x%x, "
	345	"eop = 0x%x, count = 0x%x, credit_group = 0x%x, "
346	"ra_tid = 0x%x, lmac_offset = 0x%x, seqnum = %d\n",
347	UMAC_HDI_OUT_OPCODE_WIFI, umac_cmd->id,
348	udma_cmd->eop, udma_cmd->count, udma_cmd->credit_group,
349	udma_cmd->ra_tid, udma_cmd->lmac_offset, cmd->seq_num);
350
351	if (umac_cmd->id == UMAC_CMD_OPCODE_WIFI_PASS_THROUGH)
352	IWM_DBG_CMD(iwm, DBG, "\tLMAC opcode: 0x%x\n",
353	cmd->lmac_cmd.id);
354
355	ret = iwm_tx_credit_alloc(iwm, udma_cmd->credit_group, buf->len);
356
357	/* We keep sending UMAC reset regardless of the command credits.
358	* The UMAC is supposed to be reset anyway and the Tx credits are
359	* reinitialized afterwards. If we are lucky, the reset could
360	* still be done even though we have run out of credits for the
361	* command pool at this moment.*/
362	if (ret && (umac_cmd->id != UMAC_CMD_OPCODE_RESET)) {
363	IWM_DBG_TX(iwm, DBG, "Failed to alloc tx credit for cmd %d\n",
364	umac_cmd->id);
365	return ret;
366	}
367
34dd5feb	368	trace_iwm_tx_wifi_cmd(iwm, umac_hdr);
bb9f8692 ZY	369	return iwm_bus_send_chunk(iwm, buf->start, buf->len);
	370	}
	371
	372	/* target_cmd a.k.a udma_nonwifi_cmd can be sent when UMAC is not available */
	373	int iwm_hal_send_target_cmd(struct iwm_priv *iwm,
	374	struct iwm_udma_nonwifi_cmd *udma_cmd,
	375	const void *payload)
	376	{
	377	struct iwm_nonwifi_cmd *cmd;
971ad011	378	int ret, seq_num;
bb9f8692 ZY	379
	380	cmd = kzalloc(sizeof(struct iwm_nonwifi_cmd), GFP_KERNEL);
	381	if (!cmd) {
	382	IWM_ERR(iwm, "Couldn't alloc memory for hal cmd\n");
	383	return -ENOMEM;
	384	}
	385
971ad011	386	seq_num = iwm_nonwifi_cmd_init(iwm, cmd, udma_cmd);
bb9f8692 ZY	387
	388	if (cmd->udma_cmd.opcode == UMAC_HDI_OUT_OPCODE_WRITE \|\|
	389	cmd->udma_cmd.opcode == UMAC_HDI_OUT_OPCODE_WRITE_PERSISTENT) {
	390	cmd->buf.len = le32_to_cpu(cmd->udma_cmd.op1_sz);
	391	memcpy(&cmd->buf.payload, payload, cmd->buf.len);
	392	}
	393
	394	ret = iwm_send_udma_nonwifi_cmd(iwm, cmd);
	395
	396	if (!udma_cmd->resp)
	397	kfree(cmd);
	398
	399	if (ret < 0)
	400	return ret;
	401
971ad011	402	return seq_num;
bb9f8692 ZY	403	}
	404
	405	static void iwm_build_lmac_hdr(struct iwm_priv iwm, struct iwm_lmac_hdr hdr,
	406	struct iwm_lmac_cmd *cmd)
	407	{
	408	memset(hdr, 0, sizeof(*hdr));
	409
	410	hdr->id = cmd->id;
	411	hdr->flags = 0; /* Is this ever used? */
	412	hdr->seq_num = cmd->seq_num;
	413	}
	414
	415	/*
	416	* iwm_hal_send_host_cmd(): sends commands to the UMAC or the LMAC.
	417	* Sending command to the LMAC is equivalent to sending a
af901ca1	418	* regular UMAC command with the LMAC passthrough or the LMAC
bb9f8692 ZY	419	* wrapper UMAC command IDs.
	420	*/
	421	int iwm_hal_send_host_cmd(struct iwm_priv *iwm,
	422	struct iwm_udma_wifi_cmd *udma_cmd,
	423	struct iwm_umac_cmd *umac_cmd,
	424	struct iwm_lmac_cmd *lmac_cmd,
	425	const void *payload, u16 payload_size)
	426	{
	427	struct iwm_wifi_cmd *cmd;
	428	struct iwm_lmac_hdr *hdr;
	429	int lmac_hdr_len = 0;
	430	int ret;
	431
	432	cmd = kzalloc(sizeof(struct iwm_wifi_cmd), GFP_KERNEL);
	433	if (!cmd) {
	434	IWM_ERR(iwm, "Couldn't alloc memory for wifi hal cmd\n");
	435	return -ENOMEM;
	436	}
	437
	438	iwm_wifi_cmd_init(iwm, cmd, udma_cmd, umac_cmd, lmac_cmd, payload_size);
	439
	440	if (lmac_cmd) {
	441	hdr = (struct iwm_lmac_hdr *)(cmd->buf.start);
	442
	443	iwm_build_lmac_hdr(iwm, hdr, &cmd->lmac_cmd);
	444	lmac_hdr_len = sizeof(struct iwm_lmac_hdr);
	445	}
	446
	447	memcpy(cmd->buf.payload, payload, payload_size);
	448	cmd->buf.len = le16_to_cpu(umac_cmd->count);
	449
	450	ret = iwm_send_udma_wifi_cmd(iwm, cmd);
	451
	452	/* We free the cmd if we're not expecting any response */
	453	if (!umac_cmd->resp)
	454	kfree(cmd);
	455	return ret;
	456	}
	457
	458	/*
	459	* iwm_hal_send_umac_cmd(): This is a special case for
	460	* iwm_hal_send_host_cmd() to send direct UMAC cmd (without
	461	* LMAC involved).
	462	*/
	463	int iwm_hal_send_umac_cmd(struct iwm_priv *iwm,
	464	struct iwm_udma_wifi_cmd *udma_cmd,
	465	struct iwm_umac_cmd *umac_cmd,
	466	const void *payload, u16 payload_size)
	467	{
	468	return iwm_hal_send_host_cmd(iwm, udma_cmd, umac_cmd, NULL,
	469	payload, payload_size);
	470	}