[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,
			       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, u8 tid);
	int (*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,
			      int sta_id, int tid);
	int (*tx_agg_alloc)(struct iwl_trans *trans,
			    int sta_id, int tid);
	void (*tx_agg_setup)(struct iwl_trans *trans,
			     enum iwl_rxon_context_id ctx, int sta_id, int tid,
			     int frame_limit, u16 ssn);

	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, u8 tid)
{
	return trans->ops->tx(trans, skb, dev_cmd, ctx, sta_id, tid);
}

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

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

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


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, u16 ssn)
{
	trans->ops->tx_agg_setup(trans, ctx, sta_id, tid, frame_limit, ssn);
}

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