iwl-trans.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
    2 /*
    3  * Copyright (C) 2015 Intel Mobile Communications GmbH
    4  * Copyright (C) 2016-2017 Intel Deutschland GmbH
    5  * Copyright (C) 2019-2021 Intel Corporation
    6  */
    7 #include <linux/kernel.h>
    8 #include <linux/bsearch.h>
    9 
   10 #include "fw/api/tx.h"
   11 #include "iwl-trans.h"
   12 #include "iwl-drv.h"
   13 #include "iwl-fh.h"
   14 #include "queue/tx.h"
   15 #include <linux/dmapool.h>
   16 #include "fw/api/commands.h"
   17 
   18 struct iwl_trans *iwl_trans_alloc(unsigned int priv_size,
   19                                   struct device *dev,
   20                                   const struct iwl_trans_ops *ops,
   21                                   const struct iwl_cfg_trans_params *cfg_trans)
   22 {
   23         struct iwl_trans *trans;
   24 #ifdef CONFIG_LOCKDEP
   25         static struct lock_class_key __key;
   26 #endif
   27 
   28         trans = devm_kzalloc(dev, sizeof(*trans) + priv_size, GFP_KERNEL);
   29         if (!trans)
   30                 return NULL;
   31 
   32         trans->trans_cfg = cfg_trans;
   33 
   34 #ifdef CONFIG_LOCKDEP
   35         lockdep_init_map(&trans->sync_cmd_lockdep_map, "sync_cmd_lockdep_map",
   36                          &__key, 0);
   37 #endif
   38 
   39         trans->dev = dev;
   40         trans->ops = ops;
   41         trans->num_rx_queues = 1;
   42 
   43         WARN_ON(!ops->wait_txq_empty && !ops->wait_tx_queues_empty);
   44 
   45         if (trans->trans_cfg->use_tfh) {
   46                 trans->txqs.tfd.addr_size = 64;
   47                 trans->txqs.tfd.max_tbs = IWL_TFH_NUM_TBS;
   48                 trans->txqs.tfd.size = sizeof(struct iwl_tfh_tfd);
   49         } else {
   50                 trans->txqs.tfd.addr_size = 36;
   51                 trans->txqs.tfd.max_tbs = IWL_NUM_OF_TBS;
   52                 trans->txqs.tfd.size = sizeof(struct iwl_tfd);
   53         }
   54         trans->max_skb_frags = IWL_TRANS_MAX_FRAGS(trans);
   55 
   56         return trans;
   57 }
   58 
   59 int iwl_trans_init(struct iwl_trans *trans)
   60 {
   61         int txcmd_size, txcmd_align;
   62 
   63         if (!trans->trans_cfg->gen2) {
   64                 txcmd_size = sizeof(struct iwl_tx_cmd);
   65                 txcmd_align = sizeof(void *);
   66         } else if (trans->trans_cfg->device_family < IWL_DEVICE_FAMILY_AX210) {
   67                 txcmd_size = sizeof(struct iwl_tx_cmd_gen2);
   68                 txcmd_align = 64;
   69         } else {
   70                 txcmd_size = sizeof(struct iwl_tx_cmd_gen3);
   71                 txcmd_align = 128;
   72         }
   73 
   74         txcmd_size += sizeof(struct iwl_cmd_header);
   75         txcmd_size += 36; /* biggest possible 802.11 header */
   76 
   77         /* Ensure device TX cmd cannot reach/cross a page boundary in gen2 */
   78         if (WARN_ON(trans->trans_cfg->gen2 && txcmd_size >= txcmd_align))
   79                 return -EINVAL;
   80 
   81         if (trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_BZ)
   82                 trans->txqs.bc_tbl_size =
   83                         sizeof(struct iwl_gen3_bc_tbl_entry) * TFD_QUEUE_BC_SIZE_GEN3_BZ;
   84         else if (trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_AX210)
   85                 trans->txqs.bc_tbl_size =
   86                         sizeof(struct iwl_gen3_bc_tbl_entry) * TFD_QUEUE_BC_SIZE_GEN3_AX210;
   87         else
   88                 trans->txqs.bc_tbl_size = sizeof(struct iwlagn_scd_bc_tbl);
   89         /*
   90          * For gen2 devices, we use a single allocation for each byte-count
   91          * table, but they're pretty small (1k) so use a DMA pool that we
   92          * allocate here.
   93          */
   94         if (trans->trans_cfg->gen2) {
   95                 trans->txqs.bc_pool = dmam_pool_create("iwlwifi:bc", trans->dev,
   96                                                        trans->txqs.bc_tbl_size,
   97                                                        256, 0);
   98                 if (!trans->txqs.bc_pool)
   99                         return -ENOMEM;
  100         }
  101 
  102         /* Some things must not change even if the config does */
  103         WARN_ON(trans->txqs.tfd.addr_size !=
  104                 (trans->trans_cfg->use_tfh ? 64 : 36));
  105 
  106         snprintf(trans->dev_cmd_pool_name, sizeof(trans->dev_cmd_pool_name),
  107                  "iwl_cmd_pool:%s", dev_name(trans->dev));
  108         trans->dev_cmd_pool =
  109                 kmem_cache_create(trans->dev_cmd_pool_name,
  110                                   txcmd_size, txcmd_align,
  111                                   SLAB_HWCACHE_ALIGN, NULL);
  112         if (!trans->dev_cmd_pool)
  113                 return -ENOMEM;
  114 
  115 #ifdef CONFIG_INET
  116         trans->txqs.tso_hdr_page = alloc_percpu(struct iwl_tso_hdr_page);
  117         if (!trans->txqs.tso_hdr_page) {
  118                 kmem_cache_destroy(trans->dev_cmd_pool);
  119                 return -ENOMEM;
  120         }
  121 #endif
  122 
  123         /* Initialize the wait queue for commands */
  124         init_waitqueue_head(&trans->wait_command_queue);
  125 
  126         return 0;
  127 }
  128 
  129 void iwl_trans_free(struct iwl_trans *trans)
  130 {
  131 #ifdef CONFIG_INET
  132         int i;
  133 
  134         if (trans->txqs.tso_hdr_page) {
  135                 for_each_possible_cpu(i) {
  136                         struct iwl_tso_hdr_page *p =
  137                                 per_cpu_ptr(trans->txqs.tso_hdr_page, i);
  138 
  139                         if (p && p->page)
  140                                 __free_page(p->page);
  141                 }
  142 
  143                 free_percpu(trans->txqs.tso_hdr_page);
  144         }
  145 #endif
  146 
  147         kmem_cache_destroy(trans->dev_cmd_pool);
  148 }
  149 
  150 int iwl_trans_send_cmd(struct iwl_trans *trans, struct iwl_host_cmd *cmd)
  151 {
  152         int ret;
  153 
  154         if (unlikely(!(cmd->flags & CMD_SEND_IN_RFKILL) &&
  155                      test_bit(STATUS_RFKILL_OPMODE, &trans->status)))
  156                 return -ERFKILL;
  157 
  158         /*
  159          * We can't test IWL_MVM_STATUS_IN_D3 in mvm->status because this
  160          * bit is set early in the D3 flow, before we send all the commands
  161          * that configure the firmware for D3 operation (power, patterns, ...)
  162          * and we don't want to flag all those with CMD_SEND_IN_D3.
  163          * So use the system_pm_mode instead. The only command sent after
  164          * we set system_pm_mode is D3_CONFIG_CMD, which we now flag with
  165          * CMD_SEND_IN_D3.
  166          */
  167         if (unlikely(trans->system_pm_mode == IWL_PLAT_PM_MODE_D3 &&
  168                      !(cmd->flags & CMD_SEND_IN_D3)))
  169                 return -EHOSTDOWN;
  170 
  171         if (unlikely(test_bit(STATUS_FW_ERROR, &trans->status)))
  172                 return -EIO;
  173 
  174         if (unlikely(trans->state != IWL_TRANS_FW_ALIVE)) {
  175                 IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
  176                 return -EIO;
  177         }
  178 
  179         if (WARN_ON((cmd->flags & CMD_WANT_ASYNC_CALLBACK) &&
  180                     !(cmd->flags & CMD_ASYNC)))
  181                 return -EINVAL;
  182 
  183         if (!(cmd->flags & CMD_ASYNC))
  184                 lock_map_acquire_read(&trans->sync_cmd_lockdep_map);
  185 
  186         if (trans->wide_cmd_header && !iwl_cmd_groupid(cmd->id)) {
  187                 if (cmd->id != REPLY_ERROR)
  188                         cmd->id = DEF_ID(cmd->id);
  189         }
  190 
  191         ret = iwl_trans_txq_send_hcmd(trans, cmd);
  192 
  193         if (!(cmd->flags & CMD_ASYNC))
  194                 lock_map_release(&trans->sync_cmd_lockdep_map);
  195 
  196         if (WARN_ON((cmd->flags & CMD_WANT_SKB) && !ret && !cmd->resp_pkt))
  197                 return -EIO;
  198 
  199         return ret;
  200 }
  201 IWL_EXPORT_SYMBOL(iwl_trans_send_cmd);
  202 
  203 /* Comparator for struct iwl_hcmd_names.
  204  * Used in the binary search over a list of host commands.
  205  *
  206  * @key: command_id that we're looking for.
  207  * @elt: struct iwl_hcmd_names candidate for match.
  208  *
  209  * @return 0 iff equal.
  210  */
  211 static int iwl_hcmd_names_cmp(const void *key, const void *elt)
  212 {
  213         const struct iwl_hcmd_names *name = elt;
  214         const u8 *cmd1 = key;
  215         u8 cmd2 = name->cmd_id;
  216 
  217         return (*cmd1 - cmd2);
  218 }
  219 
  220 const char *iwl_get_cmd_string(struct iwl_trans *trans, u32 id)
  221 {
  222         u8 grp, cmd;
  223         struct iwl_hcmd_names *ret;
  224         const struct iwl_hcmd_arr *arr;
  225         size_t size = sizeof(struct iwl_hcmd_names);
  226 
  227         grp = iwl_cmd_groupid(id);
  228         cmd = iwl_cmd_opcode(id);
  229 
  230         if (!trans->command_groups || grp >= trans->command_groups_size ||
  231             !trans->command_groups[grp].arr)
  232                 return "UNKNOWN";
  233 
  234         arr = &trans->command_groups[grp];
  235         ret = bsearch(&cmd, arr->arr, arr->size, size, iwl_hcmd_names_cmp);
  236         if (!ret)
  237                 return "UNKNOWN";
  238         return ret->cmd_name;
  239 }
  240 IWL_EXPORT_SYMBOL(iwl_get_cmd_string);
  241 
  242 int iwl_cmd_groups_verify_sorted(const struct iwl_trans_config *trans)
  243 {
  244         int i, j;
  245         const struct iwl_hcmd_arr *arr;
  246 
  247         for (i = 0; i < trans->command_groups_size; i++) {
  248                 arr = &trans->command_groups[i];
  249                 if (!arr->arr)
  250                         continue;
  251                 for (j = 0; j < arr->size - 1; j++)
  252                         if (arr->arr[j].cmd_id > arr->arr[j + 1].cmd_id)
  253                                 return -1;
  254         }
  255         return 0;
  256 }
  257 IWL_EXPORT_SYMBOL(iwl_cmd_groups_verify_sorted);

Cache object: 8bdb3e9c2e3b97e8ab8cbd01238a5e2d

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/contrib/dev/iwlwifi/iwl-trans.c

FreeBSD/Linux Kernel Cross Reference
sys/contrib/dev/iwlwifi/iwl-trans.c