net_driver.h 32.7 KB
Newer Older
1
2
3
/****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
4
 * Copyright 2005-2009 Solarflare Communications Inc.
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 *
 * 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

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

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

/**************************************************************************
 *
 * Build definitions
 *
 **************************************************************************/
#ifndef EFX_DRIVER_NAME
#define EFX_DRIVER_NAME	"sfc"
#endif
41
#define EFX_DRIVER_VERSION	"3.0"
42
43
44
45
46
47
48
49
50
51
52

#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

/* Un-rate-limited logging */
#define EFX_ERR(efx, fmt, args...) \
53
dev_err(&((efx)->pci_dev->dev), "ERR: %s " fmt, efx_dev_name(efx), ##args)
54
55

#define EFX_INFO(efx, fmt, args...) \
56
dev_info(&((efx)->pci_dev->dev), "INFO: %s " fmt, efx_dev_name(efx), ##args)
57
58
59

#ifdef EFX_ENABLE_DEBUG
#define EFX_LOG(efx, fmt, args...) \
60
dev_info(&((efx)->pci_dev->dev), "DBG: %s " fmt, efx_dev_name(efx), ##args)
61
62
#else
#define EFX_LOG(efx, fmt, args...) \
63
dev_dbg(&((efx)->pci_dev->dev), "DBG: %s " fmt, efx_dev_name(efx), ##args)
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#endif

#define EFX_TRACE(efx, fmt, args...) do {} while (0)

#define EFX_REGDUMP(efx, fmt, args...) do {} while (0)

/* Rate-limited logging */
#define EFX_ERR_RL(efx, fmt, args...) \
do {if (net_ratelimit()) EFX_ERR(efx, fmt, ##args); } while (0)

#define EFX_INFO_RL(efx, fmt, args...) \
do {if (net_ratelimit()) EFX_INFO(efx, fmt, ##args); } while (0)

#define EFX_LOG_RL(efx, fmt, args...) \
do {if (net_ratelimit()) EFX_LOG(efx, fmt, ##args); } while (0)

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

#define EFX_MAX_CHANNELS 32
#define EFX_MAX_RX_QUEUES EFX_MAX_CHANNELS

Ben Hutchings's avatar
Ben Hutchings committed
89
90
91
92
93
94
95
/* Checksum generation is a per-queue option in hardware, so each
 * queue visible to the networking core is backed by two hardware TX
 * queues. */
#define EFX_MAX_CORE_TX_QUEUES	EFX_MAX_CHANNELS
#define EFX_TXQ_TYPE_OFFLOAD	1
#define EFX_TXQ_TYPES		2
#define EFX_MAX_TX_QUEUES	(EFX_TXQ_TYPES * EFX_MAX_CORE_TX_QUEUES)
96

97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
/**
 * 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;
};

117
118
119
120
121
122
123
enum efx_flush_state {
	FLUSH_NONE,
	FLUSH_PENDING,
	FLUSH_FAILED,
	FLUSH_DONE,
};

124
125
126
127
128
129
/**
 * 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.
Ben Hutchings's avatar
Ben Hutchings committed
130
131
 * @tsoh: The associated TSO header structure, or %NULL if this
 *	buffer is not a TSO header.
132
133
134
135
136
137
138
139
140
 * @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;
Ben Hutchings's avatar
Ben Hutchings committed
141
	struct efx_tso_header *tsoh;
142
143
	dma_addr_t dma_addr;
	unsigned short len;
144
145
	bool continuation;
	bool unmap_single;
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
	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
 * @buffer: The software buffer ring
 * @txd: The hardware descriptor ring
167
 * @flushed: Used when handling queue flushing
168
169
 * @read_count: Current read pointer.
 *	This is the number of buffers that have been removed from both rings.
170
 * @stopped: Stopped count.
171
172
173
174
175
176
177
178
179
180
181
182
183
 *	Set if this TX queue is currently stopping its port.
 * @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.
Ben Hutchings's avatar
Ben Hutchings committed
184
185
186
187
188
189
190
 * @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
191
192
193
194
 */
struct efx_tx_queue {
	/* Members which don't change on the fast path */
	struct efx_nic *efx ____cacheline_aligned_in_smp;
Ben Hutchings's avatar
Ben Hutchings committed
195
	unsigned queue;
196
197
198
199
	struct efx_channel *channel;
	struct efx_nic *nic;
	struct efx_tx_buffer *buffer;
	struct efx_special_buffer txd;
200
	enum efx_flush_state flushed;
201
202
203
204
205
206
207
208
209

	/* Members used mainly on the completion path */
	unsigned int read_count ____cacheline_aligned_in_smp;
	int stopped;

	/* Members used only on the xmit path */
	unsigned int insert_count ____cacheline_aligned_in_smp;
	unsigned int write_count;
	unsigned int old_read_count;
Ben Hutchings's avatar
Ben Hutchings committed
210
211
212
213
	struct efx_tso_header *tso_headers_free;
	unsigned int tso_bursts;
	unsigned int tso_long_headers;
	unsigned int tso_packets;
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
};

/**
 * 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.
 * @data: Pointer to ethernet header
 * @len: Buffer length, in bytes.
 */
struct efx_rx_buffer {
	dma_addr_t dma_addr;
	struct sk_buff *skb;
	struct page *page;
	char *data;
	unsigned int len;
};

234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
/**
 * 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;
};

252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
/**
 * struct efx_rx_queue - An Efx RX queue
 * @efx: The associated Efx NIC
 * @queue: DMA queue number
 * @channel: The associated channel
 * @buffer: The software buffer ring
 * @rxd: The hardware descriptor ring
 * @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.
 * @min_overfill: RX descriptor minimum overflow fill level.
 *	This records the minimum fill level at which RX queue
 *	overflow was observed.  It should never be set.
 * @alloc_page_count: RX allocation strategy counter.
 * @alloc_skb_count: RX allocation strategy counter.
275
 * @slow_fill: Timer used to defer efx_nic_generate_fill_event().
276
 * @flushed: Use when handling queue flushing
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
 */
struct efx_rx_queue {
	struct efx_nic *efx;
	int queue;
	struct efx_channel *channel;
	struct efx_rx_buffer *buffer;
	struct efx_special_buffer rxd;

	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;
295
	struct timer_list slow_fill;
296
297
	unsigned int slow_fill_count;

298
	enum efx_flush_state flushed;
299
300
301
302
303
304
305
306
};

/**
 * 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
 *
307
 * The NIC uses these buffers for its interrupt status registers and
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
 * 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
332
 * @name: Name for channel and IRQ
333
334
 * @enabled: Channel enabled indicator
 * @irq: IRQ number (MSI and MSI-X only)
335
 * @irq_moderation: IRQ moderation value (in hardware ticks)
336
337
338
339
340
341
342
 * @napi_dev: Net device used with NAPI
 * @napi_str: NAPI control structure
 * @reset_work: Scheduled reset work thread
 * @work_pending: Is work pending via NAPI?
 * @eventq: Event queue buffer
 * @eventq_read_ptr: Event queue read pointer
 * @last_eventq_read_ptr: Last event queue read pointer value.
343
 * @magic_count: Event queue test event count
344
345
 * @irq_count: Number of IRQs since last adaptive moderation decision
 * @irq_mod_score: IRQ moderation score
346
347
348
349
350
351
352
 * @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
353
 * @n_rx_mcast_mismatch: Count of unmatched multicast frames
354
355
356
 * @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
Ben Hutchings's avatar
Ben Hutchings committed
357
358
359
 * @tx_queue: Pointer to first TX queue, or %NULL if not used for TX
 * @tx_stop_count: Core TX queue stop count
 * @tx_stop_lock: Core TX queue stop lock
360
361
362
363
 */
struct efx_channel {
	struct efx_nic *efx;
	int channel;
364
	char name[IFNAMSIZ + 6];
365
	bool enabled;
366
367
368
369
	int irq;
	unsigned int irq_moderation;
	struct net_device *napi_dev;
	struct napi_struct napi_str;
370
	bool work_pending;
371
372
373
	struct efx_special_buffer eventq;
	unsigned int eventq_read_ptr;
	unsigned int last_eventq_read_ptr;
374
	unsigned int magic_count;
375

376
377
378
	unsigned int irq_count;
	unsigned int irq_mod_score;

379
380
381
382
383
384
	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;
385
	unsigned n_rx_mcast_mismatch;
386
387
388
389
390
391
392
393
	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;
394
	bool rx_pkt_csummed;
395

Ben Hutchings's avatar
Ben Hutchings committed
396
397
398
	struct efx_tx_queue *tx_queue;
	atomic_t tx_stop_count;
	spinlock_t tx_stop_lock;
399
400
};

401
402
403
404
405
406
enum efx_led_mode {
	EFX_LED_OFF	= 0,
	EFX_LED_ON	= 1,
	EFX_LED_DEFAULT	= 2
};

407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
#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_interrupt_mode_names[];
extern const unsigned int efx_interrupt_mode_max;
#define INT_MODE(efx) \
	STRING_TABLE_LOOKUP(efx->interrupt_mode, efx_interrupt_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)
424

425
426
427
428
429
430
431
432
433
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)

434
#define EFX_IS10G(efx) ((efx)->link_state.speed == 10000)
435

436
437
438
439
enum nic_state {
	STATE_INIT = 0,
	STATE_RUNNING = 1,
	STATE_FINI = 2,
440
	STATE_DISABLED = 3,
441
442
443
444
445
446
447
448
449
450
	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].
 */
451
#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
#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 */
enum efx_fc_type {
471
472
	EFX_FC_RX = FLOW_CTRL_RX,
	EFX_FC_TX = FLOW_CTRL_TX,
473
474
475
	EFX_FC_AUTO = 4,
};

476
477
478
479
480
481
482
483
484
485
486
487
488
489
/**
 * 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;
	enum efx_fc_type fc;
	unsigned int speed;
};

Steve Hodgson's avatar
Steve Hodgson committed
490
491
492
493
494
495
496
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;
}

497
498
499
500
/**
 * struct efx_mac_operations - Efx MAC operations table
 * @reconfigure: Reconfigure MAC. Serialised by the mac_lock
 * @update_stats: Update statistics
501
 * @check_fault: Check fault state. True if fault present.
502
503
 */
struct efx_mac_operations {
504
	int (*reconfigure) (struct efx_nic *efx);
505
	void (*update_stats) (struct efx_nic *efx);
506
	bool (*check_fault)(struct efx_nic *efx);
507
508
};

509
510
/**
 * struct efx_phy_operations - Efx PHY operations table
511
512
 * @probe: Probe PHY and initialise efx->mdio.mode_support, efx->mdio.mmds,
 *	efx->loopback_modes.
513
514
515
 * @init: Initialise PHY
 * @fini: Shut down PHY
 * @reconfigure: Reconfigure PHY (e.g. for new link parameters)
Steve Hodgson's avatar
Steve Hodgson committed
516
517
 * @poll: Update @link_state and report whether it changed.
 *	Serialised by the mac_lock.
518
519
 * @get_settings: Get ethtool settings. Serialised by the mac_lock.
 * @set_settings: Set ethtool settings. Serialised by the mac_lock.
520
 * @set_npage_adv: Set abilities advertised in (Extended) Next Page
521
 *	(only needed where AN bit is set in mmds)
522
 * @test_alive: Test that PHY is 'alive' (online)
523
 * @test_name: Get the name of a PHY-specific test/result
524
 * @run_tests: Run tests and record results as appropriate (offline).
525
 *	Flags are the ethtool tests flags.
526
527
 */
struct efx_phy_operations {
528
	int (*probe) (struct efx_nic *efx);
529
530
	int (*init) (struct efx_nic *efx);
	void (*fini) (struct efx_nic *efx);
531
	void (*remove) (struct efx_nic *efx);
532
	int (*reconfigure) (struct efx_nic *efx);
Steve Hodgson's avatar
Steve Hodgson committed
533
	bool (*poll) (struct efx_nic *efx);
534
535
536
537
	void (*get_settings) (struct efx_nic *efx,
			      struct ethtool_cmd *ecmd);
	int (*set_settings) (struct efx_nic *efx,
			     struct ethtool_cmd *ecmd);
538
	void (*set_npage_adv) (struct efx_nic *efx, u32);
539
	int (*test_alive) (struct efx_nic *efx);
540
	const char *(*test_name) (struct efx_nic *efx, unsigned int index);
541
	int (*run_tests) (struct efx_nic *efx, int *results, unsigned flags);
542
543
};

544
545
546
547
/**
 * @enum efx_phy_mode - PHY operating mode flags
 * @PHY_MODE_NORMAL: on and should pass traffic
 * @PHY_MODE_TX_DISABLED: on with TX disabled
548
549
 * @PHY_MODE_LOW_POWER: set to low power through MDIO
 * @PHY_MODE_OFF: switched off through external control
550
551
552
553
554
 * @PHY_MODE_SPECIAL: on but will not pass traffic
 */
enum efx_phy_mode {
	PHY_MODE_NORMAL		= 0,
	PHY_MODE_TX_DISABLED	= 1,
555
556
	PHY_MODE_LOW_POWER	= 2,
	PHY_MODE_OFF		= 4,
557
558
559
560
561
	PHY_MODE_SPECIAL	= 8,
};

static inline bool efx_phy_mode_disabled(enum efx_phy_mode mode)
{
Ben Hutchings's avatar
Ben Hutchings committed
562
	return !!(mode & ~PHY_MODE_TX_DISABLED);
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
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
/*
 * 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];
};

/**
 * struct efx_nic - an Efx NIC
 * @name: Device name (net device name or bus id before net device registered)
 * @pci_dev: The PCI device
652
 * @port_num: Index of this host port within the controller
653
654
 * @type: Controller type attributes
 * @legacy_irq: IRQ number
655
656
 * @workqueue: Workqueue for port reconfigures and the HW monitor.
 *	Work items do not hold and must not acquire RTNL.
657
 * @workqueue_name: Name of workqueue
658
659
660
661
662
663
 * @reset_work: Scheduled reset workitem
 * @monitor_work: Hardware monitor workitem
 * @membase_phys: Memory BAR value as physical address
 * @membase: Memory BAR value
 * @biu_lock: BIU (bus interface unit) lock
 * @interrupt_mode: Interrupt mode
664
665
 * @irq_rx_adaptive: Adaptive IRQ moderation enabled for RX event queues
 * @irq_rx_moderation: IRQ moderation time for RX event queues
666
667
668
669
670
 * @state: Device state flag. Serialised by the rtnl_lock.
 * @reset_pending: Pending reset method (normally RESET_TYPE_NONE)
 * @tx_queue: TX DMA queues
 * @rx_queue: RX DMA queues
 * @channel: Channels
671
 * @next_buffer_table: First available buffer table id
672
 * @n_channels: Number of channels in use
Ben Hutchings's avatar
Ben Hutchings committed
673
674
 * @n_rx_channels: Number of channels used for RX (= number of RX queues)
 * @n_tx_channels: Number of channels used for TX
675
676
 * @rx_buffer_len: RX buffer length
 * @rx_buffer_order: Order (log2) of number of pages for each RX buffer
677
678
 * @int_error_count: Number of internal errors seen recently
 * @int_error_expire: Time at which error count will be expired
679
680
681
 * @irq_status: Interrupt status buffer
 * @last_irq_cpu: Last CPU to handle interrupt.
 *	This register is written with the SMP processor ID whenever an
682
 *	interrupt is handled.  It is used by efx_nic_test_interrupt()
683
 *	to verify that an interrupt has occurred.
684
 * @irq_zero_count: Number of legacy IRQs seen with queue flags == 0
685
 * @fatal_irq_level: IRQ level (bit number) used for serious errors
686
 * @spi_flash: SPI flash device
687
 *	This field will be %NULL if no flash device is present (or for Siena).
688
 * @spi_eeprom: SPI EEPROM device
689
 *	This field will be %NULL if no EEPROM device is present (or for Siena).
690
 * @spi_lock: SPI bus lock
691
 * @mtd_list: List of MTDs attached to the NIC
692
693
 * @n_rx_nodesc_drop_cnt: RX no descriptor drop count
 * @nic_data: Hardware dependant state
Ben Hutchings's avatar
Ben Hutchings committed
694
695
 * @mac_lock: MAC access lock. Protects @port_enabled, @phy_mode,
 *	@port_inhibited, efx_monitor() and efx_reconfigure_port()
696
 * @port_enabled: Port enabled indicator.
Steve Hodgson's avatar
Steve Hodgson committed
697
698
699
700
 *	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.
Ben Hutchings's avatar
Ben Hutchings committed
701
 * @port_inhibited: If set, the netif_carrier is always off. Hold the mac_lock
702
703
704
705
706
707
708
 * @port_initialized: Port initialized?
 * @net_dev: Operating system network device. Consider holding the rtnl lock
 * @rx_checksum_enabled: RX checksumming enabled
 * @mac_stats: MAC statistics. These include all statistics the MACs
 *	can provide.  Generic code converts these into a standard
 *	&struct net_device_stats.
 * @stats_buffer: DMA buffer for statistics
Ben Hutchings's avatar
Ben Hutchings committed
709
 * @stats_lock: Statistics update lock. Serialises statistics fetches
710
 * @mac_op: MAC interface
711
712
 * @mac_address: Permanent MAC address
 * @phy_type: PHY type
713
 * @mdio_lock: MDIO lock
714
715
 * @phy_op: PHY interface
 * @phy_data: PHY private data (including PHY-specific stats)
716
 * @mdio: PHY MDIO interface
717
 * @mdio_bus: PHY MDIO bus ID (only used by Siena)
Ben Hutchings's avatar
Ben Hutchings committed
718
 * @phy_mode: PHY operating mode. Serialised by @mac_lock.
719
 * @xmac_poll_required: XMAC link state needs polling
720
 * @link_advertising: Autonegotiation advertising flags
721
 * @link_state: Current state of the link
722
723
724
 * @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
725
 * @wanted_fc: Wanted flow control flags
726
 * @mac_work: Work item for changing MAC promiscuity and multicast hash
727
728
729
 * @loopback_mode: Loopback status
 * @loopback_modes: Supported loopback mode bitmask
 * @loopback_selftest: Offline self-test private state
730
 *
731
 * This is stored in the private area of the &struct net_device.
732
733
734
735
 */
struct efx_nic {
	char name[IFNAMSIZ];
	struct pci_dev *pci_dev;
736
	unsigned port_num;
737
738
739
	const struct efx_nic_type *type;
	int legacy_irq;
	struct workqueue_struct *workqueue;
740
	char workqueue_name[16];
741
742
	struct work_struct reset_work;
	struct delayed_work monitor_work;
743
	resource_size_t membase_phys;
744
745
746
	void __iomem *membase;
	spinlock_t biu_lock;
	enum efx_int_mode interrupt_mode;
747
748
	bool irq_rx_adaptive;
	unsigned int irq_rx_moderation;
749
750
751
752

	enum nic_state state;
	enum reset_type reset_pending;

Ben Hutchings's avatar
Ben Hutchings committed
753
	struct efx_tx_queue tx_queue[EFX_MAX_TX_QUEUES];
754
755
756
	struct efx_rx_queue rx_queue[EFX_MAX_RX_QUEUES];
	struct efx_channel channel[EFX_MAX_CHANNELS];

757
	unsigned next_buffer_table;
Ben Hutchings's avatar
Ben Hutchings committed
758
759
760
	unsigned n_channels;
	unsigned n_rx_channels;
	unsigned n_tx_channels;
761
762
763
	unsigned int rx_buffer_len;
	unsigned int rx_buffer_order;

764
765
766
	unsigned int_error_count;
	unsigned long int_error_expire;

767
768
	struct efx_buffer irq_status;
	volatile signed int last_irq_cpu;
769
	unsigned irq_zero_count;
770
	unsigned fatal_irq_level;
771

772
773
	struct efx_spi_device *spi_flash;
	struct efx_spi_device *spi_eeprom;
774
	struct mutex spi_lock;
775
776
777
#ifdef CONFIG_SFC_MTD
	struct list_head mtd_list;
#endif
778

779
780
	unsigned n_rx_nodesc_drop_cnt;

781
	void *nic_data;
782
783

	struct mutex mac_lock;
784
	struct work_struct mac_work;
785
	bool port_enabled;
Ben Hutchings's avatar
Ben Hutchings committed
786
	bool port_inhibited;
787

788
	bool port_initialized;
789
	struct net_device *net_dev;
790
	bool rx_checksum_enabled;
791
792
793
794
795

	struct efx_mac_stats mac_stats;
	struct efx_buffer stats_buffer;
	spinlock_t stats_lock;

796
	struct efx_mac_operations *mac_op;
797
798
	unsigned char mac_address[ETH_ALEN];

799
	unsigned int phy_type;
800
	struct mutex mdio_lock;
801
802
	struct efx_phy_operations *phy_op;
	void *phy_data;
803
	struct mdio_if_info mdio;
804
	unsigned int mdio_bus;
805
	enum efx_phy_mode phy_mode;
806

807
	bool xmac_poll_required;
808
	u32 link_advertising;
809
	struct efx_link_state link_state;
810
811
	unsigned int n_link_state_changes;

812
	bool promiscuous;
813
	union efx_multicast_hash multicast_hash;
814
	enum efx_fc_type wanted_fc;
815
816

	atomic_t rx_reset;
817
	enum efx_loopback_mode loopback_mode;
818
	u64 loopback_modes;
819
820

	void *loopback_selftest;
821
822
};

823
824
825
826
827
828
829
830
831
832
833
834
835
836
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 : "";
}

837
838
static inline unsigned int efx_port_num(struct efx_nic *efx)
{
839
	return efx->port_num;
840
841
}

842
843
/**
 * struct efx_nic_type - Efx device type definition
844
845
846
847
848
849
850
851
852
853
854
855
856
 * @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
 * @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()
 * @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
857
 * @set_id_led: Set state of identifying LED or revert to automatic function
858
859
 * @push_irq_moderation: Apply interrupt moderation value
 * @push_multicast_hash: Apply multicast hash table
860
 * @reconfigure_port: Push loopback/power/txdis changes to the MAC and PHY
861
862
863
 * @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)
864
 * @test_registers: Test read/write functionality of control registers
865
 * @test_nvram: Test validity of NVRAM contents
866
 * @default_mac_ops: efx_mac_operations to set at startup
867
 * @revision: Hardware architecture revision
868
869
870
871
872
873
874
875
876
877
878
879
 * @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
 * @rx_buffer_padding: Padding added to each RX buffer
 * @max_interrupt_mode: Highest capability interrupt mode supported
 *	from &enum efx_init_mode.
 * @phys_addr_channels: Number of channels with physically addressed
 *	descriptors
880
881
 * @tx_dc_base: Base address in SRAM of TX queue descriptor caches
 * @rx_dc_base: Base address in SRAM of RX queue descriptor caches
882
883
 * @offload_features: net_device feature flags for protocol offload
 *	features implemented in hardware
884
885
 * @reset_world_flags: Flags for additional components covered by
 *	reset method RESET_TYPE_WORLD
886
887
 */
struct efx_nic_type {
888
889
890
891
892
893
894
895
896
897
898
899
	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);
	int (*reset)(struct efx_nic *efx, enum reset_type method);
	int (*probe_port)(struct efx_nic *efx);
	void (*remove_port)(struct efx_nic *efx);
	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);
900
	void (*set_id_led)(struct efx_nic *efx, enum efx_led_mode mode);
901
902
	void (*push_irq_moderation)(struct efx_channel *channel);
	void (*push_multicast_hash)(struct efx_nic *efx);
903
	int (*reconfigure_port)(struct efx_nic *efx);
904
905
906
	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);
907
	int (*test_registers)(struct efx_nic *efx);
908
	int (*test_nvram)(struct efx_nic *efx);
909
910
	struct efx_mac_operations *default_mac_ops;

911
	int revision;
912
913
914
915
916
917
	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;
918
	u64 max_dma_mask;
919
920
921
	unsigned int rx_buffer_padding;
	unsigned int max_interrupt_mode;
	unsigned int phys_addr_channels;
922
923
	unsigned int tx_dc_base;
	unsigned int rx_dc_base;
924
	unsigned long offload_features;
925
	u32 reset_world_flags;
926
927
928
929
930
931
932
933
934
935
};

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

/* Iterate over all used channels */
#define efx_for_each_channel(_channel, _efx)				\
936
	for (_channel = &((_efx)->channel[0]);				\
Ben Hutchings's avatar
Ben Hutchings committed
937
938
	     _channel < &((_efx)->channel[(efx)->n_channels]);		\
	     _channel++)
939
940
941

/* Iterate over all used TX queues */
#define efx_for_each_tx_queue(_tx_queue, _efx)				\
942
	for (_tx_queue = &((_efx)->tx_queue[0]);			\
Ben Hutchings's avatar
Ben Hutchings committed
943
944
	     _tx_queue < &((_efx)->tx_queue[EFX_TXQ_TYPES *		\
					    (_efx)->n_tx_channels]);	\
945
	     _tx_queue++)
946
947
948

/* Iterate over all TX queues belonging to a channel */
#define efx_for_each_channel_tx_queue(_tx_queue, _channel)		\
Ben Hutchings's avatar
Ben Hutchings committed
949
950
951
	for (_tx_queue = (_channel)->tx_queue;				\
	     _tx_queue && _tx_queue < (_channel)->tx_queue + EFX_TXQ_TYPES; \
	     _tx_queue++)
952
953
954

/* Iterate over all used RX queues */
#define efx_for_each_rx_queue(_rx_queue, _efx)				\
955
	for (_rx_queue = &((_efx)->rx_queue[0]);			\
Ben Hutchings's avatar
Ben Hutchings committed
956
	     _rx_queue < &((_efx)->rx_queue[(_efx)->n_rx_channels]);	\
957
	     _rx_queue++)
958
959
960

/* Iterate over all RX queues belonging to a channel */
#define efx_for_each_channel_rx_queue(_rx_queue, _channel)		\
961
	for (_rx_queue = &((_channel)->efx->rx_queue[(_channel)->channel]); \
962
963
	     _rx_queue;							\
	     _rx_queue = NULL)						\
964
		if (_rx_queue->channel != (_channel))			\
965
966
967
968
969
970
971
972
973
974
975
976
977
			continue;					\
		else

/* 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)
{
	return (&rx_queue->buffer[index]);
}

/* Set bit in a little-endian bitfield */
978
static inline void set_bit_le(unsigned nr, unsigned char *addr)
979
980
981
982
983
{
	addr[nr / 8] |= (1 << (nr % 8));
}

/* Clear bit in a little-endian bitfield */
984
static inline void clear_bit_le(unsigned nr, unsigned char *addr)
985
986
987
988
989
990
991
992
993
994
995
996
997
998
{
	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.
 *
999
 * The 10G MAC requires 8-byte alignment on the frame
1000
 * length, so we round up to the nearest 8.
1001
1002
1003
1004
1005
 *
 * 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.
1006
1007
 */
#define EFX_MAX_FRAME_LEN(mtu) \
1008
	((((mtu) + ETH_HLEN + VLAN_HLEN + 4/* FCS */ + 7) & ~7) + 16)
1009
1010
1011


#endif /* EFX_NET_DRIVER_H */