drivers/net/wireless/iwmc3200wifi/tx.c - arm/linux-arm64-legacy - Git at Google

 /*
  * 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>
  *
  */

 /*
  * iwm Tx theory of operation:
  *
  * 1) We receive a 802.3 frame from the stack
  * 2) We convert it to a 802.11 frame [iwm_xmit_frame]
  * 3) We queue it to its corresponding tx queue [iwm_xmit_frame]
  * 4) We schedule the tx worker. There is one worker per tx
  *    queue. [iwm_xmit_frame]
  * 5) The tx worker is scheduled
  * 6) We go through every queued skb on the tx queue, and for each
  *    and every one of them: [iwm_tx_worker]
  *    a) We check if we have enough Tx credits (see below for a Tx
  *       credits description) for the frame length. [iwm_tx_worker]
  *    b) If we do, we aggregate the Tx frame into a UDMA one, by
  *       concatenating one REPLY_TX command per Tx frame. [iwm_tx_worker]
  *    c) When we run out of credits, or when we reach the maximum
  *       concatenation size, we actually send the concatenated UDMA
  *       frame. [iwm_tx_worker]
  *
  * When we run out of Tx credits, the skbs are filling the tx queue,
  * and eventually we will stop the netdev queue. [iwm_tx_worker]
  * The tx queue is emptied as we're getting new tx credits, by
  * scheduling the tx_worker. [iwm_tx_credit_inc]
  * The netdev queue is started again when we have enough tx credits,
  * and when our tx queue has some reasonable amout of space available
  * (i.e. half of the max size). [iwm_tx_worker]
  */

 #include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <linux/ieee80211.h>

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

 #define IWM_UMAC_PAGE_ALLOC_WRAP 0xffff

 #define BYTES_TO_PAGES(n)	 (1 + ((n) >> ilog2(IWM_UMAC_PAGE_SIZE)) - \
 				 (((n) & (IWM_UMAC_PAGE_SIZE - 1)) == 0))

 #define pool_id_to_queue(id)	 ((id < IWM_TX_CMD_QUEUE) ? id : id - 1)
 #define queue_to_pool_id(q)	 ((q < IWM_TX_CMD_QUEUE) ? q : q + 1)

 /* require to hold tx_credit lock */
 static int iwm_tx_credit_get(struct iwm_tx_credit *tx_credit, int id)
 {
 	struct pool_entry *pool = &tx_credit->pools[id];
 	struct spool_entry *spool = &tx_credit->spools[pool->sid];
 	int spool_pages;

 	/* number of pages can be taken from spool by this pool */
 	spool_pages = spool->max_pages - spool->alloc_pages +
 		      max(pool->min_pages - pool->alloc_pages, 0);

 	return min(pool->max_pages - pool->alloc_pages, spool_pages);
 }

 static bool iwm_tx_credit_ok(struct iwm_priv *iwm, int id, int nb)
 {
 	u32 npages = BYTES_TO_PAGES(nb);

 	if (npages <= iwm_tx_credit_get(&iwm->tx_credit, id))
 		return 1;

 	set_bit(id, &iwm->tx_credit.full_pools_map);

 	IWM_DBG_TX(iwm, DBG, "LINK: stop txq[%d], available credit: %d\n",
 		   pool_id_to_queue(id),
 		   iwm_tx_credit_get(&iwm->tx_credit, id));

 	return 0;
 }

 void iwm_tx_credit_inc(struct iwm_priv *iwm, int id, int total_freed_pages)
 {
 	struct pool_entry *pool;
 	struct spool_entry *spool;
 	int freed_pages;
 	int queue;

 	BUG_ON(id >= IWM_MACS_OUT_GROUPS);

 	pool = &iwm->tx_credit.pools[id];
 	spool = &iwm->tx_credit.spools[pool->sid];

 	freed_pages = total_freed_pages - pool->total_freed_pages;
 	IWM_DBG_TX(iwm, DBG, "Free %d pages for pool[%d]\n", freed_pages, id);

 	if (!freed_pages) {
 		IWM_DBG_TX(iwm, DBG, "No pages are freed by UMAC\n");
 		return;
 	} else if (freed_pages < 0)
 		freed_pages += IWM_UMAC_PAGE_ALLOC_WRAP + 1;

 	if (pool->alloc_pages > pool->min_pages) {
 		int spool_pages = pool->alloc_pages - pool->min_pages;
 		spool_pages = min(spool_pages, freed_pages);
 		spool->alloc_pages -= spool_pages;
 	}

 	pool->alloc_pages -= freed_pages;
 	pool->total_freed_pages = total_freed_pages;

 	IWM_DBG_TX(iwm, DBG, "Pool[%d] pages alloc: %d, total_freed: %d, "
 		   "Spool[%d] pages alloc: %d\n", id, pool->alloc_pages,
 		   pool->total_freed_pages, pool->sid, spool->alloc_pages);

 	if (test_bit(id, &iwm->tx_credit.full_pools_map) &&
 	    (pool->alloc_pages < pool->max_pages / 2)) {
 		clear_bit(id, &iwm->tx_credit.full_pools_map);

 		queue = pool_id_to_queue(id);

 		IWM_DBG_TX(iwm, DBG, "LINK: start txq[%d], available "
 			   "credit: %d\n", queue,
 			   iwm_tx_credit_get(&iwm->tx_credit, id));
 		queue_work(iwm->txq[queue].wq, &iwm->txq[queue].worker);
 	}
 }

 static void iwm_tx_credit_dec(struct iwm_priv *iwm, int id, int alloc_pages)
 {
 	struct pool_entry *pool;
 	struct spool_entry *spool;
 	int spool_pages;

 	IWM_DBG_TX(iwm, DBG, "Allocate %d pages for pool[%d]\n",
 		   alloc_pages, id);

 	BUG_ON(id >= IWM_MACS_OUT_GROUPS);

 	pool = &iwm->tx_credit.pools[id];
 	spool = &iwm->tx_credit.spools[pool->sid];

 	spool_pages = pool->alloc_pages + alloc_pages - pool->min_pages;

 	if (pool->alloc_pages >= pool->min_pages)
 		spool->alloc_pages += alloc_pages;
 	else if (spool_pages > 0)
 		spool->alloc_pages += spool_pages;

 	pool->alloc_pages += alloc_pages;

 	IWM_DBG_TX(iwm, DBG, "Pool[%d] pages alloc: %d, total_freed: %d, "
 		   "Spool[%d] pages alloc: %d\n", id, pool->alloc_pages,
 		   pool->total_freed_pages, pool->sid, spool->alloc_pages);
 }

 int iwm_tx_credit_alloc(struct iwm_priv *iwm, int id, int nb)
 {
 	u32 npages = BYTES_TO_PAGES(nb);
 	int ret = 0;

 	spin_lock(&iwm->tx_credit.lock);

 	if (!iwm_tx_credit_ok(iwm, id, nb)) {
 		IWM_DBG_TX(iwm, DBG, "No credit avaliable for pool[%d]\n", id);
 		ret = -ENOSPC;
 		goto out;
 	}

 	iwm_tx_credit_dec(iwm, id, npages);

  out:
 	spin_unlock(&iwm->tx_credit.lock);
 	return ret;
 }

 /*
  * Since we're on an SDIO or USB bus, we are not sharing memory
  * for storing to be transmitted frames. The host needs to push
  * them upstream. As a consequence there needs to be a way for
  * the target to let us know if it can actually take more TX frames
  * or not. This is what Tx credits are for.
  *
  * For each Tx HW queue, we have a Tx pool, and then we have one
  * unique super pool (spool), which is actually a global pool of
  * all the UMAC pages.
  * For each Tx pool we have a min_pages, a max_pages fields, and a
  * alloc_pages fields. The alloc_pages tracks the number of pages
  * currently allocated from the tx pool.
  * Here are the rules to check if given a tx frame we have enough
  * tx credits for it:
  * 1) We translate the frame length into a number of UMAC pages.
  *    Let's call them n_pages.
  * 2) For the corresponding tx pool, we check if n_pages +
  *    pool->alloc_pages is higher than pool->min_pages. min_pages
  *    represent a set of pre-allocated pages on the tx pool. If
  *    that's the case, then we need to allocate those pages from
  *    the spool. We can do so until we reach spool->max_pages.
  * 3) Each tx pool is not allowed to allocate more than pool->max_pages
  *    from the spool, so once we're over min_pages, we can allocate
  *    pages from the spool, but not more than max_pages.
  *
  * When the tx code path needs to send a tx frame, it checks first
  * if it has enough tx credits, following those rules. [iwm_tx_credit_get]
  * If it does, it then updates the pool and spool counters and
  * then send the frame. [iwm_tx_credit_alloc and iwm_tx_credit_dec]
  * On the other side, when the UMAC is done transmitting frames, it
  * will send a credit update notification to the host. This is when
  * the pool and spool counters gets to be decreased. [iwm_tx_credit_inc,
  * called from rx.c:iwm_ntf_tx_credit_update]
  *
  */
 void iwm_tx_credit_init_pools(struct iwm_priv *iwm,
 			      struct iwm_umac_notif_alive *alive)
 {
 	int i, sid, pool_pages;

 	spin_lock(&iwm->tx_credit.lock);

 	iwm->tx_credit.pool_nr = le16_to_cpu(alive->page_grp_count);
 	iwm->tx_credit.full_pools_map = 0;
 	memset(&iwm->tx_credit.spools[0], 0, sizeof(struct spool_entry));

 	IWM_DBG_TX(iwm, DBG, "Pools number is %d\n", iwm->tx_credit.pool_nr);

 	for (i = 0; i < iwm->tx_credit.pool_nr; i++) {
 		__le32 page_grp_state = alive->page_grp_state[i];

 		iwm->tx_credit.pools[i].id = GET_VAL32(page_grp_state,
 				UMAC_ALIVE_PAGE_STS_GRP_NUM);
 		iwm->tx_credit.pools[i].sid = GET_VAL32(page_grp_state,
 				UMAC_ALIVE_PAGE_STS_SGRP_NUM);
 		iwm->tx_credit.pools[i].min_pages = GET_VAL32(page_grp_state,
 				UMAC_ALIVE_PAGE_STS_GRP_MIN_SIZE);
 		iwm->tx_credit.pools[i].max_pages = GET_VAL32(page_grp_state,
 				UMAC_ALIVE_PAGE_STS_GRP_MAX_SIZE);
 		iwm->tx_credit.pools[i].alloc_pages = 0;
 		iwm->tx_credit.pools[i].total_freed_pages = 0;

 		sid = iwm->tx_credit.pools[i].sid;
 		pool_pages = iwm->tx_credit.pools[i].min_pages;

 		if (iwm->tx_credit.spools[sid].max_pages == 0) {
 			iwm->tx_credit.spools[sid].id = sid;
 			iwm->tx_credit.spools[sid].max_pages =
 				GET_VAL32(page_grp_state,
 					  UMAC_ALIVE_PAGE_STS_SGRP_MAX_SIZE);
 			iwm->tx_credit.spools[sid].alloc_pages = 0;
 		}

 		iwm->tx_credit.spools[sid].alloc_pages += pool_pages;

 		IWM_DBG_TX(iwm, DBG, "Pool idx: %d, id: %d, sid: %d, capacity "
 			   "min: %d, max: %d, pool alloc: %d, total_free: %d, "
 			   "super poll alloc: %d\n",
 			   i, iwm->tx_credit.pools[i].id,
 			   iwm->tx_credit.pools[i].sid,
 			   iwm->tx_credit.pools[i].min_pages,
 			   iwm->tx_credit.pools[i].max_pages,
 			   iwm->tx_credit.pools[i].alloc_pages,
 			   iwm->tx_credit.pools[i].total_freed_pages,
 			   iwm->tx_credit.spools[sid].alloc_pages);
 	}

 	spin_unlock(&iwm->tx_credit.lock);
 }

 #define IWM_UDMA_HDR_LEN	sizeof(struct iwm_umac_wifi_out_hdr)

 static __le16 iwm_tx_build_packet(struct iwm_priv *iwm, struct sk_buff *skb,
 				  int pool_id, u8 *buf)
 {
 	struct iwm_umac_wifi_out_hdr *hdr = (struct iwm_umac_wifi_out_hdr *)buf;
 	struct iwm_udma_wifi_cmd udma_cmd;
 	struct iwm_umac_cmd umac_cmd;
 	struct iwm_tx_info *tx_info = skb_to_tx_info(skb);

 	udma_cmd.count = cpu_to_le16(skb->len +
 				     sizeof(struct iwm_umac_fw_cmd_hdr));
 	/* set EOP to 0 here. iwm_udma_wifi_hdr_set_eop() will be
 	 * called later to set EOP for the last packet. */
 	udma_cmd.eop = 0;
 	udma_cmd.credit_group = pool_id;
 	udma_cmd.ra_tid = tx_info->sta << 4 | tx_info->tid;
 	udma_cmd.lmac_offset = 0;

 	umac_cmd.id = REPLY_TX;
 	umac_cmd.count = cpu_to_le16(skb->len);
 	umac_cmd.color = tx_info->color;
 	umac_cmd.resp = 0;
 	umac_cmd.seq_num = cpu_to_le16(iwm_alloc_wifi_cmd_seq(iwm));

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

 	memcpy(buf + sizeof(*hdr), skb->data, skb->len);

 	return umac_cmd.seq_num;
 }

 static int iwm_tx_send_concat_packets(struct iwm_priv *iwm,
 				      struct iwm_tx_queue *txq)
 {
 	int ret;

 	if (!txq->concat_count)
 		return 0;

 	IWM_DBG_TX(iwm, DBG, "Send concatenated Tx: queue %d, %d bytes\n",
 		   txq->id, txq->concat_count);

 	/* mark EOP for the last packet */
 	iwm_udma_wifi_hdr_set_eop(iwm, txq->concat_ptr, 1);

 	trace_iwm_tx_packets(iwm, txq->concat_buf, txq->concat_count);
 	ret = iwm_bus_send_chunk(iwm, txq->concat_buf, txq->concat_count);

 	txq->concat_count = 0;
 	txq->concat_ptr = txq->concat_buf;

 	return ret;
 }

 void iwm_tx_worker(struct work_struct *work)
 {
 	struct iwm_priv *iwm;
 	struct iwm_tx_info *tx_info = NULL;
 	struct sk_buff *skb;
 	struct iwm_tx_queue *txq;
 	struct iwm_sta_info *sta_info;
 	struct iwm_tid_info *tid_info;
 	int cmdlen, ret, pool_id;

 	txq = container_of(work, struct iwm_tx_queue, worker);
 	iwm = container_of(txq, struct iwm_priv, txq[txq->id]);

 	pool_id = queue_to_pool_id(txq->id);

 	while (!test_bit(pool_id, &iwm->tx_credit.full_pools_map) &&
 	       !skb_queue_empty(&txq->queue)) {

 		spin_lock_bh(&txq->lock);
 		skb = skb_dequeue(&txq->queue);
 		spin_unlock_bh(&txq->lock);

 		tx_info = skb_to_tx_info(skb);
 		sta_info = &iwm->sta_table[tx_info->sta];
 		if (!sta_info->valid) {
 			IWM_ERR(iwm, "Trying to send a frame to unknown STA\n");
 			kfree_skb(skb);
 			continue;
 		}

 		tid_info = &sta_info->tid_info[tx_info->tid];

 		mutex_lock(&tid_info->mutex);

 		/*
 		 * If the RAxTID is stopped, we queue the skb to the stopped
 		 * queue.
 		 * Whenever we'll get a UMAC notification to resume the tx flow
 		 * for this RAxTID, we'll merge back the stopped queue into the
 		 * regular queue. See iwm_ntf_stop_resume_tx() from rx.c.
 		 */
 		if (tid_info->stopped) {
 			IWM_DBG_TX(iwm, DBG, "%dx%d stopped\n",
 				   tx_info->sta, tx_info->tid);
 			spin_lock_bh(&txq->lock);
 			skb_queue_tail(&txq->stopped_queue, skb);
 			spin_unlock_bh(&txq->lock);

 			mutex_unlock(&tid_info->mutex);
 			continue;
 		}

 		cmdlen = IWM_UDMA_HDR_LEN + skb->len;

 		IWM_DBG_TX(iwm, DBG, "Tx frame on queue %d: skb: 0x%p, sta: "
 			   "%d, color: %d\n", txq->id, skb, tx_info->sta,
 			   tx_info->color);

 		if (txq->concat_count + cmdlen > IWM_HAL_CONCATENATE_BUF_SIZE)
 			iwm_tx_send_concat_packets(iwm, txq);

 		ret = iwm_tx_credit_alloc(iwm, pool_id, cmdlen);
 		if (ret) {
 			IWM_DBG_TX(iwm, DBG, "not enough tx_credit for queue "
 				   "%d, Tx worker stopped\n", txq->id);
 			spin_lock_bh(&txq->lock);
 			skb_queue_head(&txq->queue, skb);
 			spin_unlock_bh(&txq->lock);

 			mutex_unlock(&tid_info->mutex);
 			break;
 		}

 		txq->concat_ptr = txq->concat_buf + txq->concat_count;
 		tid_info->last_seq_num =
 			iwm_tx_build_packet(iwm, skb, pool_id, txq->concat_ptr);
 		txq->concat_count += ALIGN(cmdlen, 16);

 		mutex_unlock(&tid_info->mutex);

 		kfree_skb(skb);
 	}

 	iwm_tx_send_concat_packets(iwm, txq);

 	if (__netif_subqueue_stopped(iwm_to_ndev(iwm), txq->id) &&
 	    !test_bit(pool_id, &iwm->tx_credit.full_pools_map) &&
 	    (skb_queue_len(&txq->queue) < IWM_TX_LIST_SIZE / 2)) {
 		IWM_DBG_TX(iwm, DBG, "LINK: start netif_subqueue[%d]", txq->id);
 		netif_wake_subqueue(iwm_to_ndev(iwm), txq->id);
 	}
 }

 int iwm_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 {
 	struct iwm_priv *iwm = ndev_to_iwm(netdev);
 	struct wireless_dev *wdev = iwm_to_wdev(iwm);
 	struct iwm_tx_info *tx_info;
 	struct iwm_tx_queue *txq;
 	struct iwm_sta_info *sta_info;
 	u8 *dst_addr, sta_id;
 	u16 queue;
 	int ret;


 	if (!test_bit(IWM_STATUS_ASSOCIATED, &iwm->status)) {
 		IWM_DBG_TX(iwm, DBG, "LINK: stop netif_all_queues: "
 			   "not associated\n");
 		netif_tx_stop_all_queues(netdev);
 		goto drop;
 	}

 	queue = skb_get_queue_mapping(skb);
 	BUG_ON(queue >= IWM_TX_DATA_QUEUES); /* no iPAN yet */

 	txq = &iwm->txq[queue];

 	/* No free space for Tx, tx_worker is too slow */
 	if ((skb_queue_len(&txq->queue) > IWM_TX_LIST_SIZE) ||
 	    (skb_queue_len(&txq->stopped_queue) > IWM_TX_LIST_SIZE)) {
 		IWM_DBG_TX(iwm, DBG, "LINK: stop netif_subqueue[%d]\n", queue);
 		netif_stop_subqueue(netdev, queue);
 		return NETDEV_TX_BUSY;
 	}

 	ret = ieee80211_data_from_8023(skb, netdev->dev_addr, wdev->iftype,
 				       iwm->bssid, 0);
 	if (ret) {
 		IWM_ERR(iwm, "build wifi header failed\n");
 		goto drop;
 	}

 	dst_addr = ((struct ieee80211_hdr *)(skb->data))->addr1;

 	for (sta_id = 0; sta_id < IWM_STA_TABLE_NUM; sta_id++) {
 		sta_info = &iwm->sta_table[sta_id];
 		if (sta_info->valid &&
 		    !memcmp(dst_addr, sta_info->addr, ETH_ALEN))
 			break;
 	}

 	if (sta_id == IWM_STA_TABLE_NUM) {
 		IWM_ERR(iwm, "STA %pM not found in sta_table, Tx ignored\n",
 			dst_addr);
 		goto drop;
 	}

 	tx_info = skb_to_tx_info(skb);
 	tx_info->sta = sta_id;
 	tx_info->color = sta_info->color;
 	/* UMAC uses TID 8 (vs. 0) for non QoS packets */
 	if (sta_info->qos)
 		tx_info->tid = skb->priority;
 	else
 		tx_info->tid = IWM_UMAC_MGMT_TID;

 	spin_lock_bh(&iwm->txq[queue].lock);
 	skb_queue_tail(&iwm->txq[queue].queue, skb);
 	spin_unlock_bh(&iwm->txq[queue].lock);

 	queue_work(iwm->txq[queue].wq, &iwm->txq[queue].worker);

 	netdev->stats.tx_packets++;
 	netdev->stats.tx_bytes += skb->len;
 	return NETDEV_TX_OK;

  drop:
 	netdev->stats.tx_dropped++;
 	dev_kfree_skb_any(skb);
 	return NETDEV_TX_OK;
 }
	/*
	* 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>
	*
	*/

	/*
	* iwm Tx theory of operation:
	*
	* 1) We receive a 802.3 frame from the stack
	* 2) We convert it to a 802.11 frame [iwm_xmit_frame]
	* 3) We queue it to its corresponding tx queue [iwm_xmit_frame]
	* 4) We schedule the tx worker. There is one worker per tx
	* queue. [iwm_xmit_frame]
	* 5) The tx worker is scheduled
	* 6) We go through every queued skb on the tx queue, and for each
	* and every one of them: [iwm_tx_worker]
	* a) We check if we have enough Tx credits (see below for a Tx
	* credits description) for the frame length. [iwm_tx_worker]
	* b) If we do, we aggregate the Tx frame into a UDMA one, by
	* concatenating one REPLY_TX command per Tx frame. [iwm_tx_worker]
	* c) When we run out of credits, or when we reach the maximum
	* concatenation size, we actually send the concatenated UDMA
	* frame. [iwm_tx_worker]
	*
	* When we run out of Tx credits, the skbs are filling the tx queue,
	* and eventually we will stop the netdev queue. [iwm_tx_worker]
	* The tx queue is emptied as we're getting new tx credits, by
	* scheduling the tx_worker. [iwm_tx_credit_inc]
	* The netdev queue is started again when we have enough tx credits,
	* and when our tx queue has some reasonable amout of space available
	* (i.e. half of the max size). [iwm_tx_worker]
	*/

	#include <linux/slab.h>
	#include <linux/skbuff.h>
	#include <linux/netdevice.h>
	#include <linux/ieee80211.h>

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

	#define IWM_UMAC_PAGE_ALLOC_WRAP 0xffff

	#define BYTES_TO_PAGES(n) (1 + ((n) >> ilog2(IWM_UMAC_PAGE_SIZE)) - \
	(((n) & (IWM_UMAC_PAGE_SIZE - 1)) == 0))

	#define pool_id_to_queue(id) ((id < IWM_TX_CMD_QUEUE) ? id : id - 1)
	#define queue_to_pool_id(q) ((q < IWM_TX_CMD_QUEUE) ? q : q + 1)

	/* require to hold tx_credit lock */
	static int iwm_tx_credit_get(struct iwm_tx_credit *tx_credit, int id)
	{
	struct pool_entry *pool = &tx_credit->pools[id];
	struct spool_entry *spool = &tx_credit->spools[pool->sid];
	int spool_pages;

	/* number of pages can be taken from spool by this pool */
	spool_pages = spool->max_pages - spool->alloc_pages +
	max(pool->min_pages - pool->alloc_pages, 0);

	return min(pool->max_pages - pool->alloc_pages, spool_pages);
	}

	static bool iwm_tx_credit_ok(struct iwm_priv *iwm, int id, int nb)
	{
	u32 npages = BYTES_TO_PAGES(nb);

	if (npages <= iwm_tx_credit_get(&iwm->tx_credit, id))
	return 1;

	set_bit(id, &iwm->tx_credit.full_pools_map);

	IWM_DBG_TX(iwm, DBG, "LINK: stop txq[%d], available credit: %d\n",
	pool_id_to_queue(id),
	iwm_tx_credit_get(&iwm->tx_credit, id));

	return 0;
	}

	void iwm_tx_credit_inc(struct iwm_priv *iwm, int id, int total_freed_pages)
	{
	struct pool_entry *pool;
	struct spool_entry *spool;
	int freed_pages;
	int queue;

	BUG_ON(id >= IWM_MACS_OUT_GROUPS);

	pool = &iwm->tx_credit.pools[id];
	spool = &iwm->tx_credit.spools[pool->sid];

	freed_pages = total_freed_pages - pool->total_freed_pages;
	IWM_DBG_TX(iwm, DBG, "Free %d pages for pool[%d]\n", freed_pages, id);

	if (!freed_pages) {
	IWM_DBG_TX(iwm, DBG, "No pages are freed by UMAC\n");
	return;
	} else if (freed_pages < 0)
	freed_pages += IWM_UMAC_PAGE_ALLOC_WRAP + 1;

	if (pool->alloc_pages > pool->min_pages) {
	int spool_pages = pool->alloc_pages - pool->min_pages;
	spool_pages = min(spool_pages, freed_pages);
	spool->alloc_pages -= spool_pages;
	}

	pool->alloc_pages -= freed_pages;
	pool->total_freed_pages = total_freed_pages;

	IWM_DBG_TX(iwm, DBG, "Pool[%d] pages alloc: %d, total_freed: %d, "
	"Spool[%d] pages alloc: %d\n", id, pool->alloc_pages,
	pool->total_freed_pages, pool->sid, spool->alloc_pages);

	if (test_bit(id, &iwm->tx_credit.full_pools_map) &&
	(pool->alloc_pages < pool->max_pages / 2)) {
	clear_bit(id, &iwm->tx_credit.full_pools_map);

	queue = pool_id_to_queue(id);

	IWM_DBG_TX(iwm, DBG, "LINK: start txq[%d], available "
	"credit: %d\n", queue,
	iwm_tx_credit_get(&iwm->tx_credit, id));
	queue_work(iwm->txq[queue].wq, &iwm->txq[queue].worker);
	}
	}

	static void iwm_tx_credit_dec(struct iwm_priv *iwm, int id, int alloc_pages)
	{
	struct pool_entry *pool;
	struct spool_entry *spool;
	int spool_pages;

	IWM_DBG_TX(iwm, DBG, "Allocate %d pages for pool[%d]\n",
	alloc_pages, id);

	BUG_ON(id >= IWM_MACS_OUT_GROUPS);

	pool = &iwm->tx_credit.pools[id];
	spool = &iwm->tx_credit.spools[pool->sid];

	spool_pages = pool->alloc_pages + alloc_pages - pool->min_pages;

	if (pool->alloc_pages >= pool->min_pages)
	spool->alloc_pages += alloc_pages;
	else if (spool_pages > 0)
	spool->alloc_pages += spool_pages;

	pool->alloc_pages += alloc_pages;

	IWM_DBG_TX(iwm, DBG, "Pool[%d] pages alloc: %d, total_freed: %d, "
	"Spool[%d] pages alloc: %d\n", id, pool->alloc_pages,
	pool->total_freed_pages, pool->sid, spool->alloc_pages);
	}

	int iwm_tx_credit_alloc(struct iwm_priv *iwm, int id, int nb)
	{
	u32 npages = BYTES_TO_PAGES(nb);
	int ret = 0;

	spin_lock(&iwm->tx_credit.lock);

	if (!iwm_tx_credit_ok(iwm, id, nb)) {
	IWM_DBG_TX(iwm, DBG, "No credit avaliable for pool[%d]\n", id);
	ret = -ENOSPC;
	goto out;
	}

	iwm_tx_credit_dec(iwm, id, npages);

	out:
	spin_unlock(&iwm->tx_credit.lock);
	return ret;
	}

	/*
	* Since we're on an SDIO or USB bus, we are not sharing memory
	* for storing to be transmitted frames. The host needs to push
	* them upstream. As a consequence there needs to be a way for
	* the target to let us know if it can actually take more TX frames
	* or not. This is what Tx credits are for.
	*
	* For each Tx HW queue, we have a Tx pool, and then we have one
	* unique super pool (spool), which is actually a global pool of
	* all the UMAC pages.
	* For each Tx pool we have a min_pages, a max_pages fields, and a
	* alloc_pages fields. The alloc_pages tracks the number of pages
	* currently allocated from the tx pool.
	* Here are the rules to check if given a tx frame we have enough
	* tx credits for it:
	* 1) We translate the frame length into a number of UMAC pages.
	* Let's call them n_pages.
	* 2) For the corresponding tx pool, we check if n_pages +
	* pool->alloc_pages is higher than pool->min_pages. min_pages
	* represent a set of pre-allocated pages on the tx pool. If
	* that's the case, then we need to allocate those pages from
	* the spool. We can do so until we reach spool->max_pages.
	* 3) Each tx pool is not allowed to allocate more than pool->max_pages
	* from the spool, so once we're over min_pages, we can allocate
	* pages from the spool, but not more than max_pages.
	*
	* When the tx code path needs to send a tx frame, it checks first
	* if it has enough tx credits, following those rules. [iwm_tx_credit_get]
	* If it does, it then updates the pool and spool counters and
	* then send the frame. [iwm_tx_credit_alloc and iwm_tx_credit_dec]
	* On the other side, when the UMAC is done transmitting frames, it
	* will send a credit update notification to the host. This is when
	* the pool and spool counters gets to be decreased. [iwm_tx_credit_inc,
	* called from rx.c:iwm_ntf_tx_credit_update]
	*
	*/
	void iwm_tx_credit_init_pools(struct iwm_priv *iwm,
	struct iwm_umac_notif_alive *alive)
	{
	int i, sid, pool_pages;

	spin_lock(&iwm->tx_credit.lock);

	iwm->tx_credit.pool_nr = le16_to_cpu(alive->page_grp_count);
	iwm->tx_credit.full_pools_map = 0;
	memset(&iwm->tx_credit.spools[0], 0, sizeof(struct spool_entry));

	IWM_DBG_TX(iwm, DBG, "Pools number is %d\n", iwm->tx_credit.pool_nr);

	for (i = 0; i < iwm->tx_credit.pool_nr; i++) {
	__le32 page_grp_state = alive->page_grp_state[i];

	iwm->tx_credit.pools[i].id = GET_VAL32(page_grp_state,
	UMAC_ALIVE_PAGE_STS_GRP_NUM);
	iwm->tx_credit.pools[i].sid = GET_VAL32(page_grp_state,
	UMAC_ALIVE_PAGE_STS_SGRP_NUM);
	iwm->tx_credit.pools[i].min_pages = GET_VAL32(page_grp_state,
	UMAC_ALIVE_PAGE_STS_GRP_MIN_SIZE);
	iwm->tx_credit.pools[i].max_pages = GET_VAL32(page_grp_state,
	UMAC_ALIVE_PAGE_STS_GRP_MAX_SIZE);
	iwm->tx_credit.pools[i].alloc_pages = 0;
	iwm->tx_credit.pools[i].total_freed_pages = 0;

	sid = iwm->tx_credit.pools[i].sid;
	pool_pages = iwm->tx_credit.pools[i].min_pages;

	if (iwm->tx_credit.spools[sid].max_pages == 0) {
	iwm->tx_credit.spools[sid].id = sid;
	iwm->tx_credit.spools[sid].max_pages =
	GET_VAL32(page_grp_state,
	UMAC_ALIVE_PAGE_STS_SGRP_MAX_SIZE);
	iwm->tx_credit.spools[sid].alloc_pages = 0;
	}

	iwm->tx_credit.spools[sid].alloc_pages += pool_pages;

	IWM_DBG_TX(iwm, DBG, "Pool idx: %d, id: %d, sid: %d, capacity "
	"min: %d, max: %d, pool alloc: %d, total_free: %d, "
	"super poll alloc: %d\n",
	i, iwm->tx_credit.pools[i].id,
	iwm->tx_credit.pools[i].sid,
	iwm->tx_credit.pools[i].min_pages,
	iwm->tx_credit.pools[i].max_pages,
	iwm->tx_credit.pools[i].alloc_pages,
	iwm->tx_credit.pools[i].total_freed_pages,
	iwm->tx_credit.spools[sid].alloc_pages);
	}

	spin_unlock(&iwm->tx_credit.lock);
	}

	#define IWM_UDMA_HDR_LEN sizeof(struct iwm_umac_wifi_out_hdr)

	static __le16 iwm_tx_build_packet(struct iwm_priv iwm, struct sk_buff skb,
	int pool_id, u8 *buf)
	{
	struct iwm_umac_wifi_out_hdr hdr = (struct iwm_umac_wifi_out_hdr )buf;
	struct iwm_udma_wifi_cmd udma_cmd;
	struct iwm_umac_cmd umac_cmd;
	struct iwm_tx_info *tx_info = skb_to_tx_info(skb);

	udma_cmd.count = cpu_to_le16(skb->len +
	sizeof(struct iwm_umac_fw_cmd_hdr));
	/* set EOP to 0 here. iwm_udma_wifi_hdr_set_eop() will be
	* called later to set EOP for the last packet. */
	udma_cmd.eop = 0;
	udma_cmd.credit_group = pool_id;
	udma_cmd.ra_tid = tx_info->sta << 4 \| tx_info->tid;
	udma_cmd.lmac_offset = 0;

	umac_cmd.id = REPLY_TX;
	umac_cmd.count = cpu_to_le16(skb->len);
	umac_cmd.color = tx_info->color;
	umac_cmd.resp = 0;
	umac_cmd.seq_num = cpu_to_le16(iwm_alloc_wifi_cmd_seq(iwm));

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

	memcpy(buf + sizeof(*hdr), skb->data, skb->len);

	return umac_cmd.seq_num;
	}

	static int iwm_tx_send_concat_packets(struct iwm_priv *iwm,
	struct iwm_tx_queue *txq)
	{
	int ret;

	if (!txq->concat_count)
	return 0;

	IWM_DBG_TX(iwm, DBG, "Send concatenated Tx: queue %d, %d bytes\n",
	txq->id, txq->concat_count);

	/* mark EOP for the last packet */
	iwm_udma_wifi_hdr_set_eop(iwm, txq->concat_ptr, 1);

	trace_iwm_tx_packets(iwm, txq->concat_buf, txq->concat_count);
	ret = iwm_bus_send_chunk(iwm, txq->concat_buf, txq->concat_count);

	txq->concat_count = 0;
	txq->concat_ptr = txq->concat_buf;

	return ret;
	}

	void iwm_tx_worker(struct work_struct *work)
	{
	struct iwm_priv *iwm;
	struct iwm_tx_info *tx_info = NULL;
	struct sk_buff *skb;
	struct iwm_tx_queue *txq;
	struct iwm_sta_info *sta_info;
	struct iwm_tid_info *tid_info;
	int cmdlen, ret, pool_id;

	txq = container_of(work, struct iwm_tx_queue, worker);
	iwm = container_of(txq, struct iwm_priv, txq[txq->id]);

	pool_id = queue_to_pool_id(txq->id);

	while (!test_bit(pool_id, &iwm->tx_credit.full_pools_map) &&
	!skb_queue_empty(&txq->queue)) {

	spin_lock_bh(&txq->lock);
	skb = skb_dequeue(&txq->queue);
	spin_unlock_bh(&txq->lock);

	tx_info = skb_to_tx_info(skb);
	sta_info = &iwm->sta_table[tx_info->sta];
	if (!sta_info->valid) {
	IWM_ERR(iwm, "Trying to send a frame to unknown STA\n");
	kfree_skb(skb);
	continue;
	}

	tid_info = &sta_info->tid_info[tx_info->tid];

	mutex_lock(&tid_info->mutex);

	/*
	* If the RAxTID is stopped, we queue the skb to the stopped
	* queue.
	* Whenever we'll get a UMAC notification to resume the tx flow
	* for this RAxTID, we'll merge back the stopped queue into the
	* regular queue. See iwm_ntf_stop_resume_tx() from rx.c.
	*/
	if (tid_info->stopped) {
	IWM_DBG_TX(iwm, DBG, "%dx%d stopped\n",
	tx_info->sta, tx_info->tid);
	spin_lock_bh(&txq->lock);
	skb_queue_tail(&txq->stopped_queue, skb);
	spin_unlock_bh(&txq->lock);

	mutex_unlock(&tid_info->mutex);
	continue;
	}

	cmdlen = IWM_UDMA_HDR_LEN + skb->len;

	IWM_DBG_TX(iwm, DBG, "Tx frame on queue %d: skb: 0x%p, sta: "
	"%d, color: %d\n", txq->id, skb, tx_info->sta,
	tx_info->color);

	if (txq->concat_count + cmdlen > IWM_HAL_CONCATENATE_BUF_SIZE)
	iwm_tx_send_concat_packets(iwm, txq);

	ret = iwm_tx_credit_alloc(iwm, pool_id, cmdlen);
	if (ret) {
	IWM_DBG_TX(iwm, DBG, "not enough tx_credit for queue "
	"%d, Tx worker stopped\n", txq->id);
	spin_lock_bh(&txq->lock);
	skb_queue_head(&txq->queue, skb);
	spin_unlock_bh(&txq->lock);

	mutex_unlock(&tid_info->mutex);
	break;
	}

	txq->concat_ptr = txq->concat_buf + txq->concat_count;
	tid_info->last_seq_num =
	iwm_tx_build_packet(iwm, skb, pool_id, txq->concat_ptr);
	txq->concat_count += ALIGN(cmdlen, 16);

	mutex_unlock(&tid_info->mutex);

	kfree_skb(skb);
	}

	iwm_tx_send_concat_packets(iwm, txq);

	if (__netif_subqueue_stopped(iwm_to_ndev(iwm), txq->id) &&
	!test_bit(pool_id, &iwm->tx_credit.full_pools_map) &&
	(skb_queue_len(&txq->queue) < IWM_TX_LIST_SIZE / 2)) {
	IWM_DBG_TX(iwm, DBG, "LINK: start netif_subqueue[%d]", txq->id);
	netif_wake_subqueue(iwm_to_ndev(iwm), txq->id);
	}
	}

	int iwm_xmit_frame(struct sk_buff skb, struct net_device netdev)
	{
	struct iwm_priv *iwm = ndev_to_iwm(netdev);
	struct wireless_dev *wdev = iwm_to_wdev(iwm);
	struct iwm_tx_info *tx_info;
	struct iwm_tx_queue *txq;
	struct iwm_sta_info *sta_info;
	u8 *dst_addr, sta_id;
	u16 queue;
	int ret;


	if (!test_bit(IWM_STATUS_ASSOCIATED, &iwm->status)) {
	IWM_DBG_TX(iwm, DBG, "LINK: stop netif_all_queues: "
	"not associated\n");
	netif_tx_stop_all_queues(netdev);
	goto drop;
	}

	queue = skb_get_queue_mapping(skb);
	BUG_ON(queue >= IWM_TX_DATA_QUEUES); /* no iPAN yet */

	txq = &iwm->txq[queue];

	/* No free space for Tx, tx_worker is too slow */
	if ((skb_queue_len(&txq->queue) > IWM_TX_LIST_SIZE) \|\|
	(skb_queue_len(&txq->stopped_queue) > IWM_TX_LIST_SIZE)) {
	IWM_DBG_TX(iwm, DBG, "LINK: stop netif_subqueue[%d]\n", queue);
	netif_stop_subqueue(netdev, queue);
	return NETDEV_TX_BUSY;
	}

	ret = ieee80211_data_from_8023(skb, netdev->dev_addr, wdev->iftype,
	iwm->bssid, 0);
	if (ret) {
	IWM_ERR(iwm, "build wifi header failed\n");
	goto drop;
	}

	dst_addr = ((struct ieee80211_hdr *)(skb->data))->addr1;

	for (sta_id = 0; sta_id < IWM_STA_TABLE_NUM; sta_id++) {
	sta_info = &iwm->sta_table[sta_id];
	if (sta_info->valid &&
	!memcmp(dst_addr, sta_info->addr, ETH_ALEN))
	break;
	}

	if (sta_id == IWM_STA_TABLE_NUM) {
	IWM_ERR(iwm, "STA %pM not found in sta_table, Tx ignored\n",
	dst_addr);
	goto drop;
	}

	tx_info = skb_to_tx_info(skb);
	tx_info->sta = sta_id;
	tx_info->color = sta_info->color;
	/* UMAC uses TID 8 (vs. 0) for non QoS packets */
	if (sta_info->qos)
	tx_info->tid = skb->priority;
	else
	tx_info->tid = IWM_UMAC_MGMT_TID;

	spin_lock_bh(&iwm->txq[queue].lock);
	skb_queue_tail(&iwm->txq[queue].queue, skb);
	spin_unlock_bh(&iwm->txq[queue].lock);

	queue_work(iwm->txq[queue].wq, &iwm->txq[queue].worker);

	netdev->stats.tx_packets++;
	netdev->stats.tx_bytes += skb->len;
	return NETDEV_TX_OK;

	drop:
	netdev->stats.tx_dropped++;
	dev_kfree_skb_any(skb);
	return NETDEV_TX_OK;
	}