[deliverable/linux.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,
			       const char *msg);

	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, const char *msg);

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

/* Opaque calibration results */
struct iwl_calib_result {
	struct list_head list;
	size_t cmd_len;
	struct iwl_calib_hdr hdr;
	/* data follows */
};

/**
 * 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)
 * @nvm_device_type: indicates OTP or eeprom
 * @calib_results: list head for init calibration results
 */
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;

	/* eeprom related variables */
	int    nvm_device_type;

	/* init calibration results */
	struct list_head calib_results;

	/* 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,
					    const char *msg)
{
	trans->ops->wake_any_queue(trans, ctx, msg);
}


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,
					const char *msg)
{
	trans->ops->stop_queue(trans, q, msg);
}

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

int iwl_send_calib_results(struct iwl_trans *trans);
int iwl_calib_set(struct iwl_trans *trans,
		  const struct iwl_calib_hdr *cmd, int len);
void iwl_calib_free_results(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	173	void (wake_any_queue)(struct iwl_trans trans,
81a3de1c EG	174	enum iwl_rxon_context_id ctx,
81a3de1c EG	175	const char *msg);
e13c0c59	176
6d8f6eeb	177	int (send_cmd)(struct iwl_trans trans, struct iwl_host_cmd *cmd);
41c50542	178
e13c0c59	179	int (tx)(struct iwl_trans trans, struct sk_buff *skb,
14991a9d EG	180	struct iwl_device_cmd *dev_cmd, enum iwl_rxon_context_id ctx,
14991a9d EG	181	u8 sta_id);
464021ff EG	182	void (reclaim)(struct iwl_trans trans, int sta_id, int tid,
	183	int txq_id, int ssn, u32 status,
	184	struct sk_buff_head *skbs);
41c50542	185
7f01d567	186	int (tx_agg_disable)(struct iwl_trans trans,
c91bd124 EG	187	enum iwl_rxon_context_id ctx, int sta_id,
c91bd124 EG	188	int tid);
288712a6 EG	189	int (tx_agg_alloc)(struct iwl_trans trans,
	190	enum iwl_rxon_context_id ctx, int sta_id, int tid,
	191	u16 *ssn);
c91bd124 EG	192	void (tx_agg_setup)(struct iwl_trans trans,
	193	enum iwl_rxon_context_id ctx, int sta_id, int tid,
	194	int frame_limit);
41c50542	195
6d8f6eeb	196	void (kick_nic)(struct iwl_trans trans);
41c50542	197
6d8f6eeb	198	void (free)(struct iwl_trans trans);
87e5666c	199
81a3de1c	200	void (stop_queue)(struct iwl_trans trans, int q, const char *msg);
e20d4341	201
87e5666c	202	int (dbgfs_register)(struct iwl_trans trans, struct dentry* dir);
f22be624	203	int (check_stuck_queue)(struct iwl_trans trans, int q);
5f178cd2	204	int (wait_tx_queue_empty)(struct iwl_trans trans);
c01a4047	205	#ifdef CONFIG_PM_SLEEP
57210f7c EG	206	int (suspend)(struct iwl_trans trans);
57210f7c EG	207	int (resume)(struct iwl_trans trans);
c01a4047	208	#endif
41c50542 EG	209	};
41c50542 EG	210
de7f5f92 DF	211	/* one for each uCode image (inst/data, boot/init/runtime) */
	212	struct fw_desc {
	213	dma_addr_t p_addr; /* hardware address */
	214	void v_addr; / software address */
	215	u32 len; /* size in bytes */
	216	};
	217
	218	struct fw_img {
	219	struct fw_desc code; /* firmware code image */
	220	struct fw_desc data; /* firmware data image */
	221	};
	222
45c30dba DF	223	/* Opaque calibration results */
	224	struct iwl_calib_result {
	225	struct list_head list;
	226	size_t cmd_len;
	227	struct iwl_calib_hdr hdr;
	228	/* data follows */
	229	};
	230
6fbfae8e EG	231	/**
	232	* struct iwl_trans - transport common data
	233	* @ops - pointer to iwl_trans_ops
	234	* @shrd - pointer to iwl_shared which holds shared data from the upper layer
72012474	235	* @hcmd_lock: protects HCMD
5703ddb0	236	* @ucode_write_complete: indicates that the ucode has been copied.
de7f5f92 DF	237	* @ucode_rt: run time ucode image
	238	* @ucode_init: init ucode image
	239	* @ucode_wowlan: wake on wireless ucode image (optional)
45c30dba DF	240	* @nvm_device_type: indicates OTP or eeprom
45c30dba DF	241	* @calib_results: list head for init calibration results
6fbfae8e	242	*/
41c50542 EG	243	struct iwl_trans {
41c50542 EG	244	const struct iwl_trans_ops *ops;
e6bb4c9c	245	struct iwl_shared *shrd;
72012474	246	spinlock_t hcmd_lock;
e6bb4c9c	247
5703ddb0	248	u8 ucode_write_complete; /* the image write is complete */
de7f5f92 DF	249	struct fw_img ucode_rt;
	250	struct fw_img ucode_init;
	251	struct fw_img ucode_wowlan;
5703ddb0	252
97b52cfd DF	253	/* eeprom related variables */
	254	int nvm_device_type;
	255
45c30dba DF	256	/* init calibration results */
	257	struct list_head calib_results;
	258
e6bb4c9c EG	259	/* pointer to trans specific struct */
	260	/Ensure that this pointer will always be aligned to sizeof pointer /
	261	char trans_specific[0] __attribute__((__aligned__(sizeof(void *))));
41c50542 EG	262	};
41c50542 EG	263
e6bb4c9c EG	264	static inline int iwl_trans_request_irq(struct iwl_trans *trans)
	265	{
	266	return trans->ops->request_irq(trans);
	267	}
	268
	269	static inline int iwl_trans_start_device(struct iwl_trans *trans)
bdfbf092	270	{
6d8f6eeb	271	return trans->ops->start_device(trans);
bdfbf092 EG	272	}
bdfbf092 EG	273
e6bb4c9c	274	static inline int iwl_trans_prepare_card_hw(struct iwl_trans *trans)
0286cee0	275	{
6d8f6eeb	276	return trans->ops->prepare_card_hw(trans);
0286cee0 EG	277	}
0286cee0 EG	278
e6bb4c9c	279	static inline void iwl_trans_stop_device(struct iwl_trans *trans)
bdfbf092	280	{
6d8f6eeb	281	trans->ops->stop_device(trans);
bdfbf092 EG	282	}
bdfbf092 EG	283
e6bb4c9c	284	static inline void iwl_trans_tx_start(struct iwl_trans *trans)
b3c2ce13	285	{
6d8f6eeb	286	trans->ops->tx_start(trans);
b3c2ce13 EG	287	}
b3c2ce13 EG	288
14991a9d	289	static inline void iwl_trans_wake_any_queue(struct iwl_trans *trans,
81a3de1c EG	290	enum iwl_rxon_context_id ctx,
81a3de1c EG	291	const char *msg)
e13c0c59	292	{
81a3de1c	293	trans->ops->wake_any_queue(trans, ctx, msg);
e13c0c59 EG	294	}
	295
	296
e6bb4c9c	297	static inline int iwl_trans_send_cmd(struct iwl_trans *trans,
bdfbf092 EG	298	struct iwl_host_cmd *cmd)
bdfbf092 EG	299	{
6d8f6eeb	300	return trans->ops->send_cmd(trans, cmd);
bdfbf092 EG	301	}
bdfbf092 EG	302
370ad313 JB	303	int iwl_trans_send_cmd_pdu(struct iwl_trans *trans, u8 id,
370ad313 JB	304	u32 flags, u16 len, const void *data);
c85eb619	305
e6bb4c9c	306	static inline int iwl_trans_tx(struct iwl_trans trans, struct sk_buff skb,
14991a9d EG	307	struct iwl_device_cmd *dev_cmd, enum iwl_rxon_context_id ctx,
14991a9d EG	308	u8 sta_id)
47c1b496	309	{
e13c0c59	310	return trans->ops->tx(trans, skb, dev_cmd, ctx, sta_id);
47c1b496 EG	311	}
47c1b496 EG	312
464021ff EG	313	static inline void iwl_trans_reclaim(struct iwl_trans *trans, int sta_id,
464021ff EG	314	int tid, int txq_id, int ssn, u32 status,
a0eaad71 EG	315	struct sk_buff_head *skbs)
a0eaad71 EG	316	{
464021ff	317	trans->ops->reclaim(trans, sta_id, tid, txq_id, ssn, status, skbs);
a0eaad71 EG	318	}
a0eaad71 EG	319
7f01d567 EG	320	static inline int iwl_trans_tx_agg_disable(struct iwl_trans *trans,
	321	enum iwl_rxon_context_id ctx,
	322	int sta_id, int tid)
48d42c42	323	{
7f01d567	324	return trans->ops->tx_agg_disable(trans, ctx, sta_id, tid);
48d42c42 EG	325	}
48d42c42 EG	326
288712a6 EG	327	static inline int iwl_trans_tx_agg_alloc(struct iwl_trans *trans,
	328	enum iwl_rxon_context_id ctx,
	329	int sta_id, int tid, u16 *ssn)
	330	{
	331	return trans->ops->tx_agg_alloc(trans, ctx, sta_id, tid, ssn);
	332	}
	333
	334
c91bd124	335	static inline void iwl_trans_tx_agg_setup(struct iwl_trans *trans,
ba562f71 EG	336	enum iwl_rxon_context_id ctx,
	337	int sta_id, int tid,
	338	int frame_limit)
48d42c42	339	{
c91bd124	340	trans->ops->tx_agg_setup(trans, ctx, sta_id, tid, frame_limit);
48d42c42 EG	341	}
48d42c42 EG	342
e6bb4c9c	343	static inline void iwl_trans_kick_nic(struct iwl_trans *trans)
56d90f4c	344	{
6d8f6eeb	345	trans->ops->kick_nic(trans);
56d90f4c EG	346	}
56d90f4c EG	347
e6bb4c9c	348	static inline void iwl_trans_free(struct iwl_trans *trans)
34c1b7ba	349	{
6d8f6eeb	350	trans->ops->free(trans);
34c1b7ba EG	351	}
34c1b7ba EG	352
81a3de1c EG	353	static inline void iwl_trans_stop_queue(struct iwl_trans *trans, int q,
81a3de1c EG	354	const char *msg)
e20d4341	355	{
81a3de1c	356	trans->ops->stop_queue(trans, q, msg);
e20d4341 EG	357	}
e20d4341 EG	358
5f178cd2 EG	359	static inline int iwl_trans_wait_tx_queue_empty(struct iwl_trans *trans)
	360	{
	361	return trans->ops->wait_tx_queue_empty(trans);
	362	}
	363
f22be624 EG	364	static inline int iwl_trans_check_stuck_queue(struct iwl_trans *trans, int q)
	365	{
	366	return trans->ops->check_stuck_queue(trans, q);
	367	}
87e5666c EG	368	static inline int iwl_trans_dbgfs_register(struct iwl_trans *trans,
	369	struct dentry *dir)
	370	{
	371	return trans->ops->dbgfs_register(trans, dir);
	372	}
	373
c01a4047	374	#ifdef CONFIG_PM_SLEEP
57210f7c EG	375	static inline int iwl_trans_suspend(struct iwl_trans *trans)
	376	{
	377	return trans->ops->suspend(trans);
	378	}
	379
	380	static inline int iwl_trans_resume(struct iwl_trans *trans)
	381	{
	382	return trans->ops->resume(trans);
	383	}
c01a4047	384	#endif
57210f7c	385
e6bb4c9c EG	386	/*****************************************************
	387	* Transport layers implementations
	388	******************************************************/
	389	extern const struct iwl_trans_ops trans_ops_pcie;
48d42c42	390
de7f5f92 DF	391	int iwl_alloc_fw_desc(struct iwl_bus bus, struct fw_desc desc,
	392	const void *data, size_t len);
	393	void iwl_dealloc_ucode(struct iwl_trans *trans);
	394
45c30dba DF	395	int iwl_send_calib_results(struct iwl_trans *trans);
	396	int iwl_calib_set(struct iwl_trans *trans,
	397	const struct iwl_calib_hdr *cmd, int len);
	398	void iwl_calib_free_results(struct iwl_trans *trans);
	399
41c50542	400	#endif /* __iwl_trans_h__ */