net_driver.h 34.1 KB
Newer Older
1 2 3
/****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
B
Ben Hutchings 已提交
4
 * Copyright 2005-2011 Solarflare Communications Inc.
5 6 7 8 9 10 11 12 13 14 15
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation, incorporated herein by reference.
 */

/* Common definitions for all Efx net driver code */

#ifndef EFX_NET_DRIVER_H
#define EFX_NET_DRIVER_H

16 17 18 19
#if defined(EFX_ENABLE_DEBUG) && !defined(DEBUG)
#define DEBUG
#endif

20 21 22 23
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/if_vlan.h>
24
#include <linux/timer.h>
25
#include <linux/mdio.h>
26 27 28 29 30
#include <linux/list.h>
#include <linux/pci.h>
#include <linux/device.h>
#include <linux/highmem.h>
#include <linux/workqueue.h>
31
#include <linux/vmalloc.h>
32
#include <linux/i2c.h>
33 34 35 36 37 38 39 40 41

#include "enum.h"
#include "bitfield.h"

/**************************************************************************
 *
 * Build definitions
 *
 **************************************************************************/
42

B
Ben Hutchings 已提交
43
#define EFX_DRIVER_VERSION	"3.1"
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

#ifdef EFX_ENABLE_DEBUG
#define EFX_BUG_ON_PARANOID(x) BUG_ON(x)
#define EFX_WARN_ON_PARANOID(x) WARN_ON(x)
#else
#define EFX_BUG_ON_PARANOID(x) do {} while (0)
#define EFX_WARN_ON_PARANOID(x) do {} while (0)
#endif

/**************************************************************************
 *
 * Efx data structures
 *
 **************************************************************************/

#define EFX_MAX_CHANNELS 32
#define EFX_MAX_RX_QUEUES EFX_MAX_CHANNELS

B
Ben Hutchings 已提交
62 63 64
/* Checksum generation is a per-queue option in hardware, so each
 * queue visible to the networking core is backed by two hardware TX
 * queues. */
65 66 67 68 69 70
#define EFX_MAX_TX_TC		2
#define EFX_MAX_CORE_TX_QUEUES	(EFX_MAX_TX_TC * EFX_MAX_CHANNELS)
#define EFX_TXQ_TYPE_OFFLOAD	1	/* flag */
#define EFX_TXQ_TYPE_HIGHPRI	2	/* flag */
#define EFX_TXQ_TYPES		4
#define EFX_MAX_TX_QUEUES	(EFX_TXQ_TYPES * EFX_MAX_CHANNELS)
71

72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
/**
 * struct efx_special_buffer - An Efx special buffer
 * @addr: CPU base address of the buffer
 * @dma_addr: DMA base address of the buffer
 * @len: Buffer length, in bytes
 * @index: Buffer index within controller;s buffer table
 * @entries: Number of buffer table entries
 *
 * Special buffers are used for the event queues and the TX and RX
 * descriptor queues for each channel.  They are *not* used for the
 * actual transmit and receive buffers.
 */
struct efx_special_buffer {
	void *addr;
	dma_addr_t dma_addr;
	unsigned int len;
	int index;
	int entries;
};

B
Ben Hutchings 已提交
92 93 94 95 96 97 98
enum efx_flush_state {
	FLUSH_NONE,
	FLUSH_PENDING,
	FLUSH_FAILED,
	FLUSH_DONE,
};

99 100 101 102 103 104
/**
 * struct efx_tx_buffer - An Efx TX buffer
 * @skb: The associated socket buffer.
 *	Set only on the final fragment of a packet; %NULL for all other
 *	fragments.  When this fragment completes, then we can free this
 *	skb.
B
Ben Hutchings 已提交
105 106
 * @tsoh: The associated TSO header structure, or %NULL if this
 *	buffer is not a TSO header.
107 108 109 110 111 112 113 114 115
 * @dma_addr: DMA address of the fragment.
 * @len: Length of this fragment.
 *	This field is zero when the queue slot is empty.
 * @continuation: True if this fragment is not the end of a packet.
 * @unmap_single: True if pci_unmap_single should be used.
 * @unmap_len: Length of this fragment to unmap
 */
struct efx_tx_buffer {
	const struct sk_buff *skb;
B
Ben Hutchings 已提交
116
	struct efx_tso_header *tsoh;
117 118
	dma_addr_t dma_addr;
	unsigned short len;
119 120
	bool continuation;
	bool unmap_single;
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
	unsigned short unmap_len;
};

/**
 * struct efx_tx_queue - An Efx TX queue
 *
 * This is a ring buffer of TX fragments.
 * Since the TX completion path always executes on the same
 * CPU and the xmit path can operate on different CPUs,
 * performance is increased by ensuring that the completion
 * path and the xmit path operate on different cache lines.
 * This is particularly important if the xmit path is always
 * executing on one CPU which is different from the completion
 * path.  There is also a cache line for members which are
 * read but not written on the fast path.
 *
 * @efx: The associated Efx NIC
 * @queue: DMA queue number
 * @channel: The associated channel
140
 * @core_txq: The networking core TX queue structure
141 142
 * @buffer: The software buffer ring
 * @txd: The hardware descriptor ring
143
 * @ptr_mask: The size of the ring minus 1.
144
 * @initialised: Has hardware queue been initialised?
145
 * @flushed: Used when handling queue flushing
146 147
 * @read_count: Current read pointer.
 *	This is the number of buffers that have been removed from both rings.
148 149 150 151 152 153
 * @old_write_count: The value of @write_count when last checked.
 *	This is here for performance reasons.  The xmit path will
 *	only get the up-to-date value of @write_count if this
 *	variable indicates that the queue is empty.  This is to
 *	avoid cache-line ping-pong between the xmit path and the
 *	completion path.
154 155 156 157 158 159 160 161 162 163 164 165
 * @insert_count: Current insert pointer
 *	This is the number of buffers that have been added to the
 *	software ring.
 * @write_count: Current write pointer
 *	This is the number of buffers that have been added to the
 *	hardware ring.
 * @old_read_count: The value of read_count when last checked.
 *	This is here for performance reasons.  The xmit path will
 *	only get the up-to-date value of read_count if this
 *	variable indicates that the queue is full.  This is to
 *	avoid cache-line ping-pong between the xmit path and the
 *	completion path.
B
Ben Hutchings 已提交
166 167 168 169 170 171 172
 * @tso_headers_free: A list of TSO headers allocated for this TX queue
 *	that are not in use, and so available for new TSO sends. The list
 *	is protected by the TX queue lock.
 * @tso_bursts: Number of times TSO xmit invoked by kernel
 * @tso_long_headers: Number of packets with headers too long for standard
 *	blocks
 * @tso_packets: Number of packets via the TSO xmit path
173 174 175 176
 * @pushes: Number of times the TX push feature has been used
 * @empty_read_count: If the completion path has seen the queue as empty
 *	and the transmission path has not yet checked this, the value of
 *	@read_count bitwise-added to %EFX_EMPTY_COUNT_VALID; otherwise 0.
177 178 179 180
 */
struct efx_tx_queue {
	/* Members which don't change on the fast path */
	struct efx_nic *efx ____cacheline_aligned_in_smp;
B
Ben Hutchings 已提交
181
	unsigned queue;
182
	struct efx_channel *channel;
183
	struct netdev_queue *core_txq;
184 185
	struct efx_tx_buffer *buffer;
	struct efx_special_buffer txd;
186
	unsigned int ptr_mask;
187
	bool initialised;
B
Ben Hutchings 已提交
188
	enum efx_flush_state flushed;
189 190 191

	/* Members used mainly on the completion path */
	unsigned int read_count ____cacheline_aligned_in_smp;
192
	unsigned int old_write_count;
193 194 195 196 197

	/* Members used only on the xmit path */
	unsigned int insert_count ____cacheline_aligned_in_smp;
	unsigned int write_count;
	unsigned int old_read_count;
B
Ben Hutchings 已提交
198 199 200 201
	struct efx_tso_header *tso_headers_free;
	unsigned int tso_bursts;
	unsigned int tso_long_headers;
	unsigned int tso_packets;
202 203 204 205 206
	unsigned int pushes;

	/* Members shared between paths and sometimes updated */
	unsigned int empty_read_count ____cacheline_aligned_in_smp;
#define EFX_EMPTY_COUNT_VALID 0x80000000
207 208 209 210 211 212 213 214 215 216
};

/**
 * struct efx_rx_buffer - An Efx RX data buffer
 * @dma_addr: DMA base address of the buffer
 * @skb: The associated socket buffer, if any.
 *	If both this and page are %NULL, the buffer slot is currently free.
 * @page: The associated page buffer, if any.
 *	If both this and skb are %NULL, the buffer slot is currently free.
 * @len: Buffer length, in bytes.
217
 * @is_page: Indicates if @page is valid. If false, @skb is valid.
218 219 220
 */
struct efx_rx_buffer {
	dma_addr_t dma_addr;
221 222 223 224
	union {
		struct sk_buff *skb;
		struct page *page;
	} u;
225
	unsigned int len;
226
	bool is_page;
227 228
};

229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
/**
 * struct efx_rx_page_state - Page-based rx buffer state
 *
 * Inserted at the start of every page allocated for receive buffers.
 * Used to facilitate sharing dma mappings between recycled rx buffers
 * and those passed up to the kernel.
 *
 * @refcnt: Number of struct efx_rx_buffer's referencing this page.
 *	When refcnt falls to zero, the page is unmapped for dma
 * @dma_addr: The dma address of this page.
 */
struct efx_rx_page_state {
	unsigned refcnt;
	dma_addr_t dma_addr;

	unsigned int __pad[0] ____cacheline_aligned;
};

247 248 249 250 251
/**
 * struct efx_rx_queue - An Efx RX queue
 * @efx: The associated Efx NIC
 * @buffer: The software buffer ring
 * @rxd: The hardware descriptor ring
252
 * @ptr_mask: The size of the ring minus 1.
253 254 255 256 257 258 259 260 261 262 263 264 265
 * @added_count: Number of buffers added to the receive queue.
 * @notified_count: Number of buffers given to NIC (<= @added_count).
 * @removed_count: Number of buffers removed from the receive queue.
 * @max_fill: RX descriptor maximum fill level (<= ring size)
 * @fast_fill_trigger: RX descriptor fill level that will trigger a fast fill
 *	(<= @max_fill)
 * @fast_fill_limit: The level to which a fast fill will fill
 *	(@fast_fill_trigger <= @fast_fill_limit <= @max_fill)
 * @min_fill: RX descriptor minimum non-zero fill level.
 *	This records the minimum fill level observed when a ring
 *	refill was triggered.
 * @alloc_page_count: RX allocation strategy counter.
 * @alloc_skb_count: RX allocation strategy counter.
266
 * @slow_fill: Timer used to defer efx_nic_generate_fill_event().
267
 * @flushed: Use when handling queue flushing
268 269 270 271 272
 */
struct efx_rx_queue {
	struct efx_nic *efx;
	struct efx_rx_buffer *buffer;
	struct efx_special_buffer rxd;
273
	unsigned int ptr_mask;
274 275 276 277 278 279 280 281 282 283 284

	int added_count;
	int notified_count;
	int removed_count;
	unsigned int max_fill;
	unsigned int fast_fill_trigger;
	unsigned int fast_fill_limit;
	unsigned int min_fill;
	unsigned int min_overfill;
	unsigned int alloc_page_count;
	unsigned int alloc_skb_count;
285
	struct timer_list slow_fill;
286 287
	unsigned int slow_fill_count;

B
Ben Hutchings 已提交
288
	enum efx_flush_state flushed;
289 290 291 292 293 294 295 296
};

/**
 * struct efx_buffer - An Efx general-purpose buffer
 * @addr: host base address of the buffer
 * @dma_addr: DMA base address of the buffer
 * @len: Buffer length, in bytes
 *
297
 * The NIC uses these buffers for its interrupt status registers and
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
 * MAC stats dumps.
 */
struct efx_buffer {
	void *addr;
	dma_addr_t dma_addr;
	unsigned int len;
};


enum efx_rx_alloc_method {
	RX_ALLOC_METHOD_AUTO = 0,
	RX_ALLOC_METHOD_SKB = 1,
	RX_ALLOC_METHOD_PAGE = 2,
};

/**
 * struct efx_channel - An Efx channel
 *
 * A channel comprises an event queue, at least one TX queue, at least
 * one RX queue, and an associated tasklet for processing the event
 * queue.
 *
 * @efx: Associated Efx NIC
 * @channel: Channel instance number
 * @enabled: Channel enabled indicator
 * @irq: IRQ number (MSI and MSI-X only)
324
 * @irq_moderation: IRQ moderation value (in hardware ticks)
325 326 327 328
 * @napi_dev: Net device used with NAPI
 * @napi_str: NAPI control structure
 * @work_pending: Is work pending via NAPI?
 * @eventq: Event queue buffer
329
 * @eventq_mask: Event queue pointer mask
330 331
 * @eventq_read_ptr: Event queue read pointer
 * @last_eventq_read_ptr: Last event queue read pointer value.
332 333
 * @irq_count: Number of IRQs since last adaptive moderation decision
 * @irq_mod_score: IRQ moderation score
334 335 336 337 338 339 340
 * @rx_alloc_level: Watermark based heuristic counter for pushing descriptors
 *	and diagnostic counters
 * @rx_alloc_push_pages: RX allocation method currently in use for pushing
 *	descriptors
 * @n_rx_tobe_disc: Count of RX_TOBE_DISC errors
 * @n_rx_ip_hdr_chksum_err: Count of RX IP header checksum errors
 * @n_rx_tcp_udp_chksum_err: Count of RX TCP and UDP checksum errors
B
Ben Hutchings 已提交
341
 * @n_rx_mcast_mismatch: Count of unmatched multicast frames
342 343 344
 * @n_rx_frm_trunc: Count of RX_FRM_TRUNC errors
 * @n_rx_overlength: Count of RX_OVERLENGTH errors
 * @n_skbuff_leaks: Count of skbuffs leaked due to RX overrun
345 346
 * @rx_queue: RX queue for this channel
 * @tx_queue: TX queues for this channel
347 348 349 350
 */
struct efx_channel {
	struct efx_nic *efx;
	int channel;
351
	bool enabled;
352 353 354 355
	int irq;
	unsigned int irq_moderation;
	struct net_device *napi_dev;
	struct napi_struct napi_str;
356
	bool work_pending;
357
	struct efx_special_buffer eventq;
358
	unsigned int eventq_mask;
359 360 361
	unsigned int eventq_read_ptr;
	unsigned int last_eventq_read_ptr;

362 363
	unsigned int irq_count;
	unsigned int irq_mod_score;
364 365 366
#ifdef CONFIG_RFS_ACCEL
	unsigned int rfs_filters_added;
#endif
367

368 369 370 371 372 373
	int rx_alloc_level;
	int rx_alloc_push_pages;

	unsigned n_rx_tobe_disc;
	unsigned n_rx_ip_hdr_chksum_err;
	unsigned n_rx_tcp_udp_chksum_err;
B
Ben Hutchings 已提交
374
	unsigned n_rx_mcast_mismatch;
375 376 377 378 379 380 381 382
	unsigned n_rx_frm_trunc;
	unsigned n_rx_overlength;
	unsigned n_skbuff_leaks;

	/* Used to pipeline received packets in order to optimise memory
	 * access with prefetches.
	 */
	struct efx_rx_buffer *rx_pkt;
383
	bool rx_pkt_csummed;
384

385
	struct efx_rx_queue rx_queue;
386
	struct efx_tx_queue tx_queue[EFX_TXQ_TYPES];
387 388
};

389 390 391 392 393 394
enum efx_led_mode {
	EFX_LED_OFF	= 0,
	EFX_LED_ON	= 1,
	EFX_LED_DEFAULT	= 2
};

395 396 397 398 399 400 401 402 403 404 405 406
#define STRING_TABLE_LOOKUP(val, member) \
	((val) < member ## _max) ? member ## _names[val] : "(invalid)"

extern const char *efx_loopback_mode_names[];
extern const unsigned int efx_loopback_mode_max;
#define LOOPBACK_MODE(efx) \
	STRING_TABLE_LOOKUP((efx)->loopback_mode, efx_loopback_mode)

extern const char *efx_reset_type_names[];
extern const unsigned int efx_reset_type_max;
#define RESET_TYPE(type) \
	STRING_TABLE_LOOKUP(type, efx_reset_type)
407

408 409 410 411 412 413 414 415 416 417 418 419 420
enum efx_int_mode {
	/* Be careful if altering to correct macro below */
	EFX_INT_MODE_MSIX = 0,
	EFX_INT_MODE_MSI = 1,
	EFX_INT_MODE_LEGACY = 2,
	EFX_INT_MODE_MAX	/* Insert any new items before this */
};
#define EFX_INT_MODE_USE_MSI(x) (((x)->interrupt_mode) <= EFX_INT_MODE_MSI)

enum nic_state {
	STATE_INIT = 0,
	STATE_RUNNING = 1,
	STATE_FINI = 2,
421
	STATE_DISABLED = 3,
422 423 424 425 426 427 428 429 430 431
	STATE_MAX,
};

/*
 * Alignment of page-allocated RX buffers
 *
 * Controls the number of bytes inserted at the start of an RX buffer.
 * This is the equivalent of NET_IP_ALIGN [which controls the alignment
 * of the skb->head for hardware DMA].
 */
432
#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
#define EFX_PAGE_IP_ALIGN 0
#else
#define EFX_PAGE_IP_ALIGN NET_IP_ALIGN
#endif

/*
 * Alignment of the skb->head which wraps a page-allocated RX buffer
 *
 * The skb allocated to wrap an rx_buffer can have this alignment. Since
 * the data is memcpy'd from the rx_buf, it does not need to be equal to
 * EFX_PAGE_IP_ALIGN.
 */
#define EFX_PAGE_SKB_ALIGN 2

/* Forward declaration */
struct efx_nic;

/* Pseudo bit-mask flow control field */
451 452 453
#define EFX_FC_RX	FLOW_CTRL_RX
#define EFX_FC_TX	FLOW_CTRL_TX
#define EFX_FC_AUTO	4
454

455 456 457 458 459 460 461 462 463 464
/**
 * struct efx_link_state - Current state of the link
 * @up: Link is up
 * @fd: Link is full-duplex
 * @fc: Actual flow control flags
 * @speed: Link speed (Mbps)
 */
struct efx_link_state {
	bool up;
	bool fd;
465
	u8 fc;
466 467 468
	unsigned int speed;
};

S
Steve Hodgson 已提交
469 470 471 472 473 474 475
static inline bool efx_link_state_equal(const struct efx_link_state *left,
					const struct efx_link_state *right)
{
	return left->up == right->up && left->fd == right->fd &&
		left->fc == right->fc && left->speed == right->speed;
}

476 477 478 479
/**
 * struct efx_mac_operations - Efx MAC operations table
 * @reconfigure: Reconfigure MAC. Serialised by the mac_lock
 * @update_stats: Update statistics
B
Ben Hutchings 已提交
480
 * @check_fault: Check fault state. True if fault present.
481 482
 */
struct efx_mac_operations {
B
Ben Hutchings 已提交
483
	int (*reconfigure) (struct efx_nic *efx);
484
	void (*update_stats) (struct efx_nic *efx);
B
Ben Hutchings 已提交
485
	bool (*check_fault)(struct efx_nic *efx);
486 487
};

488 489
/**
 * struct efx_phy_operations - Efx PHY operations table
490 491
 * @probe: Probe PHY and initialise efx->mdio.mode_support, efx->mdio.mmds,
 *	efx->loopback_modes.
492 493 494
 * @init: Initialise PHY
 * @fini: Shut down PHY
 * @reconfigure: Reconfigure PHY (e.g. for new link parameters)
S
Steve Hodgson 已提交
495 496
 * @poll: Update @link_state and report whether it changed.
 *	Serialised by the mac_lock.
497 498
 * @get_settings: Get ethtool settings. Serialised by the mac_lock.
 * @set_settings: Set ethtool settings. Serialised by the mac_lock.
499
 * @set_npage_adv: Set abilities advertised in (Extended) Next Page
B
Ben Hutchings 已提交
500
 *	(only needed where AN bit is set in mmds)
501
 * @test_alive: Test that PHY is 'alive' (online)
502
 * @test_name: Get the name of a PHY-specific test/result
503
 * @run_tests: Run tests and record results as appropriate (offline).
504
 *	Flags are the ethtool tests flags.
505 506
 */
struct efx_phy_operations {
507
	int (*probe) (struct efx_nic *efx);
508 509
	int (*init) (struct efx_nic *efx);
	void (*fini) (struct efx_nic *efx);
510
	void (*remove) (struct efx_nic *efx);
B
Ben Hutchings 已提交
511
	int (*reconfigure) (struct efx_nic *efx);
S
Steve Hodgson 已提交
512
	bool (*poll) (struct efx_nic *efx);
513 514 515 516
	void (*get_settings) (struct efx_nic *efx,
			      struct ethtool_cmd *ecmd);
	int (*set_settings) (struct efx_nic *efx,
			     struct ethtool_cmd *ecmd);
517
	void (*set_npage_adv) (struct efx_nic *efx, u32);
518
	int (*test_alive) (struct efx_nic *efx);
519
	const char *(*test_name) (struct efx_nic *efx, unsigned int index);
520
	int (*run_tests) (struct efx_nic *efx, int *results, unsigned flags);
521 522
};

523 524 525 526
/**
 * @enum efx_phy_mode - PHY operating mode flags
 * @PHY_MODE_NORMAL: on and should pass traffic
 * @PHY_MODE_TX_DISABLED: on with TX disabled
527 528
 * @PHY_MODE_LOW_POWER: set to low power through MDIO
 * @PHY_MODE_OFF: switched off through external control
529 530 531 532 533
 * @PHY_MODE_SPECIAL: on but will not pass traffic
 */
enum efx_phy_mode {
	PHY_MODE_NORMAL		= 0,
	PHY_MODE_TX_DISABLED	= 1,
534 535
	PHY_MODE_LOW_POWER	= 2,
	PHY_MODE_OFF		= 4,
536 537 538 539 540
	PHY_MODE_SPECIAL	= 8,
};

static inline bool efx_phy_mode_disabled(enum efx_phy_mode mode)
{
B
Ben Hutchings 已提交
541
	return !!(mode & ~PHY_MODE_TX_DISABLED);
542 543
}

544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
/*
 * Efx extended statistics
 *
 * Not all statistics are provided by all supported MACs.  The purpose
 * is this structure is to contain the raw statistics provided by each
 * MAC.
 */
struct efx_mac_stats {
	u64 tx_bytes;
	u64 tx_good_bytes;
	u64 tx_bad_bytes;
	unsigned long tx_packets;
	unsigned long tx_bad;
	unsigned long tx_pause;
	unsigned long tx_control;
	unsigned long tx_unicast;
	unsigned long tx_multicast;
	unsigned long tx_broadcast;
	unsigned long tx_lt64;
	unsigned long tx_64;
	unsigned long tx_65_to_127;
	unsigned long tx_128_to_255;
	unsigned long tx_256_to_511;
	unsigned long tx_512_to_1023;
	unsigned long tx_1024_to_15xx;
	unsigned long tx_15xx_to_jumbo;
	unsigned long tx_gtjumbo;
	unsigned long tx_collision;
	unsigned long tx_single_collision;
	unsigned long tx_multiple_collision;
	unsigned long tx_excessive_collision;
	unsigned long tx_deferred;
	unsigned long tx_late_collision;
	unsigned long tx_excessive_deferred;
	unsigned long tx_non_tcpudp;
	unsigned long tx_mac_src_error;
	unsigned long tx_ip_src_error;
	u64 rx_bytes;
	u64 rx_good_bytes;
	u64 rx_bad_bytes;
	unsigned long rx_packets;
	unsigned long rx_good;
	unsigned long rx_bad;
	unsigned long rx_pause;
	unsigned long rx_control;
	unsigned long rx_unicast;
	unsigned long rx_multicast;
	unsigned long rx_broadcast;
	unsigned long rx_lt64;
	unsigned long rx_64;
	unsigned long rx_65_to_127;
	unsigned long rx_128_to_255;
	unsigned long rx_256_to_511;
	unsigned long rx_512_to_1023;
	unsigned long rx_1024_to_15xx;
	unsigned long rx_15xx_to_jumbo;
	unsigned long rx_gtjumbo;
	unsigned long rx_bad_lt64;
	unsigned long rx_bad_64_to_15xx;
	unsigned long rx_bad_15xx_to_jumbo;
	unsigned long rx_bad_gtjumbo;
	unsigned long rx_overflow;
	unsigned long rx_missed;
	unsigned long rx_false_carrier;
	unsigned long rx_symbol_error;
	unsigned long rx_align_error;
	unsigned long rx_length_error;
	unsigned long rx_internal_error;
	unsigned long rx_good_lt64;
};

/* Number of bits used in a multicast filter hash address */
#define EFX_MCAST_HASH_BITS 8

/* Number of (single-bit) entries in a multicast filter hash */
#define EFX_MCAST_HASH_ENTRIES (1 << EFX_MCAST_HASH_BITS)

/* An Efx multicast filter hash */
union efx_multicast_hash {
	u8 byte[EFX_MCAST_HASH_ENTRIES / 8];
	efx_oword_t oword[EFX_MCAST_HASH_ENTRIES / sizeof(efx_oword_t) / 8];
};

B
Ben Hutchings 已提交
627 628
struct efx_filter_state;

629 630 631 632 633 634
/**
 * struct efx_nic - an Efx NIC
 * @name: Device name (net device name or bus id before net device registered)
 * @pci_dev: The PCI device
 * @type: Controller type attributes
 * @legacy_irq: IRQ number
635
 * @legacy_irq_enabled: Are IRQs enabled on NIC (INT_EN_KER register)?
636 637
 * @workqueue: Workqueue for port reconfigures and the HW monitor.
 *	Work items do not hold and must not acquire RTNL.
638
 * @workqueue_name: Name of workqueue
639 640 641 642
 * @reset_work: Scheduled reset workitem
 * @membase_phys: Memory BAR value as physical address
 * @membase: Memory BAR value
 * @interrupt_mode: Interrupt mode
643 644
 * @irq_rx_adaptive: Adaptive IRQ moderation enabled for RX event queues
 * @irq_rx_moderation: IRQ moderation time for RX event queues
645
 * @msg_enable: Log message enable flags
646
 * @state: Device state flag. Serialised by the rtnl_lock.
647
 * @reset_pending: Bitmask for pending resets
648 649 650
 * @tx_queue: TX DMA queues
 * @rx_queue: RX DMA queues
 * @channel: Channels
651
 * @channel_name: Names for channels and their IRQs
652 653
 * @rxq_entries: Size of receive queues requested by user.
 * @txq_entries: Size of transmit queues requested by user.
654
 * @next_buffer_table: First available buffer table id
655
 * @n_channels: Number of channels in use
B
Ben Hutchings 已提交
656 657
 * @n_rx_channels: Number of channels used for RX (= number of RX queues)
 * @n_tx_channels: Number of channels used for TX
658 659
 * @rx_buffer_len: RX buffer length
 * @rx_buffer_order: Order (log2) of number of pages for each RX buffer
660
 * @rx_hash_key: Toeplitz hash key for RSS
661
 * @rx_indir_table: Indirection table for RSS
662 663
 * @int_error_count: Number of internal errors seen recently
 * @int_error_expire: Time at which error count will be expired
664
 * @irq_status: Interrupt status buffer
665
 * @irq_zero_count: Number of legacy IRQs seen with queue flags == 0
666
 * @fatal_irq_level: IRQ level (bit number) used for serious errors
667
 * @mtd_list: List of MTDs attached to the NIC
L
Lucas De Marchi 已提交
668
 * @nic_data: Hardware dependent state
B
Ben Hutchings 已提交
669
 * @mac_lock: MAC access lock. Protects @port_enabled, @phy_mode,
670
 *	efx_monitor() and efx_reconfigure_port()
671
 * @port_enabled: Port enabled indicator.
S
Steve Hodgson 已提交
672 673 674 675
 *	Serialises efx_stop_all(), efx_start_all(), efx_monitor() and
 *	efx_mac_work() with kernel interfaces. Safe to read under any
 *	one of the rtnl_lock, mac_lock, or netif_tx_lock, but all three must
 *	be held to modify it.
676 677 678
 * @port_initialized: Port initialized?
 * @net_dev: Operating system network device. Consider holding the rtnl lock
 * @stats_buffer: DMA buffer for statistics
679
 * @mac_op: MAC interface
680 681 682
 * @phy_type: PHY type
 * @phy_op: PHY interface
 * @phy_data: PHY private data (including PHY-specific stats)
683
 * @mdio: PHY MDIO interface
684
 * @mdio_bus: PHY MDIO bus ID (only used by Siena)
B
Ben Hutchings 已提交
685
 * @phy_mode: PHY operating mode. Serialised by @mac_lock.
B
Ben Hutchings 已提交
686
 * @link_advertising: Autonegotiation advertising flags
687
 * @link_state: Current state of the link
688 689 690
 * @n_link_state_changes: Number of times the link has changed state
 * @promiscuous: Promiscuous flag. Protected by netif_tx_lock.
 * @multicast_hash: Multicast hash table
B
Ben Hutchings 已提交
691
 * @wanted_fc: Wanted flow control flags
692
 * @mac_work: Work item for changing MAC promiscuity and multicast hash
693 694 695
 * @loopback_mode: Loopback status
 * @loopback_modes: Supported loopback mode bitmask
 * @loopback_selftest: Offline self-test private state
696 697 698 699 700 701 702 703 704 705 706
 * @monitor_work: Hardware monitor workitem
 * @biu_lock: BIU (bus interface unit) lock
 * @last_irq_cpu: Last CPU to handle interrupt.
 *	This register is written with the SMP processor ID whenever an
 *	interrupt is handled.  It is used by efx_nic_test_interrupt()
 *	to verify that an interrupt has occurred.
 * @n_rx_nodesc_drop_cnt: RX no descriptor drop count
 * @mac_stats: MAC statistics. These include all statistics the MACs
 *	can provide.  Generic code converts these into a standard
 *	&struct net_device_stats.
 * @stats_lock: Statistics update lock. Serialises statistics fetches
707
 *
708
 * This is stored in the private area of the &struct net_device.
709 710
 */
struct efx_nic {
711 712
	/* The following fields should be written very rarely */

713 714 715 716
	char name[IFNAMSIZ];
	struct pci_dev *pci_dev;
	const struct efx_nic_type *type;
	int legacy_irq;
717
	bool legacy_irq_enabled;
718
	struct workqueue_struct *workqueue;
719
	char workqueue_name[16];
720
	struct work_struct reset_work;
721
	resource_size_t membase_phys;
722
	void __iomem *membase;
723

724
	enum efx_int_mode interrupt_mode;
725 726
	bool irq_rx_adaptive;
	unsigned int irq_rx_moderation;
727
	u32 msg_enable;
728 729

	enum nic_state state;
730
	unsigned long reset_pending;
731

732
	struct efx_channel *channel[EFX_MAX_CHANNELS];
733
	char channel_name[EFX_MAX_CHANNELS][IFNAMSIZ + 6];
734

735 736
	unsigned rxq_entries;
	unsigned txq_entries;
737
	unsigned next_buffer_table;
B
Ben Hutchings 已提交
738 739
	unsigned n_channels;
	unsigned n_rx_channels;
740
	unsigned tx_channel_offset;
B
Ben Hutchings 已提交
741
	unsigned n_tx_channels;
742 743
	unsigned int rx_buffer_len;
	unsigned int rx_buffer_order;
744
	u8 rx_hash_key[40];
745
	u32 rx_indir_table[128];
746

747 748 749
	unsigned int_error_count;
	unsigned long int_error_expire;

750
	struct efx_buffer irq_status;
751
	unsigned irq_zero_count;
752
	unsigned fatal_irq_level;
753

754 755 756
#ifdef CONFIG_SFC_MTD
	struct list_head mtd_list;
#endif
757

758
	void *nic_data;
759 760

	struct mutex mac_lock;
761
	struct work_struct mac_work;
762
	bool port_enabled;
763

764
	bool port_initialized;
765 766 767 768
	struct net_device *net_dev;

	struct efx_buffer stats_buffer;

769
	const struct efx_mac_operations *mac_op;
770

771
	unsigned int phy_type;
772
	const struct efx_phy_operations *phy_op;
773
	void *phy_data;
774
	struct mdio_if_info mdio;
775
	unsigned int mdio_bus;
776
	enum efx_phy_mode phy_mode;
777

B
Ben Hutchings 已提交
778
	u32 link_advertising;
779
	struct efx_link_state link_state;
780 781
	unsigned int n_link_state_changes;

782
	bool promiscuous;
783
	union efx_multicast_hash multicast_hash;
784
	u8 wanted_fc;
785 786

	atomic_t rx_reset;
787
	enum efx_loopback_mode loopback_mode;
788
	u64 loopback_modes;
789 790

	void *loopback_selftest;
B
Ben Hutchings 已提交
791 792

	struct efx_filter_state *filter_state;
793 794 795 796 797 798 799 800 801

	/* The following fields may be written more often */

	struct delayed_work monitor_work ____cacheline_aligned_in_smp;
	spinlock_t biu_lock;
	volatile signed int last_irq_cpu;
	unsigned n_rx_nodesc_drop_cnt;
	struct efx_mac_stats mac_stats;
	spinlock_t stats_lock;
802 803
};

804 805 806 807 808 809 810 811 812 813 814 815 816 817
static inline int efx_dev_registered(struct efx_nic *efx)
{
	return efx->net_dev->reg_state == NETREG_REGISTERED;
}

/* Net device name, for inclusion in log messages if it has been registered.
 * Use efx->name not efx->net_dev->name so that races with (un)registration
 * are harmless.
 */
static inline const char *efx_dev_name(struct efx_nic *efx)
{
	return efx_dev_registered(efx) ? efx->name : "";
}

818 819
static inline unsigned int efx_port_num(struct efx_nic *efx)
{
820
	return efx->net_dev->dev_id;
821 822
}

823 824
/**
 * struct efx_nic_type - Efx device type definition
825 826 827 828 829
 * @probe: Probe the controller
 * @remove: Free resources allocated by probe()
 * @init: Initialise the controller
 * @fini: Shut down the controller
 * @monitor: Periodic function for polling link state and hardware monitor
830 831
 * @map_reset_reason: Map ethtool reset reason to a reset method
 * @map_reset_flags: Map ethtool reset flags to a reset method, if possible
832 833 834 835
 * @reset: Reset the controller hardware and possibly the PHY.  This will
 *	be called while the controller is uninitialised.
 * @probe_port: Probe the MAC and PHY
 * @remove_port: Free resources allocated by probe_port()
836
 * @handle_global_event: Handle a "global" event (may be %NULL)
837 838 839 840
 * @prepare_flush: Prepare the hardware for flushing the DMA queues
 * @update_stats: Update statistics not provided by event handling
 * @start_stats: Start the regular fetching of statistics
 * @stop_stats: Stop the regular fetching of statistics
841
 * @set_id_led: Set state of identifying LED or revert to automatic function
842 843
 * @push_irq_moderation: Apply interrupt moderation value
 * @push_multicast_hash: Apply multicast hash table
B
Ben Hutchings 已提交
844
 * @reconfigure_port: Push loopback/power/txdis changes to the MAC and PHY
845 846 847
 * @get_wol: Get WoL configuration from driver state
 * @set_wol: Push WoL configuration to the NIC
 * @resume_wol: Synchronise WoL state between driver and MC (e.g. after resume)
848
 * @test_registers: Test read/write functionality of control registers
849
 * @test_nvram: Test validity of NVRAM contents
850
 * @default_mac_ops: efx_mac_operations to set at startup
851
 * @revision: Hardware architecture revision
852 853 854 855 856 857 858
 * @mem_map_size: Memory BAR mapped size
 * @txd_ptr_tbl_base: TX descriptor ring base address
 * @rxd_ptr_tbl_base: RX descriptor ring base address
 * @buf_tbl_base: Buffer table base address
 * @evq_ptr_tbl_base: Event queue pointer table base address
 * @evq_rptr_tbl_base: Event queue read-pointer table base address
 * @max_dma_mask: Maximum possible DMA mask
859 860
 * @rx_buffer_hash_size: Size of hash at start of RX buffer
 * @rx_buffer_padding: Size of padding at end of RX buffer
861 862 863 864
 * @max_interrupt_mode: Highest capability interrupt mode supported
 *	from &enum efx_init_mode.
 * @phys_addr_channels: Number of channels with physically addressed
 *	descriptors
865 866
 * @tx_dc_base: Base address in SRAM of TX queue descriptor caches
 * @rx_dc_base: Base address in SRAM of RX queue descriptor caches
867 868
 * @offload_features: net_device feature flags for protocol offload
 *	features implemented in hardware
869 870
 */
struct efx_nic_type {
871 872 873 874 875
	int (*probe)(struct efx_nic *efx);
	void (*remove)(struct efx_nic *efx);
	int (*init)(struct efx_nic *efx);
	void (*fini)(struct efx_nic *efx);
	void (*monitor)(struct efx_nic *efx);
876 877
	enum reset_type (*map_reset_reason)(enum reset_type reason);
	int (*map_reset_flags)(u32 *flags);
878 879 880
	int (*reset)(struct efx_nic *efx, enum reset_type method);
	int (*probe_port)(struct efx_nic *efx);
	void (*remove_port)(struct efx_nic *efx);
881
	bool (*handle_global_event)(struct efx_channel *channel, efx_qword_t *);
882 883 884 885
	void (*prepare_flush)(struct efx_nic *efx);
	void (*update_stats)(struct efx_nic *efx);
	void (*start_stats)(struct efx_nic *efx);
	void (*stop_stats)(struct efx_nic *efx);
886
	void (*set_id_led)(struct efx_nic *efx, enum efx_led_mode mode);
887 888
	void (*push_irq_moderation)(struct efx_channel *channel);
	void (*push_multicast_hash)(struct efx_nic *efx);
B
Ben Hutchings 已提交
889
	int (*reconfigure_port)(struct efx_nic *efx);
890 891 892
	void (*get_wol)(struct efx_nic *efx, struct ethtool_wolinfo *wol);
	int (*set_wol)(struct efx_nic *efx, u32 type);
	void (*resume_wol)(struct efx_nic *efx);
893
	int (*test_registers)(struct efx_nic *efx);
894
	int (*test_nvram)(struct efx_nic *efx);
895
	const struct efx_mac_operations *default_mac_ops;
896

897
	int revision;
898 899 900 901 902 903
	unsigned int mem_map_size;
	unsigned int txd_ptr_tbl_base;
	unsigned int rxd_ptr_tbl_base;
	unsigned int buf_tbl_base;
	unsigned int evq_ptr_tbl_base;
	unsigned int evq_rptr_tbl_base;
904
	u64 max_dma_mask;
905
	unsigned int rx_buffer_hash_size;
906 907 908
	unsigned int rx_buffer_padding;
	unsigned int max_interrupt_mode;
	unsigned int phys_addr_channels;
909 910
	unsigned int tx_dc_base;
	unsigned int rx_dc_base;
911
	u32 offload_features;
912 913 914 915 916 917 918 919
};

/**************************************************************************
 *
 * Prototypes and inline functions
 *
 *************************************************************************/

920 921 922 923
static inline struct efx_channel *
efx_get_channel(struct efx_nic *efx, unsigned index)
{
	EFX_BUG_ON_PARANOID(index >= efx->n_channels);
924
	return efx->channel[index];
925 926
}

927 928
/* Iterate over all used channels */
#define efx_for_each_channel(_channel, _efx)				\
929 930 931 932
	for (_channel = (_efx)->channel[0];				\
	     _channel;							\
	     _channel = (_channel->channel + 1 < (_efx)->n_channels) ?	\
		     (_efx)->channel[_channel->channel + 1] : NULL)
933

934 935 936 937 938 939 940
static inline struct efx_tx_queue *
efx_get_tx_queue(struct efx_nic *efx, unsigned index, unsigned type)
{
	EFX_BUG_ON_PARANOID(index >= efx->n_tx_channels ||
			    type >= EFX_TXQ_TYPES);
	return &efx->channel[efx->tx_channel_offset + index]->tx_queue[type];
}
941

942 943 944 945 946 947
static inline bool efx_channel_has_tx_queues(struct efx_channel *channel)
{
	return channel->channel - channel->efx->tx_channel_offset <
		channel->efx->n_tx_channels;
}

948 949 950
static inline struct efx_tx_queue *
efx_channel_get_tx_queue(struct efx_channel *channel, unsigned type)
{
951 952 953
	EFX_BUG_ON_PARANOID(!efx_channel_has_tx_queues(channel) ||
			    type >= EFX_TXQ_TYPES);
	return &channel->tx_queue[type];
954
}
955

956 957 958 959 960 961
static inline bool efx_tx_queue_used(struct efx_tx_queue *tx_queue)
{
	return !(tx_queue->efx->net_dev->num_tc < 2 &&
		 tx_queue->queue & EFX_TXQ_TYPE_HIGHPRI);
}

962 963
/* Iterate over all TX queues belonging to a channel */
#define efx_for_each_channel_tx_queue(_tx_queue, _channel)		\
964 965 966 967
	if (!efx_channel_has_tx_queues(_channel))			\
		;							\
	else								\
		for (_tx_queue = (_channel)->tx_queue;			\
968 969
		     _tx_queue < (_channel)->tx_queue + EFX_TXQ_TYPES && \
			     efx_tx_queue_used(_tx_queue);		\
970
		     _tx_queue++)
971

972 973 974 975 976 977
/* Iterate over all possible TX queues belonging to a channel */
#define efx_for_each_possible_channel_tx_queue(_tx_queue, _channel)	\
	for (_tx_queue = (_channel)->tx_queue;				\
	     _tx_queue < (_channel)->tx_queue + EFX_TXQ_TYPES;		\
	     _tx_queue++)

978 979 980 981
static inline struct efx_rx_queue *
efx_get_rx_queue(struct efx_nic *efx, unsigned index)
{
	EFX_BUG_ON_PARANOID(index >= efx->n_rx_channels);
982
	return &efx->channel[index]->rx_queue;
983 984
}

985 986 987 988 989
static inline bool efx_channel_has_rx_queue(struct efx_channel *channel)
{
	return channel->channel < channel->efx->n_rx_channels;
}

990 991 992
static inline struct efx_rx_queue *
efx_channel_get_rx_queue(struct efx_channel *channel)
{
993 994
	EFX_BUG_ON_PARANOID(!efx_channel_has_rx_queue(channel));
	return &channel->rx_queue;
995 996
}

997 998
/* Iterate over all RX queues belonging to a channel */
#define efx_for_each_channel_rx_queue(_rx_queue, _channel)		\
999 1000 1001 1002 1003 1004
	if (!efx_channel_has_rx_queue(_channel))			\
		;							\
	else								\
		for (_rx_queue = &(_channel)->rx_queue;			\
		     _rx_queue;						\
		     _rx_queue = NULL)
1005

1006 1007 1008
static inline struct efx_channel *
efx_rx_queue_channel(struct efx_rx_queue *rx_queue)
{
1009
	return container_of(rx_queue, struct efx_channel, rx_queue);
1010 1011 1012 1013
}

static inline int efx_rx_queue_index(struct efx_rx_queue *rx_queue)
{
1014
	return efx_rx_queue_channel(rx_queue)->channel;
1015 1016
}

1017 1018 1019 1020 1021 1022
/* Returns a pointer to the specified receive buffer in the RX
 * descriptor queue.
 */
static inline struct efx_rx_buffer *efx_rx_buffer(struct efx_rx_queue *rx_queue,
						  unsigned int index)
{
1023
	return &rx_queue->buffer[index];
1024 1025 1026
}

/* Set bit in a little-endian bitfield */
1027
static inline void set_bit_le(unsigned nr, unsigned char *addr)
1028 1029 1030 1031 1032
{
	addr[nr / 8] |= (1 << (nr % 8));
}

/* Clear bit in a little-endian bitfield */
1033
static inline void clear_bit_le(unsigned nr, unsigned char *addr)
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
{
	addr[nr / 8] &= ~(1 << (nr % 8));
}


/**
 * EFX_MAX_FRAME_LEN - calculate maximum frame length
 *
 * This calculates the maximum frame length that will be used for a
 * given MTU.  The frame length will be equal to the MTU plus a
 * constant amount of header space and padding.  This is the quantity
 * that the net driver will program into the MAC as the maximum frame
 * length.
 *
1048
 * The 10G MAC requires 8-byte alignment on the frame
1049
 * length, so we round up to the nearest 8.
1050 1051 1052 1053 1054
 *
 * Re-clocking by the XGXS on RX can reduce an IPG to 32 bits (half an
 * XGMII cycle).  If the frame length reaches the maximum value in the
 * same cycle, the XMAC can miss the IPG altogether.  We work around
 * this by adding a further 16 bytes.
1055 1056
 */
#define EFX_MAX_FRAME_LEN(mtu) \
1057
	((((mtu) + ETH_HLEN + VLAN_HLEN + 4/* FCS */ + 7) & ~7) + 16)
1058 1059 1060


#endif /* EFX_NET_DRIVER_H */