iwl-trans.h

Go to the documentation of this file.

/******************************************************************************
 *
 * This file is provided under a dual BSD/GPLv2 license.  When using or
 * redistributing this file, you may do so under either license.
 *
 * GPL LICENSE SUMMARY
 *
 * Copyright(c) 2007 - 2012 Intel Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
 * USA
 *
 * The full GNU General Public License is included in this distribution
 * in the file called LICENSE.GPL.
 *
 * Contact Information:
 *  Intel Linux Wireless <[email protected]>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 * BSD LICENSE
 *
 * Copyright(c) 2005 - 2012 Intel Corporation. All rights reserved.
 * 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 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.
 *
 *****************************************************************************/
#ifndef __iwl_trans_h__
#define __iwl_trans_h__

#include <linux/ieee80211.h>
#include <linux/mm.h> /* for page_address */

#include "iwl-debug.h"
#include "iwl-config.h"
#include "iwl-fw.h"

#define SEQ_TO_SN(seq) (((seq) & IEEE80211_SCTL_SEQ) >> 4)
#define SN_TO_SEQ(ssn) (((ssn) << 4) & IEEE80211_SCTL_SEQ)
#define MAX_SN ((IEEE80211_SCTL_SEQ) >> 4)
#define SEQ_TO_QUEUE(s) (((s) >> 8) & 0x1f)
#define QUEUE_TO_SEQ(q) (((q) & 0x1f) << 8)
#define SEQ_TO_INDEX(s) ((s) & 0xff)
#define INDEX_TO_SEQ(i) ((i) & 0xff)
#define SEQ_RX_FRAME    cpu_to_le16(0x8000)

struct iwl_cmd_header {
    u8 cmd;     /* Command ID:  REPLY_RXON, etc. */
    u8 flags;   /* 0:5 reserved, 6 abort, 7 internal */
    /*
     * The driver sets up the sequence number to values of its choosing.
     * uCode does not use this value, but passes it back to the driver
     * when sending the response to each driver-originated command, so
     * the driver can match the response to the command.  Since the values
     * don't get used by uCode, the driver may set up an arbitrary format.
     *
     * There is one exception:  uCode sets bit 15 when it originates
     * the response/notification, i.e. when the response/notification
     * is not a direct response to a command sent by the driver.  For
     * example, uCode issues REPLY_RX when it sends a received frame
     * to the driver; it is not a direct response to any driver command.
     *
     * The Linux driver uses the following format:
     *
     *  0:7     tfd index - position within TX queue
     *  8:12    TX queue id
     *  13:14   reserved
     *  15      unsolicited RX or uCode-originated notification
     */
    __le16 sequence;
} __packed;

/* iwl_cmd_header flags value */
#define IWL_CMD_FAILED_MSK 0x40


#define FH_RSCSR_FRAME_SIZE_MSK     0x00003FFF  /* bits 0-13 */
#define FH_RSCSR_FRAME_INVALID      0x55550000
#define FH_RSCSR_FRAME_ALIGN        0x40

struct iwl_rx_packet {
    /*
     * The first 4 bytes of the RX frame header contain both the RX frame
     * size and some flags.
     * Bit fields:
     * 31:    flag flush RB request
     * 30:    flag ignore TC (terminal counter) request
     * 29:    flag fast IRQ request
     * 28-14: Reserved
     * 13-00: RX frame size
     */
    __le32 len_n_flags;
    struct iwl_cmd_header hdr;
    u8 data[];
} __packed;

enum CMD_MODE {
    CMD_SYNC = 0,
    CMD_ASYNC = BIT(0),
    CMD_WANT_SKB = BIT(1),
    CMD_WANT_HCMD = BIT(2),
    CMD_ON_DEMAND = BIT(3),
};

#define DEF_CMD_PAYLOAD_SIZE 320

struct iwl_device_cmd {
    struct iwl_cmd_header hdr;  /* uCode API */
    u8 payload[DEF_CMD_PAYLOAD_SIZE];
} __packed;

#define TFD_MAX_PAYLOAD_SIZE (sizeof(struct iwl_device_cmd))

#define IWL_MAX_CMD_TFDS    2

enum iwl_hcmd_dataflag {
    IWL_HCMD_DFL_NOCOPY = BIT(0),
};

struct iwl_host_cmd {
    const void *data[IWL_MAX_CMD_TFDS];
    struct iwl_rx_packet *resp_pkt;
    unsigned long _rx_page_addr;
    u32 _rx_page_order;
    int handler_status;

    u32 flags;
    u16 len[IWL_MAX_CMD_TFDS];
    u8 dataflags[IWL_MAX_CMD_TFDS];
    u8 id;
};

static inline void iwl_free_resp(struct iwl_host_cmd *cmd)
{
    free_pages(cmd->_rx_page_addr, cmd->_rx_page_order);
}

struct iwl_rx_cmd_buffer {
    struct page *_page;
    int _offset;
    bool _page_stolen;
    unsigned int truesize;
};

static inline void *rxb_addr(struct iwl_rx_cmd_buffer *r)
{
    return (void *)((unsigned long)page_address(r->_page) + r->_offset);
}

static inline int rxb_offset(struct iwl_rx_cmd_buffer *r)
{
    return r->_offset;
}

static inline struct page *rxb_steal_page(struct iwl_rx_cmd_buffer *r)
{
    r->_page_stolen = true;
    get_page(r->_page);
    return r->_page;
}

#define MAX_NO_RECLAIM_CMDS 6

#define IWL_MASK(lo, hi) ((1 << (hi)) | ((1 << (hi)) - (1 << (lo))))

/*
 * Maximum number of HW queues the transport layer
 * currently supports
 */
#define IWL_MAX_HW_QUEUES       32
#define IWL_INVALID_STATION 255
#define IWL_MAX_TID_COUNT   8
#define IWL_FRAME_LIMIT 64

struct iwl_trans_config {
    struct iwl_op_mode *op_mode;

    u8 cmd_queue;
    u8 cmd_fifo;
    const u8 *no_reclaim_cmds;
    int n_no_reclaim_cmds;

    bool rx_buf_size_8k;
    unsigned int queue_watchdog_timeout;
    const char **command_names;
};

struct iwl_trans;

struct iwl_trans_ops {

    int (*start_hw)(struct iwl_trans *iwl_trans);
    void (*stop_hw)(struct iwl_trans *iwl_trans, bool op_mode_leaving);
    int (*start_fw)(struct iwl_trans *trans, const struct fw_img *fw);
    void (*fw_alive)(struct iwl_trans *trans);
    void (*stop_device)(struct iwl_trans *trans);

    void (*wowlan_suspend)(struct iwl_trans *trans);

    int (*send_cmd)(struct iwl_trans *trans, struct iwl_host_cmd *cmd);

    int (*tx)(struct iwl_trans *trans, struct sk_buff *skb,
          struct iwl_device_cmd *dev_cmd, int queue);
    void (*reclaim)(struct iwl_trans *trans, int queue, int ssn,
            struct sk_buff_head *skbs);

    void (*txq_enable)(struct iwl_trans *trans, int queue, int fifo,
               int sta_id, int tid, int frame_limit, u16 ssn);
    void (*txq_disable)(struct iwl_trans *trans, int queue);

    int (*dbgfs_register)(struct iwl_trans *trans, struct dentry* dir);
    int (*wait_tx_queue_empty)(struct iwl_trans *trans);
#ifdef CONFIG_PM_SLEEP
    int (*suspend)(struct iwl_trans *trans);
    int (*resume)(struct iwl_trans *trans);
#endif
    void (*write8)(struct iwl_trans *trans, u32 ofs, u8 val);
    void (*write32)(struct iwl_trans *trans, u32 ofs, u32 val);
    u32 (*read32)(struct iwl_trans *trans, u32 ofs);
    void (*configure)(struct iwl_trans *trans,
              const struct iwl_trans_config *trans_cfg);
    void (*set_pmi)(struct iwl_trans *trans, bool state);
};

enum iwl_trans_state {
    IWL_TRANS_NO_FW = 0,
    IWL_TRANS_FW_ALIVE  = 1,
};

struct iwl_trans {
    const struct iwl_trans_ops *ops;
    struct iwl_op_mode *op_mode;
    const struct iwl_cfg *cfg;
    enum iwl_trans_state state;
    spinlock_t reg_lock;

    struct device *dev;
    u32 hw_rev;
    u32 hw_id;
    char hw_id_str[52];

    bool pm_support;

    wait_queue_head_t wait_command_queue;

    /* The following fields are internal only */
    struct kmem_cache *dev_cmd_pool;
    size_t dev_cmd_headroom;
    char dev_cmd_pool_name[50];

    struct dentry *dbgfs_dir;

    /* pointer to trans specific struct */
    /*Ensure that this pointer will always be aligned to sizeof pointer */
    char trans_specific[0] __aligned(sizeof(void *));
};

static inline void iwl_trans_configure(struct iwl_trans *trans,
                       const struct iwl_trans_config *trans_cfg)
{
    /*
     * only set the op_mode for the moment. Later on, this function will do
     * more
     */
    trans->op_mode = trans_cfg->op_mode;

    trans->ops->configure(trans, trans_cfg);
}

static inline int iwl_trans_start_hw(struct iwl_trans *trans)
{
    might_sleep();

    return trans->ops->start_hw(trans);
}

static inline void iwl_trans_stop_hw(struct iwl_trans *trans,
                     bool op_mode_leaving)
{
    might_sleep();

    trans->ops->stop_hw(trans, op_mode_leaving);

    trans->state = IWL_TRANS_NO_FW;
}

static inline void iwl_trans_fw_alive(struct iwl_trans *trans)
{
    might_sleep();

    trans->state = IWL_TRANS_FW_ALIVE;

    trans->ops->fw_alive(trans);
}

static inline int iwl_trans_start_fw(struct iwl_trans *trans,
                     const struct fw_img *fw)
{
    might_sleep();

    return trans->ops->start_fw(trans, fw);
}

static inline void iwl_trans_stop_device(struct iwl_trans *trans)
{
    might_sleep();

    trans->ops->stop_device(trans);

    trans->state = IWL_TRANS_NO_FW;
}

static inline void iwl_trans_wowlan_suspend(struct iwl_trans *trans)
{
    might_sleep();
    trans->ops->wowlan_suspend(trans);
}

static inline int iwl_trans_send_cmd(struct iwl_trans *trans,
                struct iwl_host_cmd *cmd)
{
    WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE,
          "%s bad state = %d", __func__, trans->state);

    return trans->ops->send_cmd(trans, cmd);
}

static inline struct iwl_device_cmd *
iwl_trans_alloc_tx_cmd(struct iwl_trans *trans)
{
    u8 *dev_cmd_ptr = kmem_cache_alloc(trans->dev_cmd_pool, GFP_ATOMIC);

    if (unlikely(dev_cmd_ptr == NULL))
        return NULL;

    return (struct iwl_device_cmd *)
            (dev_cmd_ptr + trans->dev_cmd_headroom);
}

static inline void iwl_trans_free_tx_cmd(struct iwl_trans *trans,
                     struct iwl_device_cmd *dev_cmd)
{
    u8 *dev_cmd_ptr = (u8 *)dev_cmd - trans->dev_cmd_headroom;

    kmem_cache_free(trans->dev_cmd_pool, dev_cmd_ptr);
}

static inline int iwl_trans_tx(struct iwl_trans *trans, struct sk_buff *skb,
                   struct iwl_device_cmd *dev_cmd, int queue)
{
    WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE,
          "%s bad state = %d", __func__, trans->state);

    return trans->ops->tx(trans, skb, dev_cmd, queue);
}

static inline void iwl_trans_reclaim(struct iwl_trans *trans, int queue,
                     int ssn, struct sk_buff_head *skbs)
{
    WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE,
          "%s bad state = %d", __func__, trans->state);

    trans->ops->reclaim(trans, queue, ssn, skbs);
}

static inline void iwl_trans_txq_disable(struct iwl_trans *trans, int queue)
{
    WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE,
          "%s bad state = %d", __func__, trans->state);

    trans->ops->txq_disable(trans, queue);
}

static inline void iwl_trans_txq_enable(struct iwl_trans *trans, int queue,
                    int fifo, int sta_id, int tid,
                    int frame_limit, u16 ssn)
{
    might_sleep();

    WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE,
          "%s bad state = %d", __func__, trans->state);

    trans->ops->txq_enable(trans, queue, fifo, sta_id, tid,
                 frame_limit, ssn);
}

static inline void iwl_trans_ac_txq_enable(struct iwl_trans *trans, int queue,
                       int fifo)
{
    iwl_trans_txq_enable(trans, queue, fifo, IWL_INVALID_STATION,
                 IWL_MAX_TID_COUNT, IWL_FRAME_LIMIT, 0);
}

static inline int iwl_trans_wait_tx_queue_empty(struct iwl_trans *trans)
{
    WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE,
          "%s bad state = %d", __func__, trans->state);

    return trans->ops->wait_tx_queue_empty(trans);
}

static inline int iwl_trans_dbgfs_register(struct iwl_trans *trans,
                        struct dentry *dir)
{
    return trans->ops->dbgfs_register(trans, dir);
}

#ifdef CONFIG_PM_SLEEP
static inline int iwl_trans_suspend(struct iwl_trans *trans)
{
    return trans->ops->suspend(trans);
}

static inline int iwl_trans_resume(struct iwl_trans *trans)
{
    return trans->ops->resume(trans);
}
#endif

static inline void iwl_trans_write8(struct iwl_trans *trans, u32 ofs, u8 val)
{
    trans->ops->write8(trans, ofs, val);
}

static inline void iwl_trans_write32(struct iwl_trans *trans, u32 ofs, u32 val)
{
    trans->ops->write32(trans, ofs, val);
}

static inline u32 iwl_trans_read32(struct iwl_trans *trans, u32 ofs)
{
    return trans->ops->read32(trans, ofs);
}

static inline void iwl_trans_set_pmi(struct iwl_trans *trans, bool state)
{
    trans->ops->set_pmi(trans, state);
}

/*****************************************************
* driver (transport) register/unregister functions
******************************************************/
int __must_check iwl_pci_register_driver(void);
void iwl_pci_unregister_driver(void);

#endif /* __iwl_trans_h__ */