[linux-2.6-block.git] / drivers / net / wireless / iwlwifi / iwl-trans.h

/******************************************************************************
 *
 * 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 - 2011 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 <ilw@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 * BSD LICENSE
 *
 * Copyright(c) 2005 - 2011 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/debugfs.h>
#include <linux/skbuff.h>

#include "iwl-shared.h"
#include "iwl-commands.h"

 /*This file includes the declaration that are exported from the transport
 * layer */

struct iwl_priv;
struct iwl_shared;

#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)

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

#define DEF_CMD_PAYLOAD_SIZE 320

/**
 * struct iwl_device_cmd
 *
 * For allocation of the command and tx queues, this establishes the overall
 * size of the largest command we send to uCode, except for commands that
 * aren't fully copied and use other TFD space.
 */
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 - Host command to the uCode
 * @data: array of chunks that composes the data of the host command
 * @reply_page: pointer to the page that holds the response to the host command
 * @handler_status: return value of the handler of the command
 *	(put in setup_rx_handlers) - valid for SYNC mode only
 * @callback:
 * @flags: can be CMD_* note CMD_WANT_SKB is incompatible withe CMD_ASYNC
 * @len: array of the lenths of the chunks in data
 * @dataflags:
 * @id: id of the host command
 */
struct iwl_host_cmd {
	const void *data[IWL_MAX_CMD_TFDS];
	unsigned long reply_page;
	int handler_status;

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

/**
 * struct iwl_trans_ops - transport specific operations
 * @alloc: allocates the meta data (not the queues themselves)
 * @request_irq: requests IRQ - will be called before the FW load in probe flow
 * @start_device: allocates and inits all the resources for the transport
 *                layer.
 * @prepare_card_hw: claim the ownership on the HW. Will be called during
 *                   probe.
 * @tx_start: starts and configures all the Tx fifo - usually done once the fw
 *           is alive.
 * @wake_any_queue: wake all the queues of a specfic context IWL_RXON_CTX_*
 * @stop_device:stops the whole device (embedded CPU put to reset)
 * @send_cmd:send a host command
 * @tx: send an skb
 * @reclaim: free packet until ssn. Returns a list of freed packets.
 * @tx_agg_alloc: allocate resources for a TX BA session
 * @tx_agg_setup: setup a tx queue for AMPDU - will be called once the HW is
 *                 ready and a successful ADDBA response has been received.
 * @tx_agg_disable: de-configure a Tx queue to send AMPDUs
 * @kick_nic: remove the RESET from the embedded CPU and let it run
 * @free: release all the ressource for the transport layer itself such as
 *        irq, tasklet etc...
 * @stop_queue: stop a specific queue
 * @check_stuck_queue: check if a specific queue is stuck
 * @wait_tx_queue_empty: wait until all tx queues are empty
 * @dbgfs_register: add the dbgfs files under this directory. Files will be
 *	automatically deleted.
 * @suspend: stop the device unless WoWLAN is configured
 * @resume: resume activity of the device
 */
struct iwl_trans_ops {

	struct iwl_trans *(*alloc)(struct iwl_shared *shrd);
	int (*request_irq)(struct iwl_trans *iwl_trans);
	int (*start_device)(struct iwl_trans *trans);
	int (*prepare_card_hw)(struct iwl_trans *trans);
	void (*stop_device)(struct iwl_trans *trans);
	void (*tx_start)(struct iwl_trans *trans);

	void (*wake_any_queue)(struct iwl_trans *trans,
			       enum iwl_rxon_context_id ctx);

	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, enum iwl_rxon_context_id ctx,
		u8 sta_id);
	void (*reclaim)(struct iwl_trans *trans, int sta_id, int tid,
			int txq_id, int ssn, u32 status,
			struct sk_buff_head *skbs);

	int (*tx_agg_disable)(struct iwl_trans *trans,
			      enum iwl_rxon_context_id ctx, int sta_id,
			      int tid);
	int (*tx_agg_alloc)(struct iwl_trans *trans,
			    enum iwl_rxon_context_id ctx, int sta_id, int tid,
			    u16 *ssn);
	void (*tx_agg_setup)(struct iwl_trans *trans,
			     enum iwl_rxon_context_id ctx, int sta_id, int tid,
			     int frame_limit);

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

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

	void (*stop_queue)(struct iwl_trans *trans, int q);

	int (*dbgfs_register)(struct iwl_trans *trans, struct dentry* dir);
	int (*check_stuck_queue)(struct iwl_trans *trans, int q);
	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
};

/* one for each uCode image (inst/data, boot/init/runtime) */
struct fw_desc {
	dma_addr_t p_addr;	/* hardware address */
	void *v_addr;		/* software address */
	u32 len;		/* size in bytes */
};

struct fw_img {
	struct fw_desc code;	/* firmware code image */
	struct fw_desc data;	/* firmware data image */
};

enum iwl_ucode_type {
	IWL_UCODE_NONE,
	IWL_UCODE_REGULAR,
	IWL_UCODE_INIT,
	IWL_UCODE_WOWLAN,
};

/**
 * struct iwl_trans - transport common data
 * @ops - pointer to iwl_trans_ops
 * @shrd - pointer to iwl_shared which holds shared data from the upper layer
 * @hcmd_lock: protects HCMD
 * @ucode_write_complete: indicates that the ucode has been copied.
 * @ucode_rt: run time ucode image
 * @ucode_init: init ucode image
 * @ucode_wowlan: wake on wireless ucode image (optional)
 */
struct iwl_trans {
	const struct iwl_trans_ops *ops;
	struct iwl_shared *shrd;
	spinlock_t hcmd_lock;

	u8 ucode_write_complete;	/* the image write is complete */
	struct fw_img ucode_rt;
	struct fw_img ucode_init;
	struct fw_img ucode_wowlan;

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

static inline int iwl_trans_request_irq(struct iwl_trans *trans)
{
	return trans->ops->request_irq(trans);
}

static inline int iwl_trans_start_device(struct iwl_trans *trans)
{
	return trans->ops->start_device(trans);
}

static inline int iwl_trans_prepare_card_hw(struct iwl_trans *trans)
{
	return trans->ops->prepare_card_hw(trans);
}

static inline void iwl_trans_stop_device(struct iwl_trans *trans)
{
	trans->ops->stop_device(trans);
}

static inline void iwl_trans_tx_start(struct iwl_trans *trans)
{
	trans->ops->tx_start(trans);
}

static inline void iwl_trans_wake_any_queue(struct iwl_trans *trans,
					    enum iwl_rxon_context_id ctx)
{
	trans->ops->wake_any_queue(trans, ctx);
}


static inline int iwl_trans_send_cmd(struct iwl_trans *trans,
				struct iwl_host_cmd *cmd)
{
	return trans->ops->send_cmd(trans, cmd);
}

int iwl_trans_send_cmd_pdu(struct iwl_trans *trans, u8 id,
			   u32 flags, u16 len, const void *data);

static inline int iwl_trans_tx(struct iwl_trans *trans, struct sk_buff *skb,
		struct iwl_device_cmd *dev_cmd, enum iwl_rxon_context_id ctx,
		u8 sta_id)
{
	return trans->ops->tx(trans, skb, dev_cmd, ctx, sta_id);
}

static inline void iwl_trans_reclaim(struct iwl_trans *trans, int sta_id,
				 int tid, int txq_id, int ssn, u32 status,
				 struct sk_buff_head *skbs)
{
	trans->ops->reclaim(trans, sta_id, tid, txq_id, ssn, status, skbs);
}

static inline int iwl_trans_tx_agg_disable(struct iwl_trans *trans,
					    enum iwl_rxon_context_id ctx,
					    int sta_id, int tid)
{
	return trans->ops->tx_agg_disable(trans, ctx, sta_id, tid);
}

static inline int iwl_trans_tx_agg_alloc(struct iwl_trans *trans,
					 enum iwl_rxon_context_id ctx,
					 int sta_id, int tid, u16 *ssn)
{
	return trans->ops->tx_agg_alloc(trans, ctx, sta_id, tid, ssn);
}


static inline void iwl_trans_tx_agg_setup(struct iwl_trans *trans,
					   enum iwl_rxon_context_id ctx,
					   int sta_id, int tid,
					   int frame_limit)
{
	trans->ops->tx_agg_setup(trans, ctx, sta_id, tid, frame_limit);
}

static inline void iwl_trans_kick_nic(struct iwl_trans *trans)
{
	trans->ops->kick_nic(trans);
}

static inline void iwl_trans_free(struct iwl_trans *trans)
{
	trans->ops->free(trans);
}

static inline void iwl_trans_stop_queue(struct iwl_trans *trans, int q)
{
	trans->ops->stop_queue(trans, q);
}

static inline int iwl_trans_wait_tx_queue_empty(struct iwl_trans *trans)
{
	return trans->ops->wait_tx_queue_empty(trans);
}

static inline int iwl_trans_check_stuck_queue(struct iwl_trans *trans, int q)
{
	return trans->ops->check_stuck_queue(trans, q);
}
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

/*****************************************************
* Transport layers implementations
******************************************************/
extern const struct iwl_trans_ops trans_ops_pcie;

int iwl_alloc_fw_desc(struct iwl_bus *bus, struct fw_desc *desc,
		      const void *data, size_t len);
void iwl_dealloc_ucode(struct iwl_trans *trans);

#endif /* __iwl_trans_h__ */
Commit	Line	Data
c85eb619 EG	1	/******************************************************************************
	2	*
	3	* This file is provided under a dual BSD/GPLv2 license. When using or
	4	* redistributing this file, you may do so under either license.
	5	*
	6	* GPL LICENSE SUMMARY
	7	*
	8	* Copyright(c) 2007 - 2011 Intel Corporation. All rights reserved.
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of version 2 of the GNU General Public License as
	12	* published by the Free Software Foundation.
	13	*
	14	* This program is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
	22	* USA
	23	*
	24	* The full GNU General Public License is included in this distribution
	25	* in the file called LICENSE.GPL.
	26	*
	27	* Contact Information:
	28	* Intel Linux Wireless <ilw@linux.intel.com>
	29	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	30	*
	31	* BSD LICENSE
	32	*
	33	* Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
	34	* All rights reserved.
	35	*
	36	* Redistribution and use in source and binary forms, with or without
	37	* modification, are permitted provided that the following conditions
	38	* are met:
	39	*
	40	* * Redistributions of source code must retain the above copyright
	41	* notice, this list of conditions and the following disclaimer.
	42	* * Redistributions in binary form must reproduce the above copyright
	43	* notice, this list of conditions and the following disclaimer in
	44	* the documentation and/or other materials provided with the
	45	* distribution.
	46	* * Neither the name Intel Corporation nor the names of its
	47	* contributors may be used to endorse or promote products derived
	48	* from this software without specific prior written permission.
	49	*
	50	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	51	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	52	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	53	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	54	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	55	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	56	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	57	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	58	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	59	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	60	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	61	*
	62	*****************************************************************************/
41c50542 EG	63	#ifndef __iwl_trans_h__
41c50542 EG	64	#define __iwl_trans_h__
253a634c	65
87e5666c	66	#include <linux/debugfs.h>
a72b8b08 EG	67	#include <linux/skbuff.h>
	68
	69	#include "iwl-shared.h"
	70	#include "iwl-commands.h"
87e5666c	71
253a634c EG	72	/*This file includes the declaration that are exported from the transport
	73	* layer */
	74
41c50542	75	struct iwl_priv;
e6bb4c9c	76	struct iwl_shared;
522376d2 EG	77
	78	#define SEQ_TO_SN(seq) (((seq) & IEEE80211_SCTL_SEQ) >> 4)
	79	#define SN_TO_SEQ(ssn) (((ssn) << 4) & IEEE80211_SCTL_SEQ)
	80	#define MAX_SN ((IEEE80211_SCTL_SEQ) >> 4)
	81
	82	enum {
	83	CMD_SYNC = 0,
	84	CMD_ASYNC = BIT(0),
	85	CMD_WANT_SKB = BIT(1),
	86	CMD_ON_DEMAND = BIT(2),
	87	};
	88
	89	#define DEF_CMD_PAYLOAD_SIZE 320
	90
	91	/**
	92	* struct iwl_device_cmd
	93	*
	94	* For allocation of the command and tx queues, this establishes the overall
	95	* size of the largest command we send to uCode, except for commands that
	96	* aren't fully copied and use other TFD space.
	97	*/
	98	struct iwl_device_cmd {
	99	struct iwl_cmd_header hdr; /* uCode API */
132f98c2	100	u8 payload[DEF_CMD_PAYLOAD_SIZE];
522376d2 EG	101	} __packed;
	102
	103	#define TFD_MAX_PAYLOAD_SIZE (sizeof(struct iwl_device_cmd))
	104
	105	#define IWL_MAX_CMD_TFDS 2
	106
	107	enum iwl_hcmd_dataflag {
	108	IWL_HCMD_DFL_NOCOPY = BIT(0),
	109	};
	110
	111	/**
	112	* struct iwl_host_cmd - Host command to the uCode
	113	* @data: array of chunks that composes the data of the host command
	114	* @reply_page: pointer to the page that holds the response to the host command
247c61d6 EG	115	* @handler_status: return value of the handler of the command
247c61d6 EG	116	* (put in setup_rx_handlers) - valid for SYNC mode only
522376d2 EG	117	* @callback:
	118	* @flags: can be CMD_* note CMD_WANT_SKB is incompatible withe CMD_ASYNC
	119	* @len: array of the lenths of the chunks in data
	120	* @dataflags:
	121	* @id: id of the host command
	122	*/
	123	struct iwl_host_cmd {
	124	const void *data[IWL_MAX_CMD_TFDS];
	125	unsigned long reply_page;
247c61d6 EG	126	int handler_status;
247c61d6 EG	127
522376d2 EG	128	u32 flags;
	129	u16 len[IWL_MAX_CMD_TFDS];
	130	u8 dataflags[IWL_MAX_CMD_TFDS];
	131	u8 id;
	132	};
41c50542 EG	133
	134	/**
	135	* struct iwl_trans_ops - transport specific operations
e6bb4c9c EG	136	* @alloc: allocates the meta data (not the queues themselves)
e6bb4c9c EG	137	* @request_irq: requests IRQ - will be called before the FW load in probe flow
41c50542 EG	138	* @start_device: allocates and inits all the resources for the transport
	139	* layer.
	140	* @prepare_card_hw: claim the ownership on the HW. Will be called during
	141	* probe.
	142	* @tx_start: starts and configures all the Tx fifo - usually done once the fw
	143	* is alive.
e13c0c59	144	* @wake_any_queue: wake all the queues of a specfic context IWL_RXON_CTX_*
41c50542	145	* @stop_device:stops the whole device (embedded CPU put to reset)
41c50542	146	* @send_cmd:send a host command
41c50542	147	* @tx: send an skb
a0eaad71	148	* @reclaim: free packet until ssn. Returns a list of freed packets.
288712a6	149	* @tx_agg_alloc: allocate resources for a TX BA session
c91bd124	150	* @tx_agg_setup: setup a tx queue for AMPDU - will be called once the HW is
41c50542	151	* ready and a successful ADDBA response has been received.
7f01d567	152	* @tx_agg_disable: de-configure a Tx queue to send AMPDUs
41c50542	153	* @kick_nic: remove the RESET from the embedded CPU and let it run
41c50542 EG	154	* @free: release all the ressource for the transport layer itself such as
41c50542 EG	155	* irq, tasklet etc...
e20d4341	156	* @stop_queue: stop a specific queue
f22be624	157	* @check_stuck_queue: check if a specific queue is stuck
5f178cd2	158	* @wait_tx_queue_empty: wait until all tx queues are empty
87e5666c EG	159	* @dbgfs_register: add the dbgfs files under this directory. Files will be
87e5666c EG	160	* automatically deleted.
57210f7c EG	161	* @suspend: stop the device unless WoWLAN is configured
57210f7c EG	162	* @resume: resume activity of the device
41c50542 EG	163	*/
	164	struct iwl_trans_ops {
	165
e6bb4c9c EG	166	struct iwl_trans (alloc)(struct iwl_shared *shrd);
e6bb4c9c EG	167	int (request_irq)(struct iwl_trans iwl_trans);
6d8f6eeb EG	168	int (start_device)(struct iwl_trans trans);
	169	int (prepare_card_hw)(struct iwl_trans trans);
	170	void (stop_device)(struct iwl_trans trans);
	171	void (tx_start)(struct iwl_trans trans);
41c50542	172
14991a9d EG	173	void (wake_any_queue)(struct iwl_trans trans,
14991a9d EG	174	enum iwl_rxon_context_id ctx);
e13c0c59	175
6d8f6eeb	176	int (send_cmd)(struct iwl_trans trans, struct iwl_host_cmd *cmd);
41c50542	177
e13c0c59	178	int (tx)(struct iwl_trans trans, struct sk_buff *skb,
14991a9d EG	179	struct iwl_device_cmd *dev_cmd, enum iwl_rxon_context_id ctx,
14991a9d EG	180	u8 sta_id);
464021ff EG	181	void (reclaim)(struct iwl_trans trans, int sta_id, int tid,
	182	int txq_id, int ssn, u32 status,
	183	struct sk_buff_head *skbs);
41c50542	184
7f01d567	185	int (tx_agg_disable)(struct iwl_trans trans,
c91bd124 EG	186	enum iwl_rxon_context_id ctx, int sta_id,
c91bd124 EG	187	int tid);
288712a6 EG	188	int (tx_agg_alloc)(struct iwl_trans trans,
	189	enum iwl_rxon_context_id ctx, int sta_id, int tid,
	190	u16 *ssn);
c91bd124 EG	191	void (tx_agg_setup)(struct iwl_trans trans,
	192	enum iwl_rxon_context_id ctx, int sta_id, int tid,
	193	int frame_limit);
41c50542	194
6d8f6eeb	195	void (kick_nic)(struct iwl_trans trans);
41c50542	196
6d8f6eeb	197	void (free)(struct iwl_trans trans);
87e5666c	198
e20d4341 EG	199	void (stop_queue)(struct iwl_trans trans, int q);
e20d4341 EG	200
87e5666c	201	int (dbgfs_register)(struct iwl_trans trans, struct dentry* dir);
f22be624	202	int (check_stuck_queue)(struct iwl_trans trans, int q);
5f178cd2	203	int (wait_tx_queue_empty)(struct iwl_trans trans);
c01a4047	204	#ifdef CONFIG_PM_SLEEP
57210f7c EG	205	int (suspend)(struct iwl_trans trans);
57210f7c EG	206	int (resume)(struct iwl_trans trans);
c01a4047	207	#endif
41c50542 EG	208	};
41c50542 EG	209
de7f5f92 DF	210	/* one for each uCode image (inst/data, boot/init/runtime) */
	211	struct fw_desc {
	212	dma_addr_t p_addr; /* hardware address */
	213	void v_addr; / software address */
	214	u32 len; /* size in bytes */
	215	};
	216
	217	struct fw_img {
	218	struct fw_desc code; /* firmware code image */
	219	struct fw_desc data; /* firmware data image */
	220	};
	221
	222	enum iwl_ucode_type {
	223	IWL_UCODE_NONE,
	224	IWL_UCODE_REGULAR,
	225	IWL_UCODE_INIT,
	226	IWL_UCODE_WOWLAN,
	227	};
	228
6fbfae8e EG	229	/**
	230	* struct iwl_trans - transport common data
	231	* @ops - pointer to iwl_trans_ops
	232	* @shrd - pointer to iwl_shared which holds shared data from the upper layer
72012474	233	* @hcmd_lock: protects HCMD
5703ddb0	234	* @ucode_write_complete: indicates that the ucode has been copied.
de7f5f92 DF	235	* @ucode_rt: run time ucode image
	236	* @ucode_init: init ucode image
	237	* @ucode_wowlan: wake on wireless ucode image (optional)
6fbfae8e	238	*/
41c50542 EG	239	struct iwl_trans {
41c50542 EG	240	const struct iwl_trans_ops *ops;
e6bb4c9c	241	struct iwl_shared *shrd;
72012474	242	spinlock_t hcmd_lock;
e6bb4c9c	243
5703ddb0	244	u8 ucode_write_complete; /* the image write is complete */
de7f5f92 DF	245	struct fw_img ucode_rt;
	246	struct fw_img ucode_init;
	247	struct fw_img ucode_wowlan;
5703ddb0	248
e6bb4c9c EG	249	/* pointer to trans specific struct */
	250	/Ensure that this pointer will always be aligned to sizeof pointer /
	251	char trans_specific[0] __attribute__((__aligned__(sizeof(void *))));
41c50542 EG	252	};
41c50542 EG	253
e6bb4c9c EG	254	static inline int iwl_trans_request_irq(struct iwl_trans *trans)
	255	{
	256	return trans->ops->request_irq(trans);
	257	}
	258
	259	static inline int iwl_trans_start_device(struct iwl_trans *trans)
bdfbf092	260	{
6d8f6eeb	261	return trans->ops->start_device(trans);
bdfbf092 EG	262	}
bdfbf092 EG	263
e6bb4c9c	264	static inline int iwl_trans_prepare_card_hw(struct iwl_trans *trans)
0286cee0	265	{
6d8f6eeb	266	return trans->ops->prepare_card_hw(trans);
0286cee0 EG	267	}
0286cee0 EG	268
e6bb4c9c	269	static inline void iwl_trans_stop_device(struct iwl_trans *trans)
bdfbf092	270	{
6d8f6eeb	271	trans->ops->stop_device(trans);
bdfbf092 EG	272	}
bdfbf092 EG	273
e6bb4c9c	274	static inline void iwl_trans_tx_start(struct iwl_trans *trans)
b3c2ce13	275	{
6d8f6eeb	276	trans->ops->tx_start(trans);
b3c2ce13 EG	277	}
b3c2ce13 EG	278
14991a9d EG	279	static inline void iwl_trans_wake_any_queue(struct iwl_trans *trans,
14991a9d EG	280	enum iwl_rxon_context_id ctx)
e13c0c59 EG	281	{
	282	trans->ops->wake_any_queue(trans, ctx);
	283	}
	284
	285
e6bb4c9c	286	static inline int iwl_trans_send_cmd(struct iwl_trans *trans,
bdfbf092 EG	287	struct iwl_host_cmd *cmd)
bdfbf092 EG	288	{
6d8f6eeb	289	return trans->ops->send_cmd(trans, cmd);
bdfbf092 EG	290	}
bdfbf092 EG	291
370ad313 JB	292	int iwl_trans_send_cmd_pdu(struct iwl_trans *trans, u8 id,
370ad313 JB	293	u32 flags, u16 len, const void *data);
c85eb619	294
e6bb4c9c	295	static inline int iwl_trans_tx(struct iwl_trans trans, struct sk_buff skb,
14991a9d EG	296	struct iwl_device_cmd *dev_cmd, enum iwl_rxon_context_id ctx,
14991a9d EG	297	u8 sta_id)
47c1b496	298	{
e13c0c59	299	return trans->ops->tx(trans, skb, dev_cmd, ctx, sta_id);
47c1b496 EG	300	}
47c1b496 EG	301
464021ff EG	302	static inline void iwl_trans_reclaim(struct iwl_trans *trans, int sta_id,
464021ff EG	303	int tid, int txq_id, int ssn, u32 status,
a0eaad71 EG	304	struct sk_buff_head *skbs)
a0eaad71 EG	305	{
464021ff	306	trans->ops->reclaim(trans, sta_id, tid, txq_id, ssn, status, skbs);
a0eaad71 EG	307	}
a0eaad71 EG	308
7f01d567 EG	309	static inline int iwl_trans_tx_agg_disable(struct iwl_trans *trans,
	310	enum iwl_rxon_context_id ctx,
	311	int sta_id, int tid)
48d42c42	312	{
7f01d567	313	return trans->ops->tx_agg_disable(trans, ctx, sta_id, tid);
48d42c42 EG	314	}
48d42c42 EG	315
288712a6 EG	316	static inline int iwl_trans_tx_agg_alloc(struct iwl_trans *trans,
	317	enum iwl_rxon_context_id ctx,
	318	int sta_id, int tid, u16 *ssn)
	319	{
	320	return trans->ops->tx_agg_alloc(trans, ctx, sta_id, tid, ssn);
	321	}
	322
	323
c91bd124	324	static inline void iwl_trans_tx_agg_setup(struct iwl_trans *trans,
ba562f71 EG	325	enum iwl_rxon_context_id ctx,
	326	int sta_id, int tid,
	327	int frame_limit)
48d42c42	328	{
c91bd124	329	trans->ops->tx_agg_setup(trans, ctx, sta_id, tid, frame_limit);
48d42c42 EG	330	}
48d42c42 EG	331
e6bb4c9c	332	static inline void iwl_trans_kick_nic(struct iwl_trans *trans)
56d90f4c	333	{
6d8f6eeb	334	trans->ops->kick_nic(trans);
56d90f4c EG	335	}
56d90f4c EG	336
e6bb4c9c	337	static inline void iwl_trans_free(struct iwl_trans *trans)
34c1b7ba	338	{
6d8f6eeb	339	trans->ops->free(trans);
34c1b7ba EG	340	}
34c1b7ba EG	341
e20d4341 EG	342	static inline void iwl_trans_stop_queue(struct iwl_trans *trans, int q)
	343	{
	344	trans->ops->stop_queue(trans, q);
	345	}
	346
5f178cd2 EG	347	static inline int iwl_trans_wait_tx_queue_empty(struct iwl_trans *trans)
	348	{
	349	return trans->ops->wait_tx_queue_empty(trans);
	350	}
	351
f22be624 EG	352	static inline int iwl_trans_check_stuck_queue(struct iwl_trans *trans, int q)
	353	{
	354	return trans->ops->check_stuck_queue(trans, q);
	355	}
87e5666c EG	356	static inline int iwl_trans_dbgfs_register(struct iwl_trans *trans,
	357	struct dentry *dir)
	358	{
	359	return trans->ops->dbgfs_register(trans, dir);
	360	}
	361
c01a4047	362	#ifdef CONFIG_PM_SLEEP
57210f7c EG	363	static inline int iwl_trans_suspend(struct iwl_trans *trans)
	364	{
	365	return trans->ops->suspend(trans);
	366	}
	367
	368	static inline int iwl_trans_resume(struct iwl_trans *trans)
	369	{
	370	return trans->ops->resume(trans);
	371	}
c01a4047	372	#endif
57210f7c	373
e6bb4c9c EG	374	/*****************************************************
	375	* Transport layers implementations
	376	******************************************************/
	377	extern const struct iwl_trans_ops trans_ops_pcie;
48d42c42	378
de7f5f92 DF	379	int iwl_alloc_fw_desc(struct iwl_bus bus, struct fw_desc desc,
	380	const void *data, size_t len);
	381	void iwl_dealloc_ucode(struct iwl_trans *trans);
	382
41c50542	383	#endif /* __iwl_trans_h__ */