[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 */
	union {
		u32 flags;
		u8 val8;
		u16 val16;
		u32 val32;
		struct iwl_tx_cmd tx;
		struct iwl6000_channel_switch_cmd chswitch;
		u8 payload[DEF_CMD_PAYLOAD_SIZE];
	} __packed cmd;
} __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
 * @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;
	void (*callback)(struct iwl_shared *shrd,
			 struct iwl_device_cmd *cmd,
			 struct iwl_rx_packet *pkt);
	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);

	int (*suspend)(struct iwl_trans *trans);
	int (*resume)(struct iwl_trans *trans);
};

/**
 * 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
 */
struct iwl_trans {
	const struct iwl_trans_ops *ops;
	struct iwl_shared *shrd;
	spinlock_t hcmd_lock;

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

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

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

#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 */
	100	union {
	101	u32 flags;
	102	u8 val8;
	103	u16 val16;
	104	u32 val32;
	105	struct iwl_tx_cmd tx;
	106	struct iwl6000_channel_switch_cmd chswitch;
	107	u8 payload[DEF_CMD_PAYLOAD_SIZE];
	108	} __packed cmd;
	109	} __packed;
	110
	111	#define TFD_MAX_PAYLOAD_SIZE (sizeof(struct iwl_device_cmd))
	112
	113	#define IWL_MAX_CMD_TFDS 2
	114
	115	enum iwl_hcmd_dataflag {
	116	IWL_HCMD_DFL_NOCOPY = BIT(0),
	117	};
	118
	119	/**
	120	* struct iwl_host_cmd - Host command to the uCode
	121	* @data: array of chunks that composes the data of the host command
	122	* @reply_page: pointer to the page that holds the response to the host command
	123	* @callback:
	124	* @flags: can be CMD_* note CMD_WANT_SKB is incompatible withe CMD_ASYNC
	125	* @len: array of the lenths of the chunks in data
	126	* @dataflags:
	127	* @id: id of the host command
	128	*/
	129	struct iwl_host_cmd {
	130	const void *data[IWL_MAX_CMD_TFDS];
	131	unsigned long reply_page;
	132	void (callback)(struct iwl_shared shrd,
	133	struct iwl_device_cmd *cmd,
	134	struct iwl_rx_packet *pkt);
	135	u32 flags;
	136	u16 len[IWL_MAX_CMD_TFDS];
	137	u8 dataflags[IWL_MAX_CMD_TFDS];
	138	u8 id;
	139	};
41c50542 EG	140
	141	/**
	142	* struct iwl_trans_ops - transport specific operations
e6bb4c9c EG	143	* @alloc: allocates the meta data (not the queues themselves)
e6bb4c9c EG	144	* @request_irq: requests IRQ - will be called before the FW load in probe flow
41c50542 EG	145	* @start_device: allocates and inits all the resources for the transport
	146	* layer.
	147	* @prepare_card_hw: claim the ownership on the HW. Will be called during
	148	* probe.
	149	* @tx_start: starts and configures all the Tx fifo - usually done once the fw
	150	* is alive.
e13c0c59	151	* @wake_any_queue: wake all the queues of a specfic context IWL_RXON_CTX_*
41c50542	152	* @stop_device:stops the whole device (embedded CPU put to reset)
41c50542	153	* @send_cmd:send a host command
41c50542	154	* @tx: send an skb
a0eaad71	155	* @reclaim: free packet until ssn. Returns a list of freed packets.
288712a6	156	* @tx_agg_alloc: allocate resources for a TX BA session
c91bd124	157	* @tx_agg_setup: setup a tx queue for AMPDU - will be called once the HW is
41c50542	158	* ready and a successful ADDBA response has been received.
7f01d567	159	* @tx_agg_disable: de-configure a Tx queue to send AMPDUs
41c50542	160	* @kick_nic: remove the RESET from the embedded CPU and let it run
41c50542 EG	161	* @free: release all the ressource for the transport layer itself such as
41c50542 EG	162	* irq, tasklet etc...
e20d4341	163	* @stop_queue: stop a specific queue
f22be624	164	* @check_stuck_queue: check if a specific queue is stuck
5f178cd2	165	* @wait_tx_queue_empty: wait until all tx queues are empty
87e5666c EG	166	* @dbgfs_register: add the dbgfs files under this directory. Files will be
87e5666c EG	167	* automatically deleted.
57210f7c EG	168	* @suspend: stop the device unless WoWLAN is configured
57210f7c EG	169	* @resume: resume activity of the device
41c50542 EG	170	*/
	171	struct iwl_trans_ops {
	172
e6bb4c9c EG	173	struct iwl_trans (alloc)(struct iwl_shared *shrd);
e6bb4c9c EG	174	int (request_irq)(struct iwl_trans iwl_trans);
6d8f6eeb EG	175	int (start_device)(struct iwl_trans trans);
	176	int (prepare_card_hw)(struct iwl_trans trans);
	177	void (stop_device)(struct iwl_trans trans);
	178	void (tx_start)(struct iwl_trans trans);
41c50542	179
14991a9d EG	180	void (wake_any_queue)(struct iwl_trans trans,
14991a9d EG	181	enum iwl_rxon_context_id ctx);
e13c0c59	182
6d8f6eeb	183	int (send_cmd)(struct iwl_trans trans, struct iwl_host_cmd *cmd);
41c50542	184
e13c0c59	185	int (tx)(struct iwl_trans trans, struct sk_buff *skb,
14991a9d EG	186	struct iwl_device_cmd *dev_cmd, enum iwl_rxon_context_id ctx,
14991a9d EG	187	u8 sta_id);
464021ff EG	188	void (reclaim)(struct iwl_trans trans, int sta_id, int tid,
	189	int txq_id, int ssn, u32 status,
	190	struct sk_buff_head *skbs);
41c50542	191
7f01d567	192	int (tx_agg_disable)(struct iwl_trans trans,
c91bd124 EG	193	enum iwl_rxon_context_id ctx, int sta_id,
c91bd124 EG	194	int tid);
288712a6 EG	195	int (tx_agg_alloc)(struct iwl_trans trans,
	196	enum iwl_rxon_context_id ctx, int sta_id, int tid,
	197	u16 *ssn);
c91bd124 EG	198	void (tx_agg_setup)(struct iwl_trans trans,
	199	enum iwl_rxon_context_id ctx, int sta_id, int tid,
	200	int frame_limit);
41c50542	201
6d8f6eeb	202	void (kick_nic)(struct iwl_trans trans);
41c50542	203
6d8f6eeb	204	void (free)(struct iwl_trans trans);
87e5666c	205
e20d4341 EG	206	void (stop_queue)(struct iwl_trans trans, int q);
e20d4341 EG	207
87e5666c	208	int (dbgfs_register)(struct iwl_trans trans, struct dentry* dir);
f22be624	209	int (check_stuck_queue)(struct iwl_trans trans, int q);
5f178cd2 EG	210	int (wait_tx_queue_empty)(struct iwl_trans trans);
5f178cd2 EG	211
57210f7c EG	212	int (suspend)(struct iwl_trans trans);
57210f7c EG	213	int (resume)(struct iwl_trans trans);
41c50542 EG	214	};
41c50542 EG	215
6fbfae8e EG	216	/**
	217	* struct iwl_trans - transport common data
	218	* @ops - pointer to iwl_trans_ops
	219	* @shrd - pointer to iwl_shared which holds shared data from the upper layer
72012474	220	* @hcmd_lock: protects HCMD
6fbfae8e	221	*/
41c50542 EG	222	struct iwl_trans {
41c50542 EG	223	const struct iwl_trans_ops *ops;
e6bb4c9c	224	struct iwl_shared *shrd;
72012474	225	spinlock_t hcmd_lock;
e6bb4c9c EG	226
	227	/* pointer to trans specific struct */
	228	/Ensure that this pointer will always be aligned to sizeof pointer /
	229	char trans_specific[0] __attribute__((__aligned__(sizeof(void *))));
41c50542 EG	230	};
41c50542 EG	231
e6bb4c9c EG	232	static inline int iwl_trans_request_irq(struct iwl_trans *trans)
	233	{
	234	return trans->ops->request_irq(trans);
	235	}
	236
	237	static inline int iwl_trans_start_device(struct iwl_trans *trans)
bdfbf092	238	{
6d8f6eeb	239	return trans->ops->start_device(trans);
bdfbf092 EG	240	}
bdfbf092 EG	241
e6bb4c9c	242	static inline int iwl_trans_prepare_card_hw(struct iwl_trans *trans)
0286cee0	243	{
6d8f6eeb	244	return trans->ops->prepare_card_hw(trans);
0286cee0 EG	245	}
0286cee0 EG	246
e6bb4c9c	247	static inline void iwl_trans_stop_device(struct iwl_trans *trans)
bdfbf092	248	{
6d8f6eeb	249	trans->ops->stop_device(trans);
bdfbf092 EG	250	}
bdfbf092 EG	251
e6bb4c9c	252	static inline void iwl_trans_tx_start(struct iwl_trans *trans)
b3c2ce13	253	{
6d8f6eeb	254	trans->ops->tx_start(trans);
b3c2ce13 EG	255	}
b3c2ce13 EG	256
14991a9d EG	257	static inline void iwl_trans_wake_any_queue(struct iwl_trans *trans,
14991a9d EG	258	enum iwl_rxon_context_id ctx)
e13c0c59 EG	259	{
	260	trans->ops->wake_any_queue(trans, ctx);
	261	}
	262
	263
e6bb4c9c	264	static inline int iwl_trans_send_cmd(struct iwl_trans *trans,
bdfbf092 EG	265	struct iwl_host_cmd *cmd)
bdfbf092 EG	266	{
6d8f6eeb	267	return trans->ops->send_cmd(trans, cmd);
bdfbf092 EG	268	}
bdfbf092 EG	269
370ad313 JB	270	int iwl_trans_send_cmd_pdu(struct iwl_trans *trans, u8 id,
370ad313 JB	271	u32 flags, u16 len, const void *data);
c85eb619	272
e6bb4c9c	273	static inline int iwl_trans_tx(struct iwl_trans trans, struct sk_buff skb,
14991a9d EG	274	struct iwl_device_cmd *dev_cmd, enum iwl_rxon_context_id ctx,
14991a9d EG	275	u8 sta_id)
47c1b496	276	{
e13c0c59	277	return trans->ops->tx(trans, skb, dev_cmd, ctx, sta_id);
47c1b496 EG	278	}
47c1b496 EG	279
464021ff EG	280	static inline void iwl_trans_reclaim(struct iwl_trans *trans, int sta_id,
464021ff EG	281	int tid, int txq_id, int ssn, u32 status,
a0eaad71 EG	282	struct sk_buff_head *skbs)
a0eaad71 EG	283	{
464021ff	284	trans->ops->reclaim(trans, sta_id, tid, txq_id, ssn, status, skbs);
a0eaad71 EG	285	}
a0eaad71 EG	286
7f01d567 EG	287	static inline int iwl_trans_tx_agg_disable(struct iwl_trans *trans,
	288	enum iwl_rxon_context_id ctx,
	289	int sta_id, int tid)
48d42c42	290	{
7f01d567	291	return trans->ops->tx_agg_disable(trans, ctx, sta_id, tid);
48d42c42 EG	292	}
48d42c42 EG	293
288712a6 EG	294	static inline int iwl_trans_tx_agg_alloc(struct iwl_trans *trans,
	295	enum iwl_rxon_context_id ctx,
	296	int sta_id, int tid, u16 *ssn)
	297	{
	298	return trans->ops->tx_agg_alloc(trans, ctx, sta_id, tid, ssn);
	299	}
	300
	301
c91bd124	302	static inline void iwl_trans_tx_agg_setup(struct iwl_trans *trans,
ba562f71 EG	303	enum iwl_rxon_context_id ctx,
	304	int sta_id, int tid,
	305	int frame_limit)
48d42c42	306	{
c91bd124	307	trans->ops->tx_agg_setup(trans, ctx, sta_id, tid, frame_limit);
48d42c42 EG	308	}
48d42c42 EG	309
e6bb4c9c	310	static inline void iwl_trans_kick_nic(struct iwl_trans *trans)
56d90f4c	311	{
6d8f6eeb	312	trans->ops->kick_nic(trans);
56d90f4c EG	313	}
56d90f4c EG	314
e6bb4c9c	315	static inline void iwl_trans_free(struct iwl_trans *trans)
34c1b7ba	316	{
6d8f6eeb	317	trans->ops->free(trans);
34c1b7ba EG	318	}
34c1b7ba EG	319
e20d4341 EG	320	static inline void iwl_trans_stop_queue(struct iwl_trans *trans, int q)
	321	{
	322	trans->ops->stop_queue(trans, q);
	323	}
	324
5f178cd2 EG	325	static inline int iwl_trans_wait_tx_queue_empty(struct iwl_trans *trans)
	326	{
	327	return trans->ops->wait_tx_queue_empty(trans);
	328	}
	329
f22be624 EG	330	static inline int iwl_trans_check_stuck_queue(struct iwl_trans *trans, int q)
	331	{
	332	return trans->ops->check_stuck_queue(trans, q);
	333	}
87e5666c EG	334	static inline int iwl_trans_dbgfs_register(struct iwl_trans *trans,
	335	struct dentry *dir)
	336	{
	337	return trans->ops->dbgfs_register(trans, dir);
	338	}
	339
57210f7c EG	340	static inline int iwl_trans_suspend(struct iwl_trans *trans)
	341	{
	342	return trans->ops->suspend(trans);
	343	}
	344
	345	static inline int iwl_trans_resume(struct iwl_trans *trans)
	346	{
	347	return trans->ops->resume(trans);
	348	}
	349
e6bb4c9c EG	350	/*****************************************************
	351	* Transport layers implementations
	352	******************************************************/
	353	extern const struct iwl_trans_ops trans_ops_pcie;
48d42c42	354
41c50542	355	#endif /* __iwl_trans_h__ */