iwl-trans.h 9.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
/******************************************************************************
 *
 * 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.
 *
 *****************************************************************************/
63 64
#ifndef __iwl_trans_h__
#define __iwl_trans_h__
65

66
#include <linux/debugfs.h>
E
Emmanuel Grumbach 已提交
67 68 69 70
#include <linux/skbuff.h>

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

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

75 76 77
struct iwl_priv;
struct iwl_rxon_context;
struct iwl_host_cmd;
78
struct iwl_shared;
79
struct iwl_device_cmd;
80 81 82

/**
 * struct iwl_trans_ops - transport specific operations
83 84
 * @alloc: allocates the meta data (not the queues themselves)
 * @request_irq: requests IRQ - will be called before the FW load in probe flow
85 86 87 88 89 90
 * @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.
91
 * @wake_any_queue: wake all the queues of a specfic context IWL_RXON_CTX_*
92 93 94 95
 * @stop_device:stops the whole device (embedded CPU put to reset)
 * @send_cmd:send a host command
 * @send_cmd_pdu:send a host command: flags can be CMD_*
 * @tx: send an skb
96
 * @reclaim: free packet until ssn. Returns a list of freed packets.
97
 * @tx_agg_alloc: allocate resources for a TX BA session
98 99 100 101 102 103
 * @txq_agg_setup: setup a tx queue for AMPDU - will be called once the HW is
 *                 ready and a successful ADDBA response has been received.
 * @txq_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...
104 105
 * @dbgfs_register: add the dbgfs files under this directory. Files will be
 *	automatically deleted.
106 107
 * @suspend: stop the device unless WoWLAN is configured
 * @resume: resume activity of the device
108 109 110
 */
struct iwl_trans_ops {

111 112
	struct iwl_trans *(*alloc)(struct iwl_shared *shrd);
	int (*request_irq)(struct iwl_trans *iwl_trans);
113 114 115 116
	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);
117

118 119
	void (*wake_any_queue)(struct iwl_trans *trans, u8 ctx);

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

122
	int (*send_cmd_pdu)(struct iwl_trans *trans, u8 id, u32 flags, u16 len,
123
		     const void *data);
124 125
	int (*tx)(struct iwl_trans *trans, struct sk_buff *skb,
		struct iwl_device_cmd *dev_cmd, u8 ctx, u8 sta_id);
126 127
	void (*reclaim)(struct iwl_trans *trans, int txq_id, int ssn,
			u32 status, struct sk_buff_head *skbs);
128

129
	int (*txq_agg_disable)(struct iwl_priv *priv, u16 txq_id);
130 131 132
	int (*tx_agg_alloc)(struct iwl_trans *trans,
			    enum iwl_rxon_context_id ctx, int sta_id, int tid,
			    u16 *ssn);
133 134 135
	void (*txq_agg_setup)(struct iwl_priv *priv,
			      enum iwl_rxon_context_id ctx, int sta_id,
			      int tid, int frame_limit);
136

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

139
	void (*free)(struct iwl_trans *trans);
140 141

	int (*dbgfs_register)(struct iwl_trans *trans, struct dentry* dir);
142 143
	int (*suspend)(struct iwl_trans *trans);
	int (*resume)(struct iwl_trans *trans);
144 145
};

146 147 148 149
/**
 * 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
150
 * @hcmd_lock: protects HCMD
151
 */
152 153
struct iwl_trans {
	const struct iwl_trans_ops *ops;
154
	struct iwl_shared *shrd;
155
	spinlock_t hcmd_lock;
156 157 158 159

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

162 163 164 165 166 167
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)
168
{
169
	return trans->ops->start_device(trans);
170 171
}

172
static inline int iwl_trans_prepare_card_hw(struct iwl_trans *trans)
173
{
174
	return trans->ops->prepare_card_hw(trans);
175 176
}

177
static inline void iwl_trans_stop_device(struct iwl_trans *trans)
178
{
179
	trans->ops->stop_device(trans);
180 181
}

182
static inline void iwl_trans_tx_start(struct iwl_trans *trans)
183
{
184
	trans->ops->tx_start(trans);
185 186
}

187 188 189 190 191 192
static inline void iwl_trans_wake_any_queue(struct iwl_trans *trans, u8 ctx)
{
	trans->ops->wake_any_queue(trans, ctx);
}


193
static inline int iwl_trans_send_cmd(struct iwl_trans *trans,
194 195
				struct iwl_host_cmd *cmd)
{
196
	return trans->ops->send_cmd(trans, cmd);
197 198
}

199 200
static inline int iwl_trans_send_cmd_pdu(struct iwl_trans *trans, u8 id,
					u32 flags, u16 len, const void *data)
201
{
202
	return trans->ops->send_cmd_pdu(trans, id, flags, len, data);
203
}
204

205
static inline int iwl_trans_tx(struct iwl_trans *trans, struct sk_buff *skb,
206
		struct iwl_device_cmd *dev_cmd, u8 ctx, u8 sta_id)
207
{
208
	return trans->ops->tx(trans, skb, dev_cmd, ctx, sta_id);
209 210
}

211 212 213 214 215 216 217
static inline void iwl_trans_reclaim(struct iwl_trans *trans, int txq_id,
				 int ssn, u32 status,
				 struct sk_buff_head *skbs)
{
	trans->ops->reclaim(trans, txq_id, ssn, status, skbs);
}

218
static inline int iwl_trans_txq_agg_disable(struct iwl_trans *trans, u16 txq_id)
219
{
220
	return trans->ops->txq_agg_disable(priv(trans), txq_id);
221 222
}

223 224 225 226 227 228 229 230
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);
}


231 232 233 234
static inline void iwl_trans_txq_agg_setup(struct iwl_trans *trans,
					   enum iwl_rxon_context_id ctx,
					   int sta_id, int tid,
					   int frame_limit)
235
{
236
	trans->ops->txq_agg_setup(priv(trans), ctx, sta_id, tid, frame_limit);
237 238
}

239
static inline void iwl_trans_kick_nic(struct iwl_trans *trans)
240
{
241
	trans->ops->kick_nic(trans);
242 243
}

244
static inline void iwl_trans_free(struct iwl_trans *trans)
245
{
246
	trans->ops->free(trans);
247 248
}

249 250 251 252 253 254
static inline int iwl_trans_dbgfs_register(struct iwl_trans *trans,
					    struct dentry *dir)
{
	return trans->ops->dbgfs_register(trans, dir);
}

255 256 257 258 259 260 261 262 263 264
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);
}

265 266 267 268
/*****************************************************
* Transport layers implementations
******************************************************/
extern const struct iwl_trans_ops trans_ops_pcie;
269

270
#endif /* __iwl_trans_h__ */