iwl-trans.h 39.0 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
 *
8
 * Copyright(c) 2007 - 2014 Intel Corporation. All rights reserved.
9
 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
10
 * Copyright(c) 2016        Intel Deutschland GmbH
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
 *
 * 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
27
 * in the file called COPYING.
28 29
 *
 * Contact Information:
30
 *  Intel Linux Wireless <linuxwifi@intel.com>
31 32 33 34
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 * BSD LICENSE
 *
35
 * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
36
 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
37
 * Copyright(c) 2016        Intel Deutschland GmbH
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 63 64 65 66
 * 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.
 *
 *****************************************************************************/
67 68
#ifndef __iwl_trans_h__
#define __iwl_trans_h__
69

70
#include <linux/ieee80211.h>
71
#include <linux/mm.h> /* for page_address */
72
#include <linux/lockdep.h>
73
#include <linux/kernel.h>
E
Emmanuel Grumbach 已提交
74

75
#include "iwl-debug.h"
76 77
#include "iwl-config.h"
#include "iwl-fw.h"
78
#include "iwl-op-mode.h"
79

80 81 82
/**
 * DOC: Transport layer - what is it ?
 *
S
Sara Sharon 已提交
83
 * The transport layer is the layer that deals with the HW directly. It provides
84 85
 * an abstraction of the underlying HW to the upper layer. The transport layer
 * doesn't provide any policy, algorithm or anything of this kind, but only
S
Sara Sharon 已提交
86
 * mechanisms to make the HW do something. It is not completely stateless but
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
 * close to it.
 * We will have an implementation for each different supported bus.
 */

/**
 * DOC: Life cycle of the transport layer
 *
 * The transport layer has a very precise life cycle.
 *
 *	1) A helper function is called during the module initialization and
 *	   registers the bus driver's ops with the transport's alloc function.
 *	2) Bus's probe calls to the transport layer's allocation functions.
 *	   Of course this function is bus specific.
 *	3) This allocation functions will spawn the upper layer which will
 *	   register mac80211.
 *
 *	4) At some point (i.e. mac80211's start call), the op_mode will call
 *	   the following sequence:
 *	   start_hw
 *	   start_fw
 *
 *	5) Then when finished (or reset):
109
 *	   stop_device
110 111 112 113 114 115 116
 *
 *	6) Eventually, the free function will be called.
 */

/**
 * DOC: Host command section
 *
S
Sara Sharon 已提交
117
 * A host command is a command issued by the upper layer to the fw. There are
118 119
 * several versions of fw that have several APIs. The transport layer is
 * completely agnostic to these differences.
S
Sara Sharon 已提交
120
 * The transport does provide helper functionality (i.e. SYNC / ASYNC mode),
121
 */
122 123 124 125 126 127
#define SEQ_TO_QUEUE(s)	(((s) >> 8) & 0x1f)
#define QUEUE_TO_SEQ(q)	(((q) & 0x1f) << 8)
#define SEQ_TO_INDEX(s)	((s) & 0xff)
#define INDEX_TO_SEQ(i)	((i) & 0xff)
#define SEQ_RX_FRAME	cpu_to_le16(0x8000)

128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
/*
 * those functions retrieve specific information from
 * the id field in the iwl_host_cmd struct which contains
 * the command id, the group id and the version of the command
 * and vice versa
*/
static inline u8 iwl_cmd_opcode(u32 cmdid)
{
	return cmdid & 0xFF;
}

static inline u8 iwl_cmd_groupid(u32 cmdid)
{
	return ((cmdid & 0xFF00) >> 8);
}

static inline u8 iwl_cmd_version(u32 cmdid)
{
	return ((cmdid & 0xFF0000) >> 16);
}

static inline u32 iwl_cmd_id(u8 opcode, u8 groupid, u8 version)
{
	return opcode + (groupid << 8) + (version << 16);
}

154 155 156
/* make u16 wide id out of u8 group and opcode */
#define WIDE_ID(grp, opcode) ((grp << 8) | opcode)

157 158 159 160 161
/* due to the conversion, this group is special; new groups
 * should be defined in the appropriate fw-api header files
 */
#define IWL_ALWAYS_LONG_GROUP	1

162 163 164 165 166 167 168 169
/**
 * struct iwl_cmd_header
 *
 * This header format appears in the beginning of each command sent from the
 * driver, and each response/notification received from uCode.
 */
struct iwl_cmd_header {
	u8 cmd;		/* Command ID:  REPLY_RXON, etc. */
170
	u8 group_id;
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
	/*
	 * The driver sets up the sequence number to values of its choosing.
	 * uCode does not use this value, but passes it back to the driver
	 * when sending the response to each driver-originated command, so
	 * the driver can match the response to the command.  Since the values
	 * don't get used by uCode, the driver may set up an arbitrary format.
	 *
	 * There is one exception:  uCode sets bit 15 when it originates
	 * the response/notification, i.e. when the response/notification
	 * is not a direct response to a command sent by the driver.  For
	 * example, uCode issues REPLY_RX when it sends a received frame
	 * to the driver; it is not a direct response to any driver command.
	 *
	 * The Linux driver uses the following format:
	 *
	 *  0:7		tfd index - position within TX queue
	 *  8:12	TX queue id
	 *  13:14	reserved
	 *  15		unsolicited RX or uCode-originated notification
	 */
	__le16 sequence;
} __packed;

194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
/**
 * struct iwl_cmd_header_wide
 *
 * This header format appears in the beginning of each command sent from the
 * driver, and each response/notification received from uCode.
 * this is the wide version that contains more information about the command
 * like length, version and command type
 */
struct iwl_cmd_header_wide {
	u8 cmd;
	u8 group_id;
	__le16 sequence;
	__le16 length;
	u8 reserved;
	u8 version;
} __packed;

211
#define FH_RSCSR_FRAME_SIZE_MSK		0x00003FFF	/* bits 0-13 */
212 213
#define FH_RSCSR_FRAME_INVALID		0x55550000
#define FH_RSCSR_FRAME_ALIGN		0x40
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229

struct iwl_rx_packet {
	/*
	 * The first 4 bytes of the RX frame header contain both the RX frame
	 * size and some flags.
	 * Bit fields:
	 * 31:    flag flush RB request
	 * 30:    flag ignore TC (terminal counter) request
	 * 29:    flag fast IRQ request
	 * 28-14: Reserved
	 * 13-00: RX frame size
	 */
	__le32 len_n_flags;
	struct iwl_cmd_header hdr;
	u8 data[];
} __packed;
230

231 232 233 234 235 236 237 238 239 240
static inline u32 iwl_rx_packet_len(const struct iwl_rx_packet *pkt)
{
	return le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
}

static inline u32 iwl_rx_packet_payload_len(const struct iwl_rx_packet *pkt)
{
	return iwl_rx_packet_len(pkt) - sizeof(pkt->hdr);
}

241 242 243
/**
 * enum CMD_MODE - how to send the host commands ?
 *
244
 * @CMD_ASYNC: Return right away and don't wait for the response
E
Emmanuel Grumbach 已提交
245 246
 * @CMD_WANT_SKB: Not valid with CMD_ASYNC. The caller needs the buffer of
 *	the response. The caller needs to call iwl_free_resp when done.
247
 * @CMD_HIGH_PRIO: The command is high priority - it goes to the front of the
S
Sara Sharon 已提交
248
 *	command queue, but after other high priority commands. Valid only
249 250 251 252 253
 *	with CMD_ASYNC.
 * @CMD_SEND_IN_IDLE: The command should be sent even when the trans is idle.
 * @CMD_MAKE_TRANS_IDLE: The command response should mark the trans as idle.
 * @CMD_WAKE_UP_TRANS: The command response should wake up the trans
 *	(i.e. mark it as non-idle).
254 255
 * @CMD_WANT_ASYNC_CALLBACK: the op_mode's async callback function must be
 *	called after this command completes. Valid only with CMD_ASYNC.
J
Johannes Berg 已提交
256 257
 * @CMD_TB_BITMAP_POS: Position of the first bit for the TB bitmap. We need to
 *	check that we leave enough room for the TBs bitmap which needs 20 bits.
258 259
 */
enum CMD_MODE {
J
Johannes Berg 已提交
260 261
	CMD_ASYNC		= BIT(0),
	CMD_WANT_SKB		= BIT(1),
262
	CMD_SEND_IN_RFKILL	= BIT(2),
263 264 265 266
	CMD_HIGH_PRIO		= BIT(3),
	CMD_SEND_IN_IDLE	= BIT(4),
	CMD_MAKE_TRANS_IDLE	= BIT(5),
	CMD_WAKE_UP_TRANS	= BIT(6),
267
	CMD_WANT_ASYNC_CALLBACK	= BIT(7),
J
Johannes Berg 已提交
268 269

	CMD_TB_BITMAP_POS	= 11,
270 271 272 273 274 275 276 277 278 279 280 281
};

#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 {
282 283 284 285 286 287 288 289 290 291 292 293
	union {
		struct {
			struct iwl_cmd_header hdr;	/* uCode API */
			u8 payload[DEF_CMD_PAYLOAD_SIZE];
		};
		struct {
			struct iwl_cmd_header_wide hdr_wide;
			u8 payload_wide[DEF_CMD_PAYLOAD_SIZE -
					sizeof(struct iwl_cmd_header_wide) +
					sizeof(struct iwl_cmd_header)];
		};
	};
294 295 296 297
} __packed;

#define TFD_MAX_PAYLOAD_SIZE (sizeof(struct iwl_device_cmd))

298 299 300 301 302
/*
 * number of transfer buffers (fragments) per transmit frame descriptor;
 * this is just the driver's idea, the hardware supports 20
 */
#define IWL_MAX_CMD_TBS_PER_TFD	2
303

304 305 306
/**
 * struct iwl_hcmd_dataflag - flag for each one of the chunks of the command
 *
307
 * @IWL_HCMD_DFL_NOCOPY: By default, the command is copied to the host command's
308
 *	ring. The transport layer doesn't map the command's buffer to DMA, but
309
 *	rather copies it to a previously allocated DMA buffer. This flag tells
310
 *	the transport layer not to copy the command, but to map the existing
311 312 313
 *	buffer (that is passed in) instead. This saves the memcpy and allows
 *	commands that are bigger than the fixed buffer to be submitted.
 *	Note that a TFD entry after a NOCOPY one cannot be a normal copied one.
314 315 316
 * @IWL_HCMD_DFL_DUP: Only valid without NOCOPY, duplicate the memory for this
 *	chunk internally and free it again after the command completes. This
 *	can (currently) be used only once per command.
317
 *	Note that a TFD entry after a DUP one cannot be a normal copied one.
318
 */
319 320
enum iwl_hcmd_dataflag {
	IWL_HCMD_DFL_NOCOPY	= BIT(0),
321
	IWL_HCMD_DFL_DUP	= BIT(1),
322 323 324 325
};

/**
 * struct iwl_host_cmd - Host command to the uCode
326
 *
327
 * @data: array of chunks that composes the data of the host command
328 329 330
 * @resp_pkt: response packet, if %CMD_WANT_SKB was set
 * @_rx_page_order: (internally used to free response packet)
 * @_rx_page_addr: (internally used to free response packet)
331
 * @flags: can be CMD_*
332
 * @len: array of the lengths of the chunks in data
333
 * @dataflags: IWL_HCMD_DFL_*
334 335
 * @id: command id of the host command, for wide commands encoding the
 *	version and group as well
336 337
 */
struct iwl_host_cmd {
338
	const void *data[IWL_MAX_CMD_TBS_PER_TFD];
339 340 341
	struct iwl_rx_packet *resp_pkt;
	unsigned long _rx_page_addr;
	u32 _rx_page_order;
342

343
	u32 flags;
344
	u32 id;
345 346
	u16 len[IWL_MAX_CMD_TBS_PER_TFD];
	u8 dataflags[IWL_MAX_CMD_TBS_PER_TFD];
347
};
348

349 350 351 352 353
static inline void iwl_free_resp(struct iwl_host_cmd *cmd)
{
	free_pages(cmd->_rx_page_addr, cmd->_rx_page_order);
}

354 355
struct iwl_rx_cmd_buffer {
	struct page *_page;
356 357
	int _offset;
	bool _page_stolen;
358
	u32 _rx_page_order;
359
	unsigned int truesize;
360 361 362 363
};

static inline void *rxb_addr(struct iwl_rx_cmd_buffer *r)
{
364 365 366 367 368 369
	return (void *)((unsigned long)page_address(r->_page) + r->_offset);
}

static inline int rxb_offset(struct iwl_rx_cmd_buffer *r)
{
	return r->_offset;
370 371 372 373
}

static inline struct page *rxb_steal_page(struct iwl_rx_cmd_buffer *r)
{
374 375 376
	r->_page_stolen = true;
	get_page(r->_page);
	return r->_page;
377 378
}

379 380 381 382 383
static inline void iwl_free_rxb(struct iwl_rx_cmd_buffer *r)
{
	__free_pages(r->_page, r->_rx_page_order);
}

384 385
#define MAX_NO_RECLAIM_CMDS	6

386 387 388 389 390
/*
 * The first entry in driver_data array in ieee80211_tx_info
 * that can be used by the transport.
 */
#define IWL_TRANS_FIRST_DRIVER_DATA 2
391 392
#define IWL_MASK(lo, hi) ((1 << (hi)) | ((1 << (hi)) - (1 << (lo))))

393 394 395 396 397
/*
 * Maximum number of HW queues the transport layer
 * currently supports
 */
#define IWL_MAX_HW_QUEUES		32
398 399
#define IWL_MAX_TID_COUNT	8
#define IWL_FRAME_LIMIT	64
400
#define IWL_MAX_RX_HW_QUEUES	16
401

402 403 404 405 406 407 408 409 410 411
/**
 * enum iwl_wowlan_status - WoWLAN image/device status
 * @IWL_D3_STATUS_ALIVE: firmware is still running after resume
 * @IWL_D3_STATUS_RESET: device was reset while suspended
 */
enum iwl_d3_status {
	IWL_D3_STATUS_ALIVE,
	IWL_D3_STATUS_RESET,
};

412 413 414 415 416 417 418 419
/**
 * enum iwl_trans_status: transport status flags
 * @STATUS_SYNC_HCMD_ACTIVE: a SYNC command is being processed
 * @STATUS_DEVICE_ENABLED: APM is enabled
 * @STATUS_TPOWER_PMI: the device might be asleep (need to wake it up)
 * @STATUS_INT_ENABLED: interrupts are enabled
 * @STATUS_RFKILL: the HW RFkill switch is in KILL position
 * @STATUS_FW_ERROR: the fw is in error state
420 421 422
 * @STATUS_TRANS_GOING_IDLE: shutting down the trans, only special commands
 *	are sent
 * @STATUS_TRANS_IDLE: the trans is idle - general commands are not to be sent
423
 * @STATUS_TRANS_DEAD: trans is dead - avoid any read/write operation
424 425 426 427 428 429 430 431
 */
enum iwl_trans_status {
	STATUS_SYNC_HCMD_ACTIVE,
	STATUS_DEVICE_ENABLED,
	STATUS_TPOWER_PMI,
	STATUS_INT_ENABLED,
	STATUS_RFKILL,
	STATUS_FW_ERROR,
432 433
	STATUS_TRANS_GOING_IDLE,
	STATUS_TRANS_IDLE,
434
	STATUS_TRANS_DEAD,
435 436
};

437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
static inline int
iwl_trans_get_rb_size_order(enum iwl_amsdu_size rb_size)
{
	switch (rb_size) {
	case IWL_AMSDU_4K:
		return get_order(4 * 1024);
	case IWL_AMSDU_8K:
		return get_order(8 * 1024);
	case IWL_AMSDU_12K:
		return get_order(12 * 1024);
	default:
		WARN_ON(1);
		return -1;
	}
}

453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
struct iwl_hcmd_names {
	u8 cmd_id;
	const char *const cmd_name;
};

#define HCMD_NAME(x)	\
	{ .cmd_id = x, .cmd_name = #x }

struct iwl_hcmd_arr {
	const struct iwl_hcmd_names *arr;
	int size;
};

#define HCMD_ARR(x)	\
	{ .arr = x, .size = ARRAY_SIZE(x) }

469 470 471 472
/**
 * struct iwl_trans_config - transport configuration
 *
 * @op_mode: pointer to the upper layer.
473 474
 * @cmd_queue: the index of the command queue.
 *	Must be set before start_fw.
475
 * @cmd_fifo: the fifo for host commands
476
 * @cmd_q_wdg_timeout: the timeout of the watchdog timer for the command queue.
477 478 479 480 481
 * @no_reclaim_cmds: Some devices erroneously don't set the
 *	SEQ_RX_FRAME bit on some notifications, this is the
 *	list of such notifications to filter. Max length is
 *	%MAX_NO_RECLAIM_CMDS.
 * @n_no_reclaim_cmds: # of commands in list
482
 * @rx_buf_size: RX buffer size needed for A-MSDUs
483
 *	if unset 4k will be the RX buffer size
484 485
 * @bc_table_dword: set to true if the BC table expects the byte count to be
 *	in DWORD (as opposed to bytes)
486
 * @scd_set_active: should the transport configure the SCD for HCMD queue
487
 * @wide_cmd_header: firmware supports wide host command header
488
 * @sw_csum_tx: transport should compute the TCP checksum
489 490 491
 * @command_groups: array of command groups, each member is an array of the
 *	commands in the group; for debugging only
 * @command_groups_size: number of command groups, to avoid illegal access
492 493
 * @sdio_adma_addr: the default address to set for the ADMA in SDIO mode until
 *	we get the ALIVE from the uCode
494 495 496
 */
struct iwl_trans_config {
	struct iwl_op_mode *op_mode;
497

498
	u8 cmd_queue;
499
	u8 cmd_fifo;
500
	unsigned int cmd_q_wdg_timeout;
501
	const u8 *no_reclaim_cmds;
502
	unsigned int n_no_reclaim_cmds;
503

504
	enum iwl_amsdu_size rx_buf_size;
505
	bool bc_table_dword;
506
	bool scd_set_active;
507
	bool wide_cmd_header;
508
	bool sw_csum_tx;
509 510
	const struct iwl_hcmd_arr *command_groups;
	int command_groups_size;
511

512
	u32 sdio_adma_addr;
513 514
};

515 516 517 518 519
struct iwl_trans_dump_data {
	u32 len;
	u8 data[];
};

520 521
struct iwl_trans;

522 523
struct iwl_trans_txq_scd_cfg {
	u8 fifo;
524
	u8 sta_id;
525
	u8 tid;
526
	bool aggregate;
527 528 529
	int frame_limit;
};

530 531
/**
 * struct iwl_trans_ops - transport specific operations
532 533 534
 *
 * All the handlers MUST be implemented
 *
535 536 537
 * @start_hw: starts the HW. If low_power is true, the NIC needs to be taken
 *	out of a low power state. From that point on, the HW can send
 *	interrupts. May sleep.
538
 * @op_mode_leave: Turn off the HW RF kill indication if on
539
 *	May sleep
540
 * @start_fw: allocates and inits all the resources for the transport
541 542
 *	layer. Also kick a fw image.
 *	May sleep
543 544
 * @fw_alive: called when the fw sends alive notification. If the fw provides
 *	the SCD base address in SRAM, then provide it here, or 0 otherwise.
545
 *	May sleep
546
 * @stop_device: stops the whole device (embedded CPU put to reset) and stops
547 548 549 550 551
 *	the HW. If low_power is true, the NIC will be put in low power state.
 *	From that point on, the HW will be stopped but will still issue an
 *	interrupt if the HW RF kill switch is triggered.
 *	This callback must do the right thing and not crash even if %start_hw()
 *	was called but not &start_fw(). May sleep.
552
 * @d3_suspend: put the device into the correct mode for WoWLAN during
553 554
 *	suspend. This is optional, if not implemented WoWLAN will not be
 *	supported. This callback may sleep.
555 556 557
 * @d3_resume: resume the device after WoWLAN, enabling the opmode to
 *	talk to the WoWLAN image to get its status. This is optional, if not
 *	implemented WoWLAN will not be supported. This callback may sleep.
558 559 560
 * @send_cmd:send a host command. Must return -ERFKILL if RFkill is asserted.
 *	If RFkill is asserted in the middle of a SYNC host command, it must
 *	return -ERFKILL straight away.
E
Emmanuel Grumbach 已提交
561
 *	May sleep only if CMD_ASYNC is not set
562
 * @tx: send an skb. The transport relies on the op_mode to zero the
563 564 565 566
 *	the ieee80211_tx_info->driver_data. If the MPDU is an A-MSDU, all
 *	the CSUM will be taken care of (TCP CSUM and IP header in case of
 *	IPv4). If the MPDU is a single MSDU, the op_mode must compute the IP
 *	header if it is IPv4.
567
 *	Must be atomic
568
 * @reclaim: free packet until ssn. Returns a list of freed packets.
569
 *	Must be atomic
570 571
 * @txq_enable: setup a queue. To setup an AC queue, use the
 *	iwl_trans_ac_txq_enable wrapper. fw_alive must have been called before
572 573 574
 *	this one. The op_mode must not configure the HCMD queue. The scheduler
 *	configuration may be %NULL, in which case the hardware will not be
 *	configured. May sleep.
575
 * @txq_disable: de-configure a Tx queue to send AMPDUs
576
 *	Must be atomic
577
 * @wait_tx_queue_empty: wait until tx queues are empty. May sleep.
578 579
 * @freeze_txq_timer: prevents the timer of the queue from firing until the
 *	queue is set to awake. Must be atomic.
580 581 582 583 584
 * @block_txq_ptrs: stop updating the write pointers of the Tx queues. Note
 *	that the transport needs to refcount the calls since this function
 *	will be called several times with block = true, and then the queues
 *	need to be unblocked only after the same number of calls with
 *	block = false.
585 586 587
 * @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
588 589
 * @read_prph: read a DWORD from a periphery register
 * @write_prph: write a DWORD to a periphery register
590
 * @read_mem: read device's SRAM in DWORD
E
Emmanuel Grumbach 已提交
591 592
 * @write_mem: write device's SRAM in DWORD. If %buf is %NULL, then the memory
 *	will be zeroed.
593
 * @configure: configure parameters required by the transport layer from
E
Emmanuel Grumbach 已提交
594 595
 *	the op_mode. May be called several times before start_fw, can't be
 *	called after that.
D
Don Fry 已提交
596
 * @set_pmi: set the power pmi state
597 598 599 600 601
 * @grab_nic_access: wake the NIC to be able to access non-HBUS regs.
 *	Sleeping is not allowed between grab_nic_access and
 *	release_nic_access.
 * @release_nic_access: let the NIC go to sleep. The "flags" parameter
 *	must be the same one that was sent before to the grab_nic_access.
602
 * @set_bits_mask - set SRAM register according to value and mask.
603 604 605 606 607
 * @ref: grab a reference to the transport/FW layers, disallowing
 *	certain low power states
 * @unref: release a reference previously taken with @ref. Note that
 *	initially the reference count is 1, making an initial @unref
 *	necessary to allow low power states.
608 609
 * @dump_data: return a vmalloc'ed buffer with debug data, maybe containing last
 *	TX'ed commands and similar. The buffer will be vfree'd by the caller.
610
 *	Note that the transport must fill in the proper file headers.
611 612 613
 */
struct iwl_trans_ops {

614
	int (*start_hw)(struct iwl_trans *iwl_trans, bool low_power);
615
	void (*op_mode_leave)(struct iwl_trans *iwl_trans);
616 617
	int (*start_fw)(struct iwl_trans *trans, const struct fw_img *fw,
			bool run_in_rfkill);
618 619
	int (*update_sf)(struct iwl_trans *trans,
			 struct iwl_sf_region *st_fwrd_space);
620
	void (*fw_alive)(struct iwl_trans *trans, u32 scd_addr);
621
	void (*stop_device)(struct iwl_trans *trans, bool low_power);
622

623
	void (*d3_suspend)(struct iwl_trans *trans, bool test, bool reset);
624
	int (*d3_resume)(struct iwl_trans *trans, enum iwl_d3_status *status,
625
			 bool test, bool reset);
626

627
	int (*send_cmd)(struct iwl_trans *trans, struct iwl_host_cmd *cmd);
628

629
	int (*tx)(struct iwl_trans *trans, struct sk_buff *skb,
630 631 632 633
		  struct iwl_device_cmd *dev_cmd, int queue);
	void (*reclaim)(struct iwl_trans *trans, int queue, int ssn,
			struct sk_buff_head *skbs);

634
	void (*txq_enable)(struct iwl_trans *trans, int queue, u16 ssn,
635 636
			   const struct iwl_trans_txq_scd_cfg *cfg,
			   unsigned int queue_wdg_timeout);
637 638
	void (*txq_disable)(struct iwl_trans *trans, int queue,
			    bool configure_scd);
639

640
	int (*wait_tx_queue_empty)(struct iwl_trans *trans, u32 txq_bm);
641 642
	void (*freeze_txq_timer)(struct iwl_trans *trans, unsigned long txqs,
				 bool freeze);
643
	void (*block_txq_ptrs)(struct iwl_trans *trans, bool block);
644

645 646 647
	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);
648 649
	u32 (*read_prph)(struct iwl_trans *trans, u32 ofs);
	void (*write_prph)(struct iwl_trans *trans, u32 ofs, u32 val);
650 651 652
	int (*read_mem)(struct iwl_trans *trans, u32 addr,
			void *buf, int dwords);
	int (*write_mem)(struct iwl_trans *trans, u32 addr,
653
			 const void *buf, int dwords);
654 655
	void (*configure)(struct iwl_trans *trans,
			  const struct iwl_trans_config *trans_cfg);
D
Don Fry 已提交
656
	void (*set_pmi)(struct iwl_trans *trans, bool state);
657
	bool (*grab_nic_access)(struct iwl_trans *trans, unsigned long *flags);
658 659
	void (*release_nic_access)(struct iwl_trans *trans,
				   unsigned long *flags);
660 661
	void (*set_bits_mask)(struct iwl_trans *trans, u32 reg, u32 mask,
			      u32 value);
662 663
	void (*ref)(struct iwl_trans *trans);
	void (*unref)(struct iwl_trans *trans);
664
	int  (*suspend)(struct iwl_trans *trans);
665
	void (*resume)(struct iwl_trans *trans);
666

667
	struct iwl_trans_dump_data *(*dump_data)(struct iwl_trans *trans,
668
						 const struct iwl_fw_dbg_trigger_tlv
669
						 *trigger);
670 671
};

672 673 674 675 676 677 678 679 680 681 682
/**
 * enum iwl_trans_state - state of the transport layer
 *
 * @IWL_TRANS_NO_FW: no fw has sent an alive response
 * @IWL_TRANS_FW_ALIVE: a fw has sent an alive response
 */
enum iwl_trans_state {
	IWL_TRANS_NO_FW = 0,
	IWL_TRANS_FW_ALIVE	= 1,
};

683
/**
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
 * DOC: Platform power management
 *
 * There are two types of platform power management: system-wide
 * (WoWLAN) and runtime.
 *
 * In system-wide power management the entire platform goes into a low
 * power state (e.g. idle or suspend to RAM) at the same time and the
 * device is configured as a wakeup source for the entire platform.
 * This is usually triggered by userspace activity (e.g. the user
 * presses the suspend button or a power management daemon decides to
 * put the platform in low power mode).  The device's behavior in this
 * mode is dictated by the wake-on-WLAN configuration.
 *
 * In runtime power management, only the devices which are themselves
 * idle enter a low power state.  This is done at runtime, which means
 * that the entire system is still running normally.  This mode is
 * usually triggered automatically by the device driver and requires
 * the ability to enter and exit the low power modes in a very short
 * time, so there is not much impact in usability.
 *
 * The terms used for the device's behavior are as follows:
 *
 *	- D0: the device is fully powered and the host is awake;
 *	- D3: the device is in low power mode and only reacts to
 *		specific events (e.g. magic-packet received or scan
 *		results found);
 *	- D0I3: the device is in low power mode and reacts to any
 *		activity (e.g. RX);
 *
 * These terms reflect the power modes in the firmware and are not to
 * be confused with the physical device power state.  The NIC can be
 * in D0I3 mode even if, for instance, the PCI device is in D3 state.
716
 */
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738

/**
 * enum iwl_plat_pm_mode - platform power management mode
 *
 * This enumeration describes the device's platform power management
 * behavior when in idle mode (i.e. runtime power management) or when
 * in system-wide suspend (i.e WoWLAN).
 *
 * @IWL_PLAT_PM_MODE_DISABLED: power management is disabled for this
 *	device.  At runtime, this means that nothing happens and the
 *	device always remains in active.  In system-wide suspend mode,
 *	it means that the all connections will be closed automatically
 *	by mac80211 before the platform is suspended.
 * @IWL_PLAT_PM_MODE_D3: the device goes into D3 mode (i.e. WoWLAN).
 *	For runtime power management, this mode is not officially
 *	supported.
 * @IWL_PLAT_PM_MODE_D0I3: the device goes into D0I3 mode.
 */
enum iwl_plat_pm_mode {
	IWL_PLAT_PM_MODE_DISABLED,
	IWL_PLAT_PM_MODE_D3,
	IWL_PLAT_PM_MODE_D0I3,
739 740
};

741 742 743 744 745
/* Max time to wait for trans to become idle/non-idle on d0i3
 * enter/exit (in msecs).
 */
#define IWL_TRANS_IDLE_TIMEOUT 2000

746 747
/**
 * struct iwl_trans - transport common data
748
 *
749
 * @ops - pointer to iwl_trans_ops
750
 * @op_mode - pointer to the op_mode
751
 * @cfg - pointer to the configuration
752
 * @status: a bit-mask of transport status flags
753
 * @dev - pointer to struct device * that represents the device
J
Johannes Berg 已提交
754 755
 * @max_skb_frags: maximum number of fragments an SKB can have when transmitted.
 *	0 indicates that frag SKBs (NETIF_F_SG) aren't supported.
756
 * @hw_rf_id a u32 with the device RF ID
S
Sara Sharon 已提交
757
 * @hw_id: a u32 with the ID of the device / sub-device.
758
 *	Set during transport allocation.
759
 * @hw_id_str: a string with info about HW ID. Set during transport allocation.
760
 * @pm_support: set to true in start_hw if link pm is supported
E
Emmanuel Grumbach 已提交
761
 * @ltr_enabled: set to true if the LTR is enabled
762 763
 * @num_rx_queues: number of RX queues allocated by the transport;
 *	the transport must set this before calling iwl_drv_start()
764 765 766 767 768
 * @dev_cmd_pool: pool for Tx cmd allocation - for internal use only.
 *	The user should use iwl_trans_{alloc,free}_tx_cmd.
 * @dev_cmd_headroom: room needed for the transport's private use before the
 *	device_cmd for Tx - for internal use only
 *	The user should use iwl_trans_{alloc,free}_tx_cmd.
769 770 771 772
 * @rx_mpdu_cmd: MPDU RX command ID, must be assigned by opmode before
 *	starting the firmware, used for tracing
 * @rx_mpdu_cmd_hdr_size: used for tracing, amount of data before the
 *	start of the 802.11 header in the @rx_mpdu_cmd
773
 * @dflt_pwr_limit: default power limit fetched from the platform (ACPI)
774 775
 * @dbg_dest_tlv: points to the destination TLV for debug
 * @dbg_conf_tlv: array of pointers to configuration TLVs for debug
776
 * @dbg_trigger_tlv: array of pointers to triggers TLVs for debug
777
 * @dbg_dest_reg_num: num of reg_ops in %dbg_dest_tlv
778 779 780 781 782 783
 * @paging_req_addr: The location were the FW will upload / download the pages
 *	from. The address is set by the opmode
 * @paging_db: Pointer to the opmode paging data base, the pointer is set by
 *	the opmode.
 * @paging_download_buf: Buffer used for copying all of the pages before
 *	downloading them to the FW. The buffer is allocated in the opmode
784 785 786 787 788 789
 * @system_pm_mode: the system-wide power management mode in use.
 *	This mode is set dynamically, depending on the WoWLAN values
 *	configured from the userspace at runtime.
 * @runtime_pm_mode: the runtime power management mode in use.  This
 *	mode is set during the initialization phase and is not
 *	supposed to change during runtime.
790
 */
791 792
struct iwl_trans {
	const struct iwl_trans_ops *ops;
793
	struct iwl_op_mode *op_mode;
794
	const struct iwl_cfg *cfg;
795
	enum iwl_trans_state state;
796
	unsigned long status;
797

798
	struct device *dev;
J
Johannes Berg 已提交
799
	u32 max_skb_frags;
800
	u32 hw_rev;
801
	u32 hw_rf_id;
E
Emmanuel Grumbach 已提交
802
	u32 hw_id;
803
	char hw_id_str[52];
804

805 806
	u8 rx_mpdu_cmd, rx_mpdu_cmd_hdr_size;

807
	bool pm_support;
E
Emmanuel Grumbach 已提交
808
	bool ltr_enabled;
809

810 811 812
	const struct iwl_hcmd_arr *command_groups;
	int command_groups_size;

813 814
	u8 num_rx_queues;

815 816 817
	/* The following fields are internal only */
	struct kmem_cache *dev_cmd_pool;
	size_t dev_cmd_headroom;
818
	char dev_cmd_pool_name[50];
819

820 821
	struct dentry *dbgfs_dir;

822 823 824 825
#ifdef CONFIG_LOCKDEP
	struct lockdep_map sync_cmd_lockdep_map;
#endif

826 827
	u64 dflt_pwr_limit;

828
	const struct iwl_fw_dbg_dest_tlv *dbg_dest_tlv;
829 830
	const struct iwl_fw_dbg_conf_tlv *dbg_conf_tlv[FW_DBG_CONF_MAX];
	struct iwl_fw_dbg_trigger_tlv * const *dbg_trigger_tlv;
831 832
	u8 dbg_dest_reg_num;

833 834 835 836 837 838 839 840
	/*
	 * Paging parameters - All of the parameters should be set by the
	 * opmode when paging is enabled
	 */
	u32 paging_req_addr;
	struct iwl_fw_paging *paging_db;
	void *paging_download_buf;

841 842
	enum iwl_plat_pm_mode system_pm_mode;
	enum iwl_plat_pm_mode runtime_pm_mode;
843
	bool suspending;
844

845 846
	/* pointer to trans specific struct */
	/*Ensure that this pointer will always be aligned to sizeof pointer */
847
	char trans_specific[0] __aligned(sizeof(void *));
848 849
};

850 851 852
const char *iwl_get_cmd_string(struct iwl_trans *trans, u32 id);
int iwl_cmd_groups_verify_sorted(const struct iwl_trans_config *trans);

853
static inline void iwl_trans_configure(struct iwl_trans *trans,
854
				       const struct iwl_trans_config *trans_cfg)
855
{
856
	trans->op_mode = trans_cfg->op_mode;
857 858

	trans->ops->configure(trans, trans_cfg);
859
	WARN_ON(iwl_cmd_groups_verify_sorted(trans_cfg));
860 861
}

862
static inline int _iwl_trans_start_hw(struct iwl_trans *trans, bool low_power)
863
{
864 865
	might_sleep();

866 867 868 869 870 871
	return trans->ops->start_hw(trans, low_power);
}

static inline int iwl_trans_start_hw(struct iwl_trans *trans)
{
	return trans->ops->start_hw(trans, true);
872 873
}

874
static inline void iwl_trans_op_mode_leave(struct iwl_trans *trans)
875
{
876 877
	might_sleep();

878 879
	if (trans->ops->op_mode_leave)
		trans->ops->op_mode_leave(trans);
880

881
	trans->op_mode = NULL;
882

883
	trans->state = IWL_TRANS_NO_FW;
884 885
}

886
static inline void iwl_trans_fw_alive(struct iwl_trans *trans, u32 scd_addr)
887
{
888 889
	might_sleep();

890
	trans->state = IWL_TRANS_FW_ALIVE;
891

892
	trans->ops->fw_alive(trans, scd_addr);
893 894
}

895
static inline int iwl_trans_start_fw(struct iwl_trans *trans,
896 897
				     const struct fw_img *fw,
				     bool run_in_rfkill)
898
{
899 900
	might_sleep();

901 902
	WARN_ON_ONCE(!trans->rx_mpdu_cmd);

903
	clear_bit(STATUS_FW_ERROR, &trans->status);
904
	return trans->ops->start_fw(trans, fw, run_in_rfkill);
905 906
}

907 908 909 910 911 912 913 914 915 916 917
static inline int iwl_trans_update_sf(struct iwl_trans *trans,
				      struct iwl_sf_region *st_fwrd_space)
{
	might_sleep();

	if (trans->ops->update_sf)
		return trans->ops->update_sf(trans, st_fwrd_space);

	return 0;
}

918 919
static inline void _iwl_trans_stop_device(struct iwl_trans *trans,
					  bool low_power)
920
{
921 922
	might_sleep();

923
	trans->ops->stop_device(trans, low_power);
924 925

	trans->state = IWL_TRANS_NO_FW;
926 927
}

928 929 930 931 932
static inline void iwl_trans_stop_device(struct iwl_trans *trans)
{
	_iwl_trans_stop_device(trans, true);
}

933 934
static inline void iwl_trans_d3_suspend(struct iwl_trans *trans, bool test,
					bool reset)
935 936
{
	might_sleep();
937
	if (trans->ops->d3_suspend)
938
		trans->ops->d3_suspend(trans, test, reset);
939 940 941
}

static inline int iwl_trans_d3_resume(struct iwl_trans *trans,
942
				      enum iwl_d3_status *status,
943
				      bool test, bool reset)
944 945
{
	might_sleep();
946 947 948
	if (!trans->ops->d3_resume)
		return 0;

949
	return trans->ops->d3_resume(trans, status, test, reset);
950 951
}

952 953 954 955 956 957 958 959 960 961 962 963
static inline void iwl_trans_ref(struct iwl_trans *trans)
{
	if (trans->ops->ref)
		trans->ops->ref(trans);
}

static inline void iwl_trans_unref(struct iwl_trans *trans)
{
	if (trans->ops->unref)
		trans->ops->unref(trans);
}

964
static inline int iwl_trans_suspend(struct iwl_trans *trans)
965
{
966 967 968 969
	if (!trans->ops->suspend)
		return 0;

	return trans->ops->suspend(trans);
970 971 972 973 974 975 976 977
}

static inline void iwl_trans_resume(struct iwl_trans *trans)
{
	if (trans->ops->resume)
		trans->ops->resume(trans);
}

978
static inline struct iwl_trans_dump_data *
979
iwl_trans_dump_data(struct iwl_trans *trans,
980
		    const struct iwl_fw_dbg_trigger_tlv *trigger)
981 982
{
	if (!trans->ops->dump_data)
983
		return NULL;
984
	return trans->ops->dump_data(trans, trigger);
985 986
}

987 988 989 990 991 992 993 994 995 996 997 998
static inline struct iwl_device_cmd *
iwl_trans_alloc_tx_cmd(struct iwl_trans *trans)
{
	u8 *dev_cmd_ptr = kmem_cache_alloc(trans->dev_cmd_pool, GFP_ATOMIC);

	if (unlikely(dev_cmd_ptr == NULL))
		return NULL;

	return (struct iwl_device_cmd *)
			(dev_cmd_ptr + trans->dev_cmd_headroom);
}

999 1000
int iwl_trans_send_cmd(struct iwl_trans *trans, struct iwl_host_cmd *cmd);

1001 1002 1003 1004 1005 1006 1007 1008
static inline void iwl_trans_free_tx_cmd(struct iwl_trans *trans,
					 struct iwl_device_cmd *dev_cmd)
{
	u8 *dev_cmd_ptr = (u8 *)dev_cmd - trans->dev_cmd_headroom;

	kmem_cache_free(trans->dev_cmd_pool, dev_cmd_ptr);
}

1009
static inline int iwl_trans_tx(struct iwl_trans *trans, struct sk_buff *skb,
1010
			       struct iwl_device_cmd *dev_cmd, int queue)
1011
{
1012 1013 1014
	if (unlikely(test_bit(STATUS_FW_ERROR, &trans->status)))
		return -EIO;

1015
	if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
1016
		IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
1017 1018
		return -EIO;
	}
1019

1020
	return trans->ops->tx(trans, skb, dev_cmd, queue);
1021 1022
}

1023 1024
static inline void iwl_trans_reclaim(struct iwl_trans *trans, int queue,
				     int ssn, struct sk_buff_head *skbs)
1025
{
1026
	if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
1027
		IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
1028 1029
		return;
	}
1030

1031
	trans->ops->reclaim(trans, queue, ssn, skbs);
1032 1033
}

1034 1035
static inline void iwl_trans_txq_disable(struct iwl_trans *trans, int queue,
					 bool configure_scd)
1036
{
1037 1038 1039 1040 1041
	trans->ops->txq_disable(trans, queue, configure_scd);
}

static inline void
iwl_trans_txq_enable_cfg(struct iwl_trans *trans, int queue, u16 ssn,
1042 1043
			 const struct iwl_trans_txq_scd_cfg *cfg,
			 unsigned int queue_wdg_timeout)
1044 1045 1046
{
	might_sleep();

1047
	if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
1048
		IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
1049 1050
		return;
	}
1051

1052
	trans->ops->txq_enable(trans, queue, ssn, cfg, queue_wdg_timeout);
1053 1054
}

1055 1056
static inline void iwl_trans_txq_enable(struct iwl_trans *trans, int queue,
					int fifo, int sta_id, int tid,
1057 1058
					int frame_limit, u16 ssn,
					unsigned int queue_wdg_timeout)
1059
{
1060 1061 1062 1063 1064
	struct iwl_trans_txq_scd_cfg cfg = {
		.fifo = fifo,
		.sta_id = sta_id,
		.tid = tid,
		.frame_limit = frame_limit,
1065
		.aggregate = sta_id >= 0,
1066 1067
	};

1068
	iwl_trans_txq_enable_cfg(trans, queue, ssn, &cfg, queue_wdg_timeout);
1069 1070
}

1071 1072 1073
static inline
void iwl_trans_ac_txq_enable(struct iwl_trans *trans, int queue, int fifo,
			     unsigned int queue_wdg_timeout)
1074
{
1075 1076 1077 1078 1079
	struct iwl_trans_txq_scd_cfg cfg = {
		.fifo = fifo,
		.sta_id = -1,
		.tid = IWL_MAX_TID_COUNT,
		.frame_limit = IWL_FRAME_LIMIT,
1080
		.aggregate = false,
1081 1082
	};

1083
	iwl_trans_txq_enable_cfg(trans, queue, 0, &cfg, queue_wdg_timeout);
1084 1085
}

1086 1087 1088 1089
static inline void iwl_trans_freeze_txq_timer(struct iwl_trans *trans,
					      unsigned long txqs,
					      bool freeze)
{
1090
	if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
1091
		IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
1092 1093
		return;
	}
1094 1095 1096 1097 1098

	if (trans->ops->freeze_txq_timer)
		trans->ops->freeze_txq_timer(trans, txqs, freeze);
}

1099 1100 1101
static inline void iwl_trans_block_txq_ptrs(struct iwl_trans *trans,
					    bool block)
{
1102
	if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
1103
		IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
1104 1105
		return;
	}
1106 1107 1108 1109 1110

	if (trans->ops->block_txq_ptrs)
		trans->ops->block_txq_ptrs(trans, block);
}

1111
static inline int iwl_trans_wait_tx_queue_empty(struct iwl_trans *trans,
1112
						u32 txqs)
1113
{
1114
	if (WARN_ON_ONCE(trans->state != IWL_TRANS_FW_ALIVE)) {
1115
		IWL_ERR(trans, "%s bad state = %d\n", __func__, trans->state);
1116 1117
		return -EIO;
	}
1118

1119
	return trans->ops->wait_tx_queue_empty(trans, txqs);
1120 1121
}

1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
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);
}

1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
static inline u32 iwl_trans_read_prph(struct iwl_trans *trans, u32 ofs)
{
	return trans->ops->read_prph(trans, ofs);
}

static inline void iwl_trans_write_prph(struct iwl_trans *trans, u32 ofs,
					u32 val)
{
	return trans->ops->write_prph(trans, ofs, val);
}

1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
static inline int iwl_trans_read_mem(struct iwl_trans *trans, u32 addr,
				     void *buf, int dwords)
{
	return trans->ops->read_mem(trans, addr, buf, dwords);
}

#define iwl_trans_read_mem_bytes(trans, addr, buf, bufsize)		      \
	do {								      \
		if (__builtin_constant_p(bufsize))			      \
			BUILD_BUG_ON((bufsize) % sizeof(u32));		      \
		iwl_trans_read_mem(trans, addr, buf, (bufsize) / sizeof(u32));\
	} while (0)

static inline u32 iwl_trans_read_mem32(struct iwl_trans *trans, u32 addr)
{
	u32 value;

	if (WARN_ON(iwl_trans_read_mem(trans, addr, &value, 1)))
		return 0xa5a5a5a5;

	return value;
}

static inline int iwl_trans_write_mem(struct iwl_trans *trans, u32 addr,
1172
				      const void *buf, int dwords)
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182
{
	return trans->ops->write_mem(trans, addr, buf, dwords);
}

static inline u32 iwl_trans_write_mem32(struct iwl_trans *trans, u32 addr,
					u32 val)
{
	return iwl_trans_write_mem(trans, addr, &val, 1);
}

D
Don Fry 已提交
1183 1184
static inline void iwl_trans_set_pmi(struct iwl_trans *trans, bool state)
{
1185 1186
	if (trans->ops->set_pmi)
		trans->ops->set_pmi(trans, state);
D
Don Fry 已提交
1187 1188
}

1189 1190 1191 1192 1193 1194
static inline void
iwl_trans_set_bits_mask(struct iwl_trans *trans, u32 reg, u32 mask, u32 value)
{
	trans->ops->set_bits_mask(trans, reg, mask, value);
}

1195
#define iwl_trans_grab_nic_access(trans, flags)	\
1196
	__cond_lock(nic_access,				\
1197
		    likely((trans)->ops->grab_nic_access(trans, flags)))
1198

1199
static inline void __releases(nic_access)
1200
iwl_trans_release_nic_access(struct iwl_trans *trans, unsigned long *flags)
1201
{
1202
	trans->ops->release_nic_access(trans, flags);
1203
	__release(nic_access);
1204 1205
}

1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
static inline void iwl_trans_fw_error(struct iwl_trans *trans)
{
	if (WARN_ON_ONCE(!trans->op_mode))
		return;

	/* prevent double restarts due to the same erroneous FW */
	if (!test_and_set_bit(STATUS_FW_ERROR, &trans->status))
		iwl_op_mode_nic_error(trans->op_mode);
}

1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
/*****************************************************
 * transport helper functions
 *****************************************************/
struct iwl_trans *iwl_trans_alloc(unsigned int priv_size,
				  struct device *dev,
				  const struct iwl_cfg *cfg,
				  const struct iwl_trans_ops *ops,
				  size_t dev_cmd_headroom);
void iwl_trans_free(struct iwl_trans *trans);

1226
/*****************************************************
1227
* driver (transport) register/unregister functions
1228
******************************************************/
E
Emmanuel Grumbach 已提交
1229 1230
int __must_check iwl_pci_register_driver(void);
void iwl_pci_unregister_driver(void);
1231

1232
#endif /* __iwl_trans_h__ */