iwl-trans.h 13.8 KB
Newer Older
1
2
3
4
5
6
7
/******************************************************************************
 *
 * 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
 *
Wey-Yi Guy's avatar
Wey-Yi Guy committed
8
 * Copyright(c) 2007 - 2012 Intel Corporation. All rights reserved.
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 *
 * 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
 *
Wey-Yi Guy's avatar
Wey-Yi Guy committed
33
 * Copyright(c) 2005 - 2012 Intel Corporation. All rights reserved.
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
 * 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>
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
struct iwl_priv;
76
struct iwl_shared;
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

#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 */
100
	u8 payload[DEF_CMD_PAYLOAD_SIZE];
101
102
103
104
105
106
107
108
109
110
111
112
113
114
} __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
115
116
 * @handler_status: return value of the handler of the command
 *	(put in setup_rx_handlers) - valid for SYNC mode only
117
118
119
120
121
122
123
124
125
 * @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;
126
127
	int handler_status;

128
129
130
131
132
	u32 flags;
	u16 len[IWL_MAX_CMD_TFDS];
	u8 dataflags[IWL_MAX_CMD_TFDS];
	u8 id;
};
133
134
135

/**
 * struct iwl_trans_ops - transport specific operations
136
 * @start_hw: starts the HW- from that point on, the HW can send interrupts
137
138
 * @stop_hw: stops the HW- from that point on, the HW will be in low power but
 *	will still issue interrupt if the HW RF kill is triggered.
139
140
 * @start_device: allocates and inits all the resources for the transport
 *                layer.
141
 * @fw_alive: called when the fw sends alive notification
142
 * @wake_any_queue: wake all the queues of a specfic context IWL_RXON_CTX_*
143
144
145
 * @stop_device:stops the whole device (embedded CPU put to reset)
 * @send_cmd:send a host command
 * @tx: send an skb
146
 * @reclaim: free packet until ssn. Returns a list of freed packets.
147
 * @tx_agg_alloc: allocate resources for a TX BA session
148
 * @tx_agg_setup: setup a tx queue for AMPDU - will be called once the HW is
149
 *                 ready and a successful ADDBA response has been received.
150
 * @tx_agg_disable: de-configure a Tx queue to send AMPDUs
151
152
153
 * @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...
154
 * @stop_queue: stop a specific queue
155
 * @check_stuck_queue: check if a specific queue is stuck
156
 * @wait_tx_queue_empty: wait until all tx queues are empty
157
158
 * @dbgfs_register: add the dbgfs files under this directory. Files will be
 *	automatically deleted.
159
160
 * @suspend: stop the device unless WoWLAN is configured
 * @resume: resume activity of the device
161
162
163
 * @write8: write a u8 to a register at offset ofs from the BAR
 * @write32: write a u32 to a register at offset ofs from the BAR
 * @read32: read a u32 register at offset ofs from the BAR
164
165
166
 */
struct iwl_trans_ops {

167
	int (*start_hw)(struct iwl_trans *iwl_trans);
168
	void (*stop_hw)(struct iwl_trans *iwl_trans);
169
	int (*start_device)(struct iwl_trans *trans);
170
	void (*fw_alive)(struct iwl_trans *trans);
171
	void (*stop_device)(struct iwl_trans *trans);
172

173
	void (*wake_any_queue)(struct iwl_trans *trans,
174
175
			       enum iwl_rxon_context_id ctx,
			       const char *msg);
176

177
	int (*send_cmd)(struct iwl_trans *trans, struct iwl_host_cmd *cmd);
178

179
	int (*tx)(struct iwl_trans *trans, struct sk_buff *skb,
180
		struct iwl_device_cmd *dev_cmd, enum iwl_rxon_context_id ctx,
181
		u8 sta_id, u8 tid);
182
	int (*reclaim)(struct iwl_trans *trans, int sta_id, int tid,
183
184
			int txq_id, int ssn, u32 status,
			struct sk_buff_head *skbs);
185

186
	int (*tx_agg_disable)(struct iwl_trans *trans,
187
			      int sta_id, int tid);
188
	int (*tx_agg_alloc)(struct iwl_trans *trans,
189
			    int sta_id, int tid);
190
191
	void (*tx_agg_setup)(struct iwl_trans *trans,
			     enum iwl_rxon_context_id ctx, int sta_id, int tid,
192
			     int frame_limit, u16 ssn);
193

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

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

198
	void (*stop_queue)(struct iwl_trans *trans, int q, const char *msg);
199

200
	int (*dbgfs_register)(struct iwl_trans *trans, struct dentry* dir);
201
	int (*check_stuck_queue)(struct iwl_trans *trans, int q);
202
	int (*wait_tx_queue_empty)(struct iwl_trans *trans);
Johannes Berg's avatar
Johannes Berg committed
203
#ifdef CONFIG_PM_SLEEP
204
205
	int (*suspend)(struct iwl_trans *trans);
	int (*resume)(struct iwl_trans *trans);
Johannes Berg's avatar
Johannes Berg committed
206
#endif
207
208
209
	void (*write8)(struct iwl_trans *trans, u32 ofs, u8 val);
	void (*write32)(struct iwl_trans *trans, u32 ofs, u32 val);
	u32 (*read32)(struct iwl_trans *trans, u32 ofs);
210
211
};

212
213
214
215
216
217
218
219
220
221
222
223
/* 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 */
};

224
225
226
227
228
229
230
231
/* Opaque calibration results */
struct iwl_calib_result {
	struct list_head list;
	size_t cmd_len;
	struct iwl_calib_hdr hdr;
	/* data follows */
};

232
233
234
235
/**
 * 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
236
 * @hcmd_lock: protects HCMD
237
 * @reg_lock - protect hw register access
238
239
 * @dev - pointer to struct device * that represents the device
 * @irq - the irq number for the device
240
 * @ucode_write_complete: indicates that the ucode has been copied.
241
242
243
 * @ucode_rt: run time ucode image
 * @ucode_init: init ucode image
 * @ucode_wowlan: wake on wireless ucode image (optional)
244
245
 * @nvm_device_type: indicates OTP or eeprom
 * @calib_results: list head for init calibration results
246
 */
247
248
struct iwl_trans {
	const struct iwl_trans_ops *ops;
249
	struct iwl_shared *shrd;
250
	spinlock_t hcmd_lock;
251
	spinlock_t reg_lock;
252

253
254
255
	struct device *dev;
	unsigned int irq;

256
	u8 ucode_write_complete;	/* the image write is complete */
257
258
259
	struct fw_img ucode_rt;
	struct fw_img ucode_init;
	struct fw_img ucode_wowlan;
260

261
262
263
	/* eeprom related variables */
	int    nvm_device_type;

264
265
266
	/* init calibration results */
	struct list_head calib_results;

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

272
static inline int iwl_trans_start_hw(struct iwl_trans *trans)
273
{
274
	return trans->ops->start_hw(trans);
275
276
}

277
278
279
280
281
static inline void iwl_trans_stop_hw(struct iwl_trans *trans)
{
	trans->ops->stop_hw(trans);
}

282
283
284
285
286
static inline void iwl_trans_fw_alive(struct iwl_trans *trans)
{
	trans->ops->fw_alive(trans);
}

287
static inline int iwl_trans_start_device(struct iwl_trans *trans)
288
{
289
	return trans->ops->start_device(trans);
290
291
}

292
static inline void iwl_trans_stop_device(struct iwl_trans *trans)
293
{
294
	trans->ops->stop_device(trans);
295
296
}

297
static inline void iwl_trans_wake_any_queue(struct iwl_trans *trans,
298
299
					    enum iwl_rxon_context_id ctx,
					    const char *msg)
300
{
301
	trans->ops->wake_any_queue(trans, ctx, msg);
302
303
304
}


305
static inline int iwl_trans_send_cmd(struct iwl_trans *trans,
306
307
				struct iwl_host_cmd *cmd)
{
308
	return trans->ops->send_cmd(trans, cmd);
309
310
}

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

314
static inline int iwl_trans_tx(struct iwl_trans *trans, struct sk_buff *skb,
315
		struct iwl_device_cmd *dev_cmd, enum iwl_rxon_context_id ctx,
316
		u8 sta_id, u8 tid)
317
{
318
	return trans->ops->tx(trans, skb, dev_cmd, ctx, sta_id, tid);
319
320
}

321
static inline int iwl_trans_reclaim(struct iwl_trans *trans, int sta_id,
322
				 int tid, int txq_id, int ssn, u32 status,
323
324
				 struct sk_buff_head *skbs)
{
325
326
	return trans->ops->reclaim(trans, sta_id, tid, txq_id, ssn,
				   status, skbs);
327
328
}

329
330
static inline int iwl_trans_tx_agg_disable(struct iwl_trans *trans,
					    int sta_id, int tid)
331
{
332
	return trans->ops->tx_agg_disable(trans, sta_id, tid);
333
334
}

335
static inline int iwl_trans_tx_agg_alloc(struct iwl_trans *trans,
336
					 int sta_id, int tid)
337
{
338
	return trans->ops->tx_agg_alloc(trans, sta_id, tid);
339
340
341
}


342
static inline void iwl_trans_tx_agg_setup(struct iwl_trans *trans,
343
344
					   enum iwl_rxon_context_id ctx,
					   int sta_id, int tid,
345
					   int frame_limit, u16 ssn)
346
{
347
	trans->ops->tx_agg_setup(trans, ctx, sta_id, tid, frame_limit, ssn);
348
349
}

350
static inline void iwl_trans_kick_nic(struct iwl_trans *trans)
351
{
352
	trans->ops->kick_nic(trans);
353
354
}

355
static inline void iwl_trans_free(struct iwl_trans *trans)
356
{
357
	trans->ops->free(trans);
358
359
}

360
361
static inline void iwl_trans_stop_queue(struct iwl_trans *trans, int q,
					const char *msg)
362
{
363
	trans->ops->stop_queue(trans, q, msg);
364
365
}

366
367
368
369
370
static inline int iwl_trans_wait_tx_queue_empty(struct iwl_trans *trans)
{
	return trans->ops->wait_tx_queue_empty(trans);
}

371
372
373
374
static inline int iwl_trans_check_stuck_queue(struct iwl_trans *trans, int q)
{
	return trans->ops->check_stuck_queue(trans, q);
}
375
376
377
378
379
380
static inline int iwl_trans_dbgfs_register(struct iwl_trans *trans,
					    struct dentry *dir)
{
	return trans->ops->dbgfs_register(trans, dir);
}

Johannes Berg's avatar
Johannes Berg committed
381
#ifdef CONFIG_PM_SLEEP
382
383
384
385
386
387
388
389
390
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);
}
Johannes Berg's avatar
Johannes Berg committed
391
#endif
392

393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
static inline void iwl_trans_write8(struct iwl_trans *trans, u32 ofs, u8 val)
{
	trans->ops->write8(trans, ofs, val);
}

static inline void iwl_trans_write32(struct iwl_trans *trans, u32 ofs, u32 val)
{
	trans->ops->write32(trans, ofs, val);
}

static inline u32 iwl_trans_read32(struct iwl_trans *trans, u32 ofs)
{
	return trans->ops->read32(trans, ofs);
}

408
/*****************************************************
409
* Utils functions
410
******************************************************/
411
int iwl_alloc_fw_desc(struct iwl_trans *trans, struct fw_desc *desc,
412
413
414
		      const void *data, size_t len);
void iwl_dealloc_ucode(struct iwl_trans *trans);

415
416
417
418
419
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);

420
421
422
423
424
425
426
427
428
429
430
431
432
433
/*****************************************************
* Transport layers implementations + their allocation function
******************************************************/
struct pci_dev;
struct pci_device_id;
extern const struct iwl_trans_ops trans_ops_pcie;
struct iwl_trans *iwl_trans_pcie_alloc(struct iwl_shared *shrd,
				       struct pci_dev *pdev,
				       const struct pci_device_id *ent);

extern const struct iwl_trans_ops trans_ops_idi;
struct iwl_trans *iwl_trans_idi_alloc(struct iwl_shared *shrd,
				      void *pdev_void,
				      const void *ent_void);
434
#endif /* __iwl_trans_h__ */