1 /* $OpenBSD: if_aq_pci.c,v 1.28 2024/05/24 06:02:53 jsg Exp $ */
2 /* $NetBSD: if_aq.c,v 1.27 2021/06/16 00:21:18 riastradh Exp $ */
3
4 /*
5 * Copyright (c) 2021 Jonathan Matthew <jonathan@d14n.org>
6 * Copyright (c) 2021 Mike Larkin <mlarkin@openbsd.org>
7 *
8 * Permission to use, copy, modify, and distribute this software for any
9 * purpose with or without fee is hereby granted, provided that the above
10 * copyright notice and this permission notice appear in all copies.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 */
20
21 /**
22 * aQuantia Corporation Network Driver
23 * Copyright (C) 2014-2017 aQuantia Corporation. All rights reserved
24 *
25 * Redistribution and use in source and binary forms, with or without
26 * modification, are permitted provided that the following conditions
27 * are met:
28 *
29 * (1) Redistributions of source code must retain the above
30 * copyright notice, this list of conditions and the following
31 * disclaimer.
32 *
33 * (2) Redistributions in binary form must reproduce the above
34 * copyright notice, this list of conditions and the following
35 * disclaimer in the documentation and/or other materials provided
36 * with the distribution.
37 *
38 * (3) The name of the author may not be used to endorse or promote
39 * products derived from this software without specific prior
40 * written permission.
41 *
42 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
43 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
44 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
46 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
48 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
49 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
50 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
51 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
52 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
53 *
54 */
55
56 /*-
57 * Copyright (c) 2020 Ryo Shimizu <ryo@nerv.org>
58 * All rights reserved.
59 *
60 * Redistribution and use in source and binary forms, with or without
61 * modification, are permitted provided that the following conditions
62 * are met:
63 * 1. Redistributions of source code must retain the above copyright
64 * notice, this list of conditions and the following disclaimer.
65 * 2. Redistributions in binary form must reproduce the above copyright
66 * notice, this list of conditions and the following disclaimer in the
67 * documentation and/or other materials provided with the distribution.
68 *
69 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
70 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
71 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
72 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
73 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
74 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
75 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
76 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
77 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
78 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
79 * POSSIBILITY OF SUCH DAMAGE.
80 */
81 #include "bpfilter.h"
82 #include "vlan.h"
83
84 #include <sys/types.h>
85 #include <sys/device.h>
86 #include <sys/param.h>
87 #include <sys/sockio.h>
88 #include <sys/systm.h>
89 #include <sys/intrmap.h>
90
91 #include <net/if.h>
92 #include <net/if_media.h>
93 #include <net/toeplitz.h>
94
95 #include <netinet/in.h>
96 #include <netinet/if_ether.h>
97
98 #ifdef __HAVE_FDT
99 #include <dev/ofw/openfirm.h>
100 #endif
101
102 #include <dev/pci/pcireg.h>
103 #include <dev/pci/pcivar.h>
104 #include <dev/pci/pcidevs.h>
105
106 #if NBPFILTER > 0
107 #include <net/bpf.h>
108 #endif
109
110 /* #define AQ_DEBUG 1 */
111 #ifdef AQ_DEBUG
112 #define DPRINTF(x) printf x
113 #else
114 #define DPRINTF(x)
115 #endif /* AQ_DEBUG */
116
117 #define DEVNAME(_s) ((_s)->sc_dev.dv_xname)
118
119 #define AQ_BAR0 0x10
120 #define AQ_MAXQ 8
121 #define AQ_RSS_KEYSIZE 40
122 #define AQ_RSS_REDIR_ENTRIES 12
123
124 #define AQ_TXD_NUM 2048
125 #define AQ_RXD_NUM 2048
126
127 #define AQ_TX_MAX_SEGMENTS 32
128
129 #define AQ_LINKSTAT_IRQ 31
130
131 #define RPF_ACTION_HOST 1
132
133 #define AQ_FW_SOFTRESET_REG 0x0000
134 #define AQ_FW_SOFTRESET_DIS (1 << 14)
135 #define AQ_FW_SOFTRESET_RESET (1 << 15)
136 #define AQ_FW_VERSION_REG 0x0018
137 #define AQ_HW_REVISION_REG 0x001c
138 #define AQ2_HW_FPGA_VERSION_REG 0x00f4
139 #define AQ_GLB_NVR_INTERFACE1_REG 0x0100
140 #define AQ_FW_MBOX_CMD_REG 0x0200
141 #define AQ_FW_MBOX_CMD_EXECUTE 0x00008000
142 #define AQ_FW_MBOX_CMD_BUSY 0x00000100
143 #define AQ_FW_MBOX_ADDR_REG 0x0208
144 #define AQ_FW_MBOX_VAL_REG 0x020C
145 #define AQ_FW_GLB_CPU_SEM_REG(i) (0x03a0 + (i) * 4)
146 #define AQ_FW_SEM_RAM_REG AQ_FW_GLB_CPU_SEM_REG(2)
147 #define AQ2_ART_SEM_REG AQ_FW_GLB_CPU_SEM_REG(3)
148 #define AQ_FW_GLB_CTL2_REG 0x0404
149 #define AQ_GLB_GENERAL_PROVISIONING9_REG 0x0520
150 #define AQ_GLB_NVR_PROVISIONING2_REG 0x0534
151 #define AQ_INTR_STATUS_REG 0x2000 /* intr status */
152 #define AQ_INTR_STATUS_CLR_REG 0x2050 /* intr status clear */
153 #define AQ_INTR_MASK_REG 0x2060 /* intr mask set */
154 #define AQ_INTR_MASK_CLR_REG 0x2070 /* intr mask clear */
155 #define AQ_INTR_AUTOMASK_REG 0x2090
156
157 /* AQ_INTR_IRQ_MAP_TXRX_REG 0x2100-0x2140 */
158 #define AQ_INTR_IRQ_MAP_TXRX_REG(i) (0x2100 + ((i) / 2) * 4)
159 #define AQ_INTR_IRQ_MAP_TX_REG(i) AQ_INTR_IRQ_MAP_TXRX_REG(i)
160 #define AQ_INTR_IRQ_MAP_TX_IRQMAP(i) (0x1FU << (((i) & 1) ? 16 : 24))
161 #define AQ_INTR_IRQ_MAP_TX_EN(i) (1U << (((i) & 1) ? 23 : 31))
162 #define AQ_INTR_IRQ_MAP_RX_REG(i) AQ_INTR_IRQ_MAP_TXRX_REG(i)
163 #define AQ_INTR_IRQ_MAP_RX_IRQMAP(i) (0x1FU << (((i) & 1) ? 0 : 8))
164 #define AQ_INTR_IRQ_MAP_RX_EN(i) (1U << (((i) & 1) ? 7 : 15))
165
166 /* AQ_GEN_INTR_MAP_REG[AQ_RINGS_NUM] 0x2180-0x2200 */
167 #define AQ_GEN_INTR_MAP_REG(i) (0x2180 + (i) * 4)
168 #define AQ_B0_ERR_INT 8U
169
170 #define AQ_INTR_CTRL_REG 0x2300
171 #define AQ_INTR_CTRL_IRQMODE ((1 << 0) | (1 << 1))
172 #define AQ_INTR_CTRL_IRQMODE_LEGACY 0
173 #define AQ_INTR_CTRL_IRQMODE_MSI 1
174 #define AQ_INTR_CTRL_IRQMODE_MSIX 2
175 #define AQ_INTR_CTRL_MULTIVEC (1 << 2)
176 #define AQ_INTR_CTRL_RESET_DIS (1 << 29)
177 #define AQ_INTR_CTRL_RESET_IRQ (1U << 31)
178 #define AQ_MBOXIF_POWER_GATING_CONTROL_REG 0x32a8
179
180 #define FW_MPI_MBOX_ADDR_REG 0x0360
181 #define FW1X_MPI_INIT1_REG 0x0364
182 #define FW1X_MPI_INIT2_REG 0x0370
183 #define FW1X_MPI_EFUSEADDR_REG 0x0374
184
185 #define FW2X_MPI_EFUSEADDR_REG 0x0364
186 #define FW2X_MPI_CONTROL_REG 0x0368 /* 64bit */
187 #define FW2X_MPI_STATE_REG 0x0370 /* 64bit */
188 #define FW_BOOT_EXIT_CODE_REG 0x0388
189
190 #define FW_BOOT_EXIT_CODE_REG 0x0388
191 #define RBL_STATUS_DEAD 0x0000dead
192 #define RBL_STATUS_SUCCESS 0x0000abba
193 #define RBL_STATUS_FAILURE 0x00000bad
194 #define RBL_STATUS_HOST_BOOT 0x0000f1a7
195 #define FW_MPI_DAISY_CHAIN_STATUS_REG 0x0704
196 #define AQ_PCI_REG_CONTROL_6_REG 0x1014
197
198 #define FW_MPI_RESETCTRL_REG 0x4000
199 #define FW_MPI_RESETCTRL_RESET_DIS (1 << 29)
200
201 #define RX_SYSCONTROL_REG 0x5000
202 #define RX_SYSCONTROL_RESET_DIS (1 << 29)
203
204 #define RX_TCP_RSS_HASH_REG 0x5040
205 #define RX_TCP_RSS_HASH_RPF2 (0xf << 16)
206 #define RX_TCP_RSS_HASH_TYPE (0xffff)
207
208 #define RPF_L2BC_REG 0x5100
209 #define RPF_L2BC_EN (1 << 0)
210 #define RPF_L2BC_PROMISC (1 << 3)
211 #define RPF_L2BC_ACTION 0x7000
212 #define RPF_L2BC_THRESHOLD 0xFFFF0000
213
214 #define AQ_HW_MAC_OWN 0
215
216 /* RPF_L2UC_*_REG[34] (actual [38]?) */
217 #define RPF_L2UC_LSW_REG(i) (0x5110 + (i) * 8)
218 #define RPF_L2UC_MSW_REG(i) (0x5114 + (i) * 8)
219 #define RPF_L2UC_MSW_MACADDR_HI 0xFFFF
220 #define RPF_L2UC_MSW_ACTION 0x70000
221 #define RPF_L2UC_MSW_TAG 0x03c00000
222 #define RPF_L2UC_MSW_EN (1U << 31)
223 #define AQ_HW_MAC_NUM 34
224
225 /* RPF_MCAST_FILTER_REG[8] 0x5250-0x5270 */
226 #define RPF_MCAST_FILTER_REG(i) (0x5250 + (i) * 4)
227 #define RPF_MCAST_FILTER_EN (1U << 31)
228 #define RPF_MCAST_FILTER_MASK_REG 0x5270
229 #define RPF_MCAST_FILTER_MASK_ALLMULTI (1 << 14)
230
231 #define RPF_VLAN_MODE_REG 0x5280
232 #define RPF_VLAN_MODE_PROMISC (1 << 1)
233 #define RPF_VLAN_MODE_ACCEPT_UNTAGGED (1 << 2)
234 #define RPF_VLAN_MODE_UNTAGGED_ACTION 0x38
235
236 #define RPF_VLAN_TPID_REG 0x5284
237 #define RPF_VLAN_TPID_OUTER 0xFFFF0000
238 #define RPF_VLAN_TPID_INNER 0xFFFF
239
240 /* RPF_ETHERTYPE_FILTER_REG[AQ_RINGS_NUM] 0x5300-0x5380 */
241 #define RPF_ETHERTYPE_FILTER_REG(i) (0x5300 + (i) * 4)
242 #define RPF_ETHERTYPE_FILTER_EN (1U << 31)
243
244 /* RPF_L3_FILTER_REG[8] 0x5380-0x53a0 */
245 #define RPF_L3_FILTER_REG(i) (0x5380 + (i) * 4)
246 #define RPF_L3_FILTER_L4_EN (1U << 31)
247
248 #define RX_FLR_RSS_CONTROL1_REG 0x54c0
249 #define RX_FLR_RSS_CONTROL1_EN (1U << 31)
250
251 #define RPF_RPB_RX_TC_UPT_REG 0x54c4
252 #define RPF_RPB_RX_TC_UPT_MASK(i) (0x00000007 << ((i) * 4))
253
254 #define RPF_RSS_KEY_ADDR_REG 0x54d0
255 #define RPF_RSS_KEY_ADDR 0x1f
256 #define RPF_RSS_KEY_WR_EN (1 << 5)
257 #define RPF_RSS_KEY_WR_DATA_REG 0x54d4
258 #define RPF_RSS_KEY_RD_DATA_REG 0x54d8
259
260 #define RPF_RSS_REDIR_ADDR_REG 0x54e0
261 #define RPF_RSS_REDIR_ADDR 0xf
262 #define RPF_RSS_REDIR_WR_EN (1 << 4)
263
264 #define RPF_RSS_REDIR_WR_DATA_REG 0x54e4
265
266
267 #define RPO_HWCSUM_REG 0x5580
268 #define RPO_HWCSUM_L4CSUM_EN (1 << 0)
269 #define RPO_HWCSUM_IP4CSUM_EN (1 << 1)
270
271 #define RPB_RPF_RX_REG 0x5700
272 #define RPB_RPF_RX_TC_MODE (1 << 8)
273 #define RPB_RPF_RX_FC_MODE 0x30
274 #define RPB_RPF_RX_BUF_EN (1 << 0)
275
276 /* RPB_RXB_BUFSIZE_REG[AQ_TRAFFICCLASS_NUM] 0x5710-0x5790 */
277 #define RPB_RXB_BUFSIZE_REG(i) (0x5710 + (i) * 0x10)
278 #define RPB_RXB_BUFSIZE 0x1FF
279 #define RPB_RXB_XOFF_REG(i) (0x5714 + (i) * 0x10)
280 #define RPB_RXB_XOFF_EN (1U << 31)
281 #define RPB_RXB_XOFF_THRESH_HI 0x3FFF0000
282 #define RPB_RXB_XOFF_THRESH_LO 0x3FFF
283
284 #define RX_DMA_DESC_CACHE_INIT_REG 0x5a00
285 #define RX_DMA_DESC_CACHE_INIT (1 << 0)
286
287 #define RX_DMA_INT_DESC_WRWB_EN_REG 0x5a30
288 #define RX_DMA_INT_DESC_WRWB_EN (1 << 2)
289 #define RX_DMA_INT_DESC_MODERATE_EN (1 << 3)
290
291 #define RX_INTR_MODERATION_CTL_REG(i) (0x5a40 + (i) * 4)
292 #define RX_INTR_MODERATION_CTL_EN (1 << 1)
293 #define RX_INTR_MODERATION_CTL_MIN (0xFF << 8)
294 #define RX_INTR_MODERATION_CTL_MAX (0x1FF << 16)
295
296 #define RX_DMA_DESC_BASE_ADDRLSW_REG(i) (0x5b00 + (i) * 0x20)
297 #define RX_DMA_DESC_BASE_ADDRMSW_REG(i) (0x5b04 + (i) * 0x20)
298 #define RX_DMA_DESC_REG(i) (0x5b08 + (i) * 0x20)
299 #define RX_DMA_DESC_LEN (0x3FF << 3)
300 #define RX_DMA_DESC_RESET (1 << 25)
301 #define RX_DMA_DESC_HEADER_SPLIT (1 << 28)
302 #define RX_DMA_DESC_VLAN_STRIP (1 << 29)
303 #define RX_DMA_DESC_EN (1U << 31)
304 #define RX_DMA_DESC_HEAD_PTR_REG(i) (0x5b0c + (i) * 0x20)
305 #define RX_DMA_DESC_HEAD_PTR 0xFFF
306 #define RX_DMA_DESC_TAIL_PTR_REG(i) (0x5b10 + (i) * 0x20)
307 #define RX_DMA_DESC_BUFSIZE_REG(i) (0x5b18 + (i) * 0x20)
308 #define RX_DMA_DESC_BUFSIZE_DATA 0x000F
309 #define RX_DMA_DESC_BUFSIZE_HDR 0x0FF0
310
311 #define RX_DMA_DCAD_REG(i) (0x6100 + (i) * 4)
312 #define RX_DMA_DCAD_CPUID 0xFF
313 #define RX_DMA_DCAD_PAYLOAD_EN (1 << 29)
314 #define RX_DMA_DCAD_HEADER_EN (1 << 30)
315 #define RX_DMA_DCAD_DESC_EN (1U << 31)
316
317 #define RX_DMA_DCA_REG 0x6180
318 #define RX_DMA_DCA_EN (1U << 31)
319 #define RX_DMA_DCA_MODE 0xF
320
321 #define TX_SYSCONTROL_REG 0x7000
322 #define TX_SYSCONTROL_RESET_DIS (1 << 29)
323
324 #define TX_TPO2_REG 0x7040
325 #define TX_TPO2_EN (1 << 16)
326
327 #define TPS_DESC_VM_ARB_MODE_REG 0x7300
328 #define TPS_DESC_VM_ARB_MODE (1 << 0)
329 #define TPS_DESC_RATE_REG 0x7310
330 #define TPS_DESC_RATE_TA_RST (1U << 31)
331 #define TPS_DESC_RATE_LIM 0x7FF
332 #define TPS_DESC_TC_ARB_MODE_REG 0x7200
333 #define TPS_DESC_TC_ARB_MODE 0x3
334 #define TPS_DATA_TC_ARB_MODE_REG 0x7100
335 #define TPS_DATA_TC_ARB_MODE (1 << 0)
336
337 /* TPS_DATA_TCT_REG[AQ_TRAFFICCLASS_NUM] 0x7110-0x7130 */
338 #define TPS_DATA_TCT_REG(i) (0x7110 + (i) * 4)
339 #define TPS_DATA_TCT_CREDIT_MAX 0xFFF0000
340 #define TPS_DATA_TCT_WEIGHT 0x1FF
341 #define TPS2_DATA_TCT_CREDIT_MAX 0xFFFF0000
342 #define TPS2_DATA_TCT_WEIGHT 0x7FFF
343 /* TPS_DATA_TCT_REG[AQ_TRAFFICCLASS_NUM] 0x7210-0x7230 */
344 #define TPS_DESC_TCT_REG(i) (0x7210 + (i) * 4)
345 #define TPS_DESC_TCT_CREDIT_MAX 0xFFF0000
346 #define TPS_DESC_TCT_WEIGHT 0x1FF
347
348 #define AQ_HW_TXBUF_MAX 160
349 #define AQ_HW_RXBUF_MAX 320
350 #define AQ2_HW_TXBUF_MAX 128
351 #define AQ2_HW_RXBUF_MAX 192
352
353 #define TPO_HWCSUM_REG 0x7800
354 #define TPO_HWCSUM_L4CSUM_EN (1 << 0)
355 #define TPO_HWCSUM_IP4CSUM_EN (1 << 1)
356
357 #define THM_LSO_TCP_FLAG1_REG 0x7820
358 #define THM_LSO_TCP_FLAG1_FIRST 0xFFF
359 #define THM_LSO_TCP_FLAG1_MID 0xFFF0000
360 #define THM_LSO_TCP_FLAG2_REG 0x7824
361 #define THM_LSO_TCP_FLAG2_LAST 0xFFF
362
363 #define TPB_TX_BUF_REG 0x7900
364 #define TPB_TX_BUF_EN (1 << 0)
365 #define TPB_TX_BUF_SCP_INS_EN (1 << 2)
366 #define TPB_TX_BUF_CLK_GATE_EN (1 << 5)
367 #define TPB_TX_BUF_TC_MODE_EN (1 << 8)
368
369
370 /* TPB_TXB_BUFSIZE_REG[AQ_TRAFFICCLASS_NUM] 0x7910-7990 */
371 #define TPB_TXB_BUFSIZE_REG(i) (0x7910 + (i) * 0x10)
372 #define TPB_TXB_BUFSIZE (0xFF)
373 #define TPB_TXB_THRESH_REG(i) (0x7914 + (i) * 0x10)
374 #define TPB_TXB_THRESH_HI 0x1FFF0000
375 #define TPB_TXB_THRESH_LO 0x1FFF
376
377 #define AQ_HW_TX_DMA_TOTAL_REQ_LIMIT_REG 0x7b20
378
379 #define TX_DMA_INT_DESC_WRWB_EN_REG 0x7b40
380 #define TX_DMA_INT_DESC_WRWB_EN (1 << 1)
381 #define TX_DMA_INT_DESC_MODERATE_EN (1 << 4)
382
383 #define TX_DMA_DESC_BASE_ADDRLSW_REG(i) (0x7c00 + (i) * 0x40)
384 #define TX_DMA_DESC_BASE_ADDRMSW_REG(i) (0x7c04 + (i) * 0x40)
385 #define TX_DMA_DESC_REG(i) (0x7c08 + (i) * 0x40)
386 #define TX_DMA_DESC_LEN 0x00000FF8
387 #define TX_DMA_DESC_EN 0x80000000
388 #define TX_DMA_DESC_HEAD_PTR_REG(i) (0x7c0c + (i) * 0x40)
389 #define TX_DMA_DESC_HEAD_PTR 0x00000FFF
390 #define TX_DMA_DESC_TAIL_PTR_REG(i) (0x7c10 + (i) * 0x40)
391 #define TX_DMA_DESC_WRWB_THRESH_REG(i) (0x7c18 + (i) * 0x40)
392 #define TX_DMA_DESC_WRWB_THRESH 0x00003F00
393
394 #define TDM_DCAD_REG(i) (0x8400 + (i) * 4)
395 #define TDM_DCAD_CPUID 0x7F
396 #define TDM_DCAD_CPUID_EN 0x80000000
397
398 #define TDM_DCA_REG 0x8480
399 #define TDM_DCA_EN (1U << 31)
400 #define TDM_DCA_MODE 0xF
401
402 #define TX_INTR_MODERATION_CTL_REG(i) (0x8980 + (i) * 4)
403 #define TX_INTR_MODERATION_CTL_EN (1 << 1)
404 #define TX_INTR_MODERATION_CTL_MIN (0xFF << 8)
405 #define TX_INTR_MODERATION_CTL_MAX (0x1FF << 16)
406
407 /* AQ2 registers */
408
409 #define AQ2_MIF_HOST_FINISHED_STATUS_WRITE_REG 0x0e00
410 #define AQ2_MIF_HOST_FINISHED_STATUS_READ_REG 0x0e04
411 #define AQ2_MIF_HOST_FINISHED_STATUS_ACK (1 << 0)
412
413 #define AQ2_MCP_HOST_REQ_INT_REG 0x0f00
414 #define AQ2_MCP_HOST_REQ_INT_READY (1 << 0)
415 #define AQ2_MCP_HOST_REQ_INT_SET_REG 0x0f04
416 #define AQ2_MCP_HOST_REQ_INT_CLR_REG 0x0f08
417
418 #define AQ2_MIF_BOOT_REG 0x3040
419 #define AQ2_MIF_BOOT_HOST_DATA_LOADED (1 << 16)
420 #define AQ2_MIF_BOOT_BOOT_STARTED (1 << 24)
421 #define AQ2_MIF_BOOT_CRASH_INIT (1 << 27)
422 #define AQ2_MIF_BOOT_BOOT_CODE_FAILED (1 << 28)
423 #define AQ2_MIF_BOOT_FW_INIT_FAILED (1 << 29)
424 #define AQ2_MIF_BOOT_FW_INIT_COMP_SUCCESS (1U << 31)
425
426 /* AQ2 action resolver table */
427 #define AQ2_ART_ACTION_ACT_SHIFT 8
428 #define AQ2_ART_ACTION_RSS 0x0080
429 #define AQ2_ART_ACTION_INDEX_SHIFT 2
430 #define AQ2_ART_ACTION_ENABLE 0x0001
431 #define AQ2_ART_ACTION(act, rss, idx, en) \
432 (((act) << AQ2_ART_ACTION_ACT_SHIFT) | \
433 ((rss) ? AQ2_ART_ACTION_RSS : 0) | \
434 ((idx) << AQ2_ART_ACTION_INDEX_SHIFT) | \
435 ((en) ? AQ2_ART_ACTION_ENABLE : 0))
436 #define AQ2_ART_ACTION_DROP AQ2_ART_ACTION(0, 0, 0, 1)
437 #define AQ2_ART_ACTION_DISABLE AQ2_ART_ACTION(0, 0, 0, 0)
438 #define AQ2_ART_ACTION_ASSIGN_QUEUE(q) AQ2_ART_ACTION(1, 0, (q), 1)
439 #define AQ2_ART_ACTION_ASSIGN_TC(tc) AQ2_ART_ACTION(1, 1, (tc), 1)
440
441 #define AQ2_RPF_TAG_PCP_MASK 0xe0000000
442 #define AQ2_RPF_TAG_PCP_SHIFT 29
443 #define AQ2_RPF_TAG_FLEX_MASK 0x18000000
444 #define AQ2_RPF_TAG_UNKNOWN_MASK 0x07000000
445 #define AQ2_RPF_TAG_L4_MASK 0x00e00000
446 #define AQ2_RPF_TAG_L3_V6_MASK 0x001c0000
447 #define AQ2_RPF_TAG_L3_V4_MASK 0x00038000
448 #define AQ2_RPF_TAG_UNTAG_MASK 0x00004000
449 #define AQ2_RPF_TAG_VLAN_MASK 0x00003c00
450 #define AQ2_RPF_TAG_ET_MASK 0x00000380
451 #define AQ2_RPF_TAG_ALLMC_MASK 0x00000040
452 #define AQ2_RPF_TAG_UC_MASK 0x0000002f
453
454 /* index of aq2_filter_art_set() */
455 #define AQ2_RPF_INDEX_L2_PROMISC_OFF 0
456 #define AQ2_RPF_INDEX_VLAN_PROMISC_OFF 1
457 #define AQ2_RPF_INDEX_L3L4_USER 8
458 #define AQ2_RPF_INDEX_ET_PCP_USER 24
459 #define AQ2_RPF_INDEX_VLAN_USER 40
460 #define AQ2_RPF_INDEX_PCP_TO_TC 56
461
462 #define AQ2_RPF_L2BC_TAG_REG 0x50f0
463 #define AQ2_RPF_L2BC_TAG_MASK 0x0000003f
464
465 #define AQ2_RPF_NEW_CTRL_REG 0x5104
466 #define AQ2_RPF_NEW_CTRL_ENABLE (1 << 11)
467
468 #define AQ2_RPF_REDIR2_REG 0x54c8
469 #define AQ2_RPF_REDIR2_INDEX (1 << 12)
470 #define AQ2_RPF_REDIR2_HASHTYPE 0x00000100
471 #define AQ2_RPF_REDIR2_HASHTYPE_NONE 0
472 #define AQ2_RPF_REDIR2_HASHTYPE_IP (1 << 0)
473 #define AQ2_RPF_REDIR2_HASHTYPE_TCP4 (1 << 1)
474 #define AQ2_RPF_REDIR2_HASHTYPE_UDP4 (1 << 2)
475 #define AQ2_RPF_REDIR2_HASHTYPE_IP6 (1 << 3)
476 #define AQ2_RPF_REDIR2_HASHTYPE_TCP6 (1 << 4)
477 #define AQ2_RPF_REDIR2_HASHTYPE_UDP6 (1 << 5)
478 #define AQ2_RPF_REDIR2_HASHTYPE_IP6EX (1 << 6)
479 #define AQ2_RPF_REDIR2_HASHTYPE_TCP6EX (1 << 7)
480 #define AQ2_RPF_REDIR2_HASHTYPE_UDP6EX (1 << 8)
481 #define AQ2_RPF_REDIR2_HASHTYPE_ALL 0x00000100
482
483 #define AQ2_RPF_REC_TAB_ENABLE_REG 0x6ff0
484 #define AQ2_RPF_REC_TAB_ENABLE_MASK 0x0000ffff
485
486 #define AQ2_LAUNCHTIME_CTRL_REG 0x7a1c
487 #define AQ2_LAUNCHTIME_CTRL_RATIO 0x0000ff00
488 #define AQ2_LAUNCHTIME_CTRL_RATIO_SPEED_QUARTER 4
489 #define AQ2_LAUNCHTIME_CTRL_RATIO_SPEED_HALF 2
490 #define AQ2_LAUNCHTIME_CTRL_RATIO_SPEED_FULL 1
491
492 #define AQ2_TX_INTR_MODERATION_CTL_REG(i) (0x7c28 + (i) * 0x40)
493 #define AQ2_TX_INTR_MODERATION_CTL_EN (1 << 1)
494 #define AQ2_TX_INTR_MODERATION_CTL_MIN 0x0000ff00
495 #define AQ2_TX_INTR_MODERATION_CTL_MAX 0x01ff0000
496
497 #define AQ2_FW_INTERFACE_IN_MTU_REG 0x12000
498 #define AQ2_FW_INTERFACE_IN_MAC_ADDRESS_REG 0x12008
499
500 #define AQ2_FW_INTERFACE_IN_LINK_CONTROL_REG 0x12010
501 #define AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE 0x0000000f
502 #define AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE_INVALID 0
503 #define AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE_ACTIVE 1
504 #define AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE_SLEEP_PROXY 2
505 #define AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE_LOWPOWER 3
506 #define AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE_SHUTDOWN 4
507
508 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_REG 0x12018
509 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_DOWNSHIFT (1 << 27)
510 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_PAUSE_TX (1 << 25)
511 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_PAUSE_RX (1 << 24)
512 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_EEE_10G (1 << 20)
513 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_EEE_5G (1 << 19)
514 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_EEE_2G5 (1 << 18)
515 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_EEE_1G (1 << 17)
516 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_EEE_100M (1 << 16)
517 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_10G (1 << 15)
518 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_N5G (1 << 14)
519 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_5G (1 << 13)
520 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_N2G5 (1 << 12)
521 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_2G5 (1 << 11)
522 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_1G (1 << 10)
523 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_100M (1 << 9)
524 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_10M (1 << 8)
525 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_1G_HD (1 << 7)
526 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_100M_HD (1 << 6)
527 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_10M_HD (1 << 5)
528 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_EXTERNAL_LOOPBACK (1 << 4)
529 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_INTERNAL_LOOPBACK (1 << 3)
530 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_MINIMAL_LINK_SPEED (1 << 2)
531 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_LINK_RENEGOTIATE (1 << 1)
532 #define AQ2_FW_INTERFACE_IN_LINK_OPTIONS_LINK_UP (1 << 0)
533
534 #define AQ2_FW_INTERFACE_IN_REQUEST_POLICY_REG 0x12a58
535 #define AQ2_FW_INTERFACE_IN_REQUEST_POLICY_MCAST_QUEUE_OR_TC 0x00800000
536 #define AQ2_FW_INTERFACE_IN_REQUEST_POLICY_MCAST_RX_QUEUE_TC_INDEX 0x007c0000
537 #define AQ2_FW_INTERFACE_IN_REQUEST_POLICY_MCAST_ACCEPT 0x00010000
538 #define AQ2_FW_INTERFACE_IN_REQUEST_POLICY_BCAST_QUEUE_OR_TC 0x00008000
539 #define AQ2_FW_INTERFACE_IN_REQUEST_POLICY_BCAST_RX_QUEUE_TC_INDEX 0x00007c00
540 #define AQ2_FW_INTERFACE_IN_REQUEST_POLICY_BCAST_ACCEPT 0x00000100
541 #define AQ2_FW_INTERFACE_IN_REQUEST_POLICY_PROMISC_QUEUE_OR_TC 0x00000080
542 #define AQ2_FW_INTERFACE_IN_REQUEST_POLICY_PROMISC_RX_QUEUE_TX_INDEX 0x0000007c
543 #define AQ2_FW_INTERFACE_IN_REQUEST_POLICY_PROMISC_MCAST 0x00000002
544 #define AQ2_FW_INTERFACE_IN_REQUEST_POLICY_PROMISC_ALL 0x00000001
545
546 #define AQ2_FW_INTERFACE_OUT_TRANSACTION_ID_REG 0x13000
547 #define AQ2_FW_INTERFACE_OUT_TRANSACTION_ID_B 0xffff0000
548 #define AQ2_FW_INTERFACE_OUT_TRANSACTION_ID_B_S 16
549 #define AQ2_FW_INTERFACE_OUT_TRANSACTION_ID_A 0x0000ffff
550 #define AQ2_FW_INTERFACE_OUT_TRANSACTION_ID_A_S 0
551
552 #define AQ2_FW_INTERFACE_OUT_VERSION_BUNDLE_REG 0x13004
553 #define AQ2_FW_INTERFACE_OUT_VERSION_MAC_REG 0x13008
554
555 #define AQ2_FW_INTERFACE_OUT_VERSION_PHY_REG 0x1300c
556 #define AQ2_FW_INTERFACE_OUT_VERSION_BUILD 0xffff0000
557 #define AQ2_FW_INTERFACE_OUT_VERSION_BUILD_S 16
558 #define AQ2_FW_INTERFACE_OUT_VERSION_MINOR 0x0000ff00
559 #define AQ2_FW_INTERFACE_OUT_VERSION_MINOR_S 8
560 #define AQ2_FW_INTERFACE_OUT_VERSION_MAJOR 0x000000ff
561 #define AQ2_FW_INTERFACE_OUT_VERSION_MAJOR_S 0
562
563 #define AQ2_FW_INTERFACE_OUT_VERSION_IFACE_REG 0x13010
564 #define AQ2_FW_INTERFACE_OUT_VERSION_IFACE_VER 0x0000000f
565 #define AQ2_FW_INTERFACE_OUT_VERSION_IFACE_VER_A0 0
566 #define AQ2_FW_INTERFACE_OUT_VERSION_IFACE_VER_B0 1
567
568 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_REG 0x13014
569 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_DUPLEX (1 << 11)
570 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_EEE (1 << 10)
571 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_PAUSE_RX (1 << 9)
572 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_PAUSE_TX (1 << 8)
573 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE 0x000000f0
574 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_S 4
575 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_10G 6
576 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_5G 5
577 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_2G5 4
578 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_1G 3
579 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_100M 2
580 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_10M 1
581 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_INVALID 0
582 #define AQ2_FW_INTERFACE_OUT_LINK_STATUS_STATE 0x0000000f
583
584 #define AQ2_FW_INTERFACE_OUT_FILTER_CAPS_REG 0x13774
585 #define AQ2_FW_INTERFACE_OUT_FILTER_CAPS3_RESOLVER_BASE_INDEX 0x00ff0000
586 #define AQ2_FW_INTERFACE_OUT_FILTER_CAPS3_RESOLVER_BASE_INDEX_SHIFT 16
587
588 #define AQ2_RPF_ACT_ART_REQ_TAG_REG(i) (0x14000 + (i) * 0x10)
589 #define AQ2_RPF_ACT_ART_REQ_MASK_REG(i) (0x14004 + (i) * 0x10)
590 #define AQ2_RPF_ACT_ART_REQ_ACTION_REG(i) (0x14008 + (i) * 0x10)
591
592 #define __LOWEST_SET_BIT(__mask) (((((uint32_t)__mask) - 1) & ((uint32_t)__mask)) ^ ((uint32_t)__mask))
593 #define __SHIFTIN(__x, __mask) ((__x) * __LOWEST_SET_BIT(__mask))
594
595 #define AQ_READ_REG(sc, reg) \
596 bus_space_read_4((sc)->sc_iot, (sc)->sc_ioh, (reg))
597 #define AQ_READ_REGS(sc, reg, p, cnt) \
598 bus_space_read_region_4((sc)->sc_iot, (sc)->sc_ioh, (reg), (p), (cnt));
599
600 #define AQ_WRITE_REG(sc, reg, val) \
601 bus_space_write_4((sc)->sc_iot, (sc)->sc_ioh, (reg), (val))
602
603 #define AQ_WRITE_REG_BIT(sc, reg, mask, val) \
604 do { \
605 uint32_t _v; \
606 _v = AQ_READ_REG((sc), (reg)); \
607 _v &= ~(mask); \
608 if ((val) != 0) \
609 _v |= __SHIFTIN((val), (mask)); \
610 AQ_WRITE_REG((sc), (reg), _v); \
611 } while (/* CONSTCOND */ 0)
612
613 #define AQ_READ64_REG(sc, reg) \
614 ((uint64_t)AQ_READ_REG(sc, reg) | \
615 (((uint64_t)AQ_READ_REG(sc, (reg) + 4)) << 32))
616
617 #define AQ_WRITE64_REG(sc, reg, val) \
618 do { \
619 AQ_WRITE_REG(sc, reg, (uint32_t)val); \
620 AQ_WRITE_REG(sc, reg + 4, (uint32_t)(val >> 32)); \
621 } while (/* CONSTCOND */0)
622
623 #define WAIT_FOR(expr, us, n, errp) \
624 do { \
625 unsigned int _n; \
626 for (_n = n; (!(expr)) && _n != 0; --_n) { \
627 delay((us)); \
628 } \
629 if ((errp != NULL)) { \
630 if (_n == 0) \
631 *(errp) = ETIMEDOUT; \
632 else \
633 *(errp) = 0; \
634 } \
635 } while (/* CONSTCOND */ 0)
636
637 #define FW_VERSION_MAJOR(sc) (((sc)->sc_fw_version >> 24) & 0xff)
638 #define FW_VERSION_MINOR(sc) (((sc)->sc_fw_version >> 16) & 0xff)
639 #define FW_VERSION_BUILD(sc) ((sc)->sc_fw_version & 0xffff)
640
641 #define FEATURES_MIPS 0x00000001
642 #define FEATURES_TPO2 0x00000002
643 #define FEATURES_RPF2 0x00000004
644 #define FEATURES_MPI_AQ 0x00000008
645 #define FEATURES_AQ1_REV_A0 0x01000000
646 #define FEATURES_AQ1_REV_A (FEATURES_AQ1_REV_A0)
647 #define FEATURES_AQ1_REV_B0 0x02000000
648 #define FEATURES_AQ1_REV_B1 0x04000000
649 #define FEATURES_AQ1_REV_B (FEATURES_AQ1_REV_B0|FEATURES_AQ1_REV_B1)
650 #define FEATURES_AQ1 (FEATURES_AQ1_REV_A|FEATURES_AQ1_REV_B)
651 #define FEATURES_AQ2 0x10000000
652 #define FEATURES_AQ2_IFACE_A0 0x20000000
653 #define FEATURES_AQ2_IFACE_B0 0x40000000
654 #define HWTYPE_AQ1_P(sc) (((sc)->sc_features & FEATURES_AQ1) != 0)
655 #define HWTYPE_AQ2_P(sc) (((sc)->sc_features & FEATURES_AQ2) != 0)
656
657 /* lock for firmware interface */
658 #define AQ_MPI_LOCK(sc) mtx_enter(&(sc)->sc_mpi_mutex);
659 #define AQ_MPI_UNLOCK(sc) mtx_leave(&(sc)->sc_mpi_mutex);
660
661 #define FW2X_CTRL_10BASET_HD (1 << 0)
662 #define FW2X_CTRL_10BASET_FD (1 << 1)
663 #define FW2X_CTRL_100BASETX_HD (1 << 2)
664 #define FW2X_CTRL_100BASET4_HD (1 << 3)
665 #define FW2X_CTRL_100BASET2_HD (1 << 4)
666 #define FW2X_CTRL_100BASETX_FD (1 << 5)
667 #define FW2X_CTRL_100BASET2_FD (1 << 6)
668 #define FW2X_CTRL_1000BASET_HD (1 << 7)
669 #define FW2X_CTRL_1000BASET_FD (1 << 8)
670 #define FW2X_CTRL_2P5GBASET_FD (1 << 9)
671 #define FW2X_CTRL_5GBASET_FD (1 << 10)
672 #define FW2X_CTRL_10GBASET_FD (1 << 11)
673 #define FW2X_CTRL_RESERVED1 (1ULL << 32)
674 #define FW2X_CTRL_10BASET_EEE (1ULL << 33)
675 #define FW2X_CTRL_RESERVED2 (1ULL << 34)
676 #define FW2X_CTRL_PAUSE (1ULL << 35)
677 #define FW2X_CTRL_ASYMMETRIC_PAUSE (1ULL << 36)
678 #define FW2X_CTRL_100BASETX_EEE (1ULL << 37)
679 #define FW2X_CTRL_RESERVED3 (1ULL << 38)
680 #define FW2X_CTRL_RESERVED4 (1ULL << 39)
681 #define FW2X_CTRL_1000BASET_FD_EEE (1ULL << 40)
682 #define FW2X_CTRL_2P5GBASET_FD_EEE (1ULL << 41)
683 #define FW2X_CTRL_5GBASET_FD_EEE (1ULL << 42)
684 #define FW2X_CTRL_10GBASET_FD_EEE (1ULL << 43)
685 #define FW2X_CTRL_RESERVED5 (1ULL << 44)
686 #define FW2X_CTRL_RESERVED6 (1ULL << 45)
687 #define FW2X_CTRL_RESERVED7 (1ULL << 46)
688 #define FW2X_CTRL_RESERVED8 (1ULL << 47)
689 #define FW2X_CTRL_RESERVED9 (1ULL << 48)
690 #define FW2X_CTRL_CABLE_DIAG (1ULL << 49)
691 #define FW2X_CTRL_TEMPERATURE (1ULL << 50)
692 #define FW2X_CTRL_DOWNSHIFT (1ULL << 51)
693 #define FW2X_CTRL_PTP_AVB_EN (1ULL << 52)
694 #define FW2X_CTRL_MEDIA_DETECT (1ULL << 53)
695 #define FW2X_CTRL_LINK_DROP (1ULL << 54)
696 #define FW2X_CTRL_SLEEP_PROXY (1ULL << 55)
697 #define FW2X_CTRL_WOL (1ULL << 56)
698 #define FW2X_CTRL_MAC_STOP (1ULL << 57)
699 #define FW2X_CTRL_EXT_LOOPBACK (1ULL << 58)
700 #define FW2X_CTRL_INT_LOOPBACK (1ULL << 59)
701 #define FW2X_CTRL_EFUSE_AGENT (1ULL << 60)
702 #define FW2X_CTRL_WOL_TIMER (1ULL << 61)
703 #define FW2X_CTRL_STATISTICS (1ULL << 62)
704 #define FW2X_CTRL_TRANSACTION_ID (1ULL << 63)
705
706 #define FW2X_CTRL_RATE_100M FW2X_CTRL_100BASETX_FD
707 #define FW2X_CTRL_RATE_1G FW2X_CTRL_1000BASET_FD
708 #define FW2X_CTRL_RATE_2G5 FW2X_CTRL_2P5GBASET_FD
709 #define FW2X_CTRL_RATE_5G FW2X_CTRL_5GBASET_FD
710 #define FW2X_CTRL_RATE_10G FW2X_CTRL_10GBASET_FD
711 #define FW2X_CTRL_RATE_MASK \
712 (FW2X_CTRL_RATE_100M | \
713 FW2X_CTRL_RATE_1G | \
714 FW2X_CTRL_RATE_2G5 | \
715 FW2X_CTRL_RATE_5G | \
716 FW2X_CTRL_RATE_10G)
717 #define FW2X_CTRL_EEE_MASK \
718 (FW2X_CTRL_10BASET_EEE | \
719 FW2X_CTRL_100BASETX_EEE | \
720 FW2X_CTRL_1000BASET_FD_EEE | \
721 FW2X_CTRL_2P5GBASET_FD_EEE | \
722 FW2X_CTRL_5GBASET_FD_EEE | \
723 FW2X_CTRL_10GBASET_FD_EEE)
724
725 enum aq_hwtype {
726 HWTYPE_AQ1,
727 HWTYPE_AQ2
728 };
729
730 enum aq_fw_bootloader_mode {
731 FW_BOOT_MODE_UNKNOWN = 0,
732 FW_BOOT_MODE_FLB,
733 FW_BOOT_MODE_RBL_FLASH,
734 FW_BOOT_MODE_RBL_HOST_BOOTLOAD
735 };
736
737 enum aq_media_type {
738 AQ_MEDIA_TYPE_UNKNOWN = 0,
739 AQ_MEDIA_TYPE_FIBRE,
740 AQ_MEDIA_TYPE_TP
741 };
742
743 enum aq_link_speed {
744 AQ_LINK_NONE = 0,
745 AQ_LINK_10M = (1 << 0),
746 AQ_LINK_100M = (1 << 1),
747 AQ_LINK_1G = (1 << 2),
748 AQ_LINK_2G5 = (1 << 3),
749 AQ_LINK_5G = (1 << 4),
750 AQ_LINK_10G = (1 << 5)
751 };
752
753 #define AQ_LINK_ALL (AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5 | \
754 AQ_LINK_5G | AQ_LINK_10G )
755 #define AQ_LINK_AUTO AQ_LINK_ALL
756
757 enum aq_link_eee {
758 AQ_EEE_DISABLE = 0,
759 AQ_EEE_ENABLE = 1
760 };
761
762 enum aq_hw_fw_mpi_state {
763 MPI_DEINIT = 0,
764 MPI_RESET = 1,
765 MPI_INIT = 2,
766 MPI_POWER = 4
767 };
768
769 enum aq_link_fc {
770 AQ_FC_NONE = 0,
771 AQ_FC_RX = (1 << 0),
772 AQ_FC_TX = (1 << 1),
773 AQ_FC_ALL = (AQ_FC_RX | AQ_FC_TX)
774 };
775
776 struct aq_dmamem {
777 bus_dmamap_t aqm_map;
778 bus_dma_segment_t aqm_seg;
779 int aqm_nsegs;
780 size_t aqm_size;
781 caddr_t aqm_kva;
782 };
783
784 #define AQ_DMA_MAP(_aqm) ((_aqm)->aqm_map)
785 #define AQ_DMA_DVA(_aqm) ((_aqm)->aqm_map->dm_segs[0].ds_addr)
786 #define AQ_DMA_KVA(_aqm) ((void *)(_aqm)->aqm_kva)
787 #define AQ_DMA_LEN(_aqm) ((_aqm)->aqm_size)
788
789
790 struct aq_mailbox_header {
791 uint32_t version;
792 uint32_t transaction_id;
793 int32_t error;
794 } __packed __aligned(4);
795
796 struct aq_hw_stats_s {
797 uint32_t uprc;
798 uint32_t mprc;
799 uint32_t bprc;
800 uint32_t erpt;
801 uint32_t uptc;
802 uint32_t mptc;
803 uint32_t bptc;
804 uint32_t erpr;
805 uint32_t mbtc;
806 uint32_t bbtc;
807 uint32_t mbrc;
808 uint32_t bbrc;
809 uint32_t ubrc;
810 uint32_t ubtc;
811 uint32_t ptc;
812 uint32_t prc;
813 uint32_t dpc; /* not exists in fw2x_msm_statistics */
814 uint32_t cprc; /* not exists in fw2x_msm_statistics */
815 } __packed __aligned(4);
816
817 struct aq_fw2x_capabilities {
818 uint32_t caps_lo;
819 uint32_t caps_hi;
820 } __packed __aligned(4);
821
822 struct aq_fw2x_msm_statistics {
823 uint32_t uprc;
824 uint32_t mprc;
825 uint32_t bprc;
826 uint32_t erpt;
827 uint32_t uptc;
828 uint32_t mptc;
829 uint32_t bptc;
830 uint32_t erpr;
831 uint32_t mbtc;
832 uint32_t bbtc;
833 uint32_t mbrc;
834 uint32_t bbrc;
835 uint32_t ubrc;
836 uint32_t ubtc;
837 uint32_t ptc;
838 uint32_t prc;
839 } __packed __aligned(4);
840
841 struct aq_fw2x_phy_cable_diag_data {
842 uint32_t lane_data[4];
843 } __packed __aligned(4);
844
845 struct aq_fw2x_mailbox { /* struct fwHostInterface */
846 struct aq_mailbox_header header;
847 struct aq_fw2x_msm_statistics msm; /* msmStatistics_t msm; */
848
849 uint32_t phy_info1;
850 #define PHYINFO1_FAULT_CODE __BITS(31,16)
851 #define PHYINFO1_PHY_H_BIT __BITS(0,15)
852 uint32_t phy_info2;
853 #define PHYINFO2_TEMPERATURE __BITS(15,0)
854 #define PHYINFO2_CABLE_LEN __BITS(23,16)
855
856 struct aq_fw2x_phy_cable_diag_data diag_data;
857 uint32_t reserved[8];
858
859 struct aq_fw2x_capabilities caps;
860
861 /* ... */
862 } __packed __aligned(4);
863
864 struct aq_rx_desc_read {
865 uint64_t buf_addr;
866 uint64_t hdr_addr;
867 } __packed;
868
869 struct aq_rx_desc_wb {
870 uint32_t type;
871 #define AQ_RXDESC_TYPE_RSSTYPE 0x000f
872 #define AQ_RXDESC_TYPE_ETHER 0x0030
873 #define AQ_RXDESC_TYPE_PROTO 0x01c0
874 #define AQ_RXDESC_TYPE_VLAN (1 << 9)
875 #define AQ_RXDESC_TYPE_VLAN2 (1 << 10)
876 #define AQ_RXDESC_TYPE_DMA_ERR (1 << 12)
877 #define AQ_RXDESC_TYPE_V4_SUM (1 << 19)
878 #define AQ_RXDESC_TYPE_L4_SUM (1 << 20)
879 uint32_t rss_hash;
880 uint16_t status;
881 #define AQ_RXDESC_STATUS_DD (1 << 0)
882 #define AQ_RXDESC_STATUS_EOP (1 << 1)
883 #define AQ_RXDESC_STATUS_MACERR (1 << 2)
884 #define AQ_RXDESC_STATUS_V4_SUM_NG (1 << 3)
885 #define AQ_RXDESC_STATUS_L4_SUM_ERR (1 << 4)
886 #define AQ_RXDESC_STATUS_L4_SUM_OK (1 << 5)
887 uint16_t pkt_len;
888 uint16_t next_desc_ptr;
889 uint16_t vlan;
890 } __packed;
891
892 struct aq_tx_desc {
893 uint64_t buf_addr;
894 uint32_t ctl1;
895 #define AQ_TXDESC_CTL1_TYPE_TXD 0x00000001
896 #define AQ_TXDESC_CTL1_TYPE_TXC 0x00000002
897 #define AQ_TXDESC_CTL1_BLEN_SHIFT 4
898 #define AQ_TXDESC_CTL1_VLAN_SHIFT 4
899 #define AQ_TXDESC_CTL1_DD (1 << 20)
900 #define AQ_TXDESC_CTL1_CMD_EOP (1 << 21)
901 #define AQ_TXDESC_CTL1_CMD_VLAN (1 << 22)
902 #define AQ_TXDESC_CTL1_CMD_FCS (1 << 23)
903 #define AQ_TXDESC_CTL1_CMD_IP4CSUM (1 << 24)
904 #define AQ_TXDESC_CTL1_CMD_L4CSUM (1 << 25)
905 #define AQ_TXDESC_CTL1_CMD_WB (1 << 27)
906
907 #define AQ_TXDESC_CTL1_VID_SHIFT 4
908 uint32_t ctl2;
909 #define AQ_TXDESC_CTL2_LEN_SHIFT 14
910 #define AQ_TXDESC_CTL2_CTX_EN (1 << 13)
911 } __packed;
912
913 struct aq_slot {
914 bus_dmamap_t as_map;
915 struct mbuf *as_m;
916 };
917
918 struct aq_rxring {
919 struct ifiqueue *rx_ifiq;
920 struct aq_dmamem rx_mem;
921 struct aq_slot *rx_slots;
922 int rx_q;
923 int rx_irq;
924
925 struct timeout rx_refill;
926 struct if_rxring rx_rxr;
927 uint32_t rx_prod;
928 uint32_t rx_cons;
929
930 struct mbuf *rx_m_head;
931 struct mbuf **rx_m_tail;
932 int rx_m_error;
933 };
934
935 struct aq_txring {
936 struct ifqueue *tx_ifq;
937 struct aq_dmamem tx_mem;
938 struct aq_slot *tx_slots;
939 int tx_q;
940 int tx_irq;
941 uint32_t tx_prod;
942 uint32_t tx_cons;
943 };
944
945 struct aq_queues {
946 char q_name[16];
947 void *q_ihc;
948 struct aq_softc *q_sc;
949 int q_index;
950 struct aq_rxring q_rx;
951 struct aq_txring q_tx;
952 };
953
954
955 struct aq_softc;
956 struct aq_firmware_ops {
957 int (*reset)(struct aq_softc *);
958 int (*get_mac_addr)(struct aq_softc *);
959 int (*set_mode)(struct aq_softc *, enum aq_hw_fw_mpi_state,
960 enum aq_link_speed, enum aq_link_fc, enum aq_link_eee);
961 int (*get_mode)(struct aq_softc *, enum aq_hw_fw_mpi_state *,
962 enum aq_link_speed *, enum aq_link_fc *, enum aq_link_eee *);
963 int (*get_stats)(struct aq_softc *, struct aq_hw_stats_s *);
964 };
965
966 struct aq_softc {
967 struct device sc_dev;
968 uint16_t sc_product;
969 uint16_t sc_revision;
970 bus_dma_tag_t sc_dmat;
971 pci_chipset_tag_t sc_pc;
972 pcitag_t sc_pcitag;
973 int sc_nqueues;
974 struct aq_queues sc_queues[AQ_MAXQ];
975 struct intrmap *sc_intrmap;
976 void *sc_ih;
977 bus_space_handle_t sc_ioh;
978 bus_space_tag_t sc_iot;
979
980 uint32_t sc_mbox_addr;
981 int sc_rbl_enabled;
982 int sc_fast_start_enabled;
983 int sc_flash_present;
984 int sc_art_filter_base_index;
985 uint32_t sc_fw_version;
986 const struct aq_firmware_ops *sc_fw_ops;
987 uint64_t sc_fw_caps;
988 enum aq_media_type sc_media_type;
989 enum aq_link_speed sc_available_rates;
990 uint32_t sc_features;
991 int sc_linkstat_irq;
992 struct arpcom sc_arpcom;
993 struct ifmedia sc_media;
994
995 struct ether_addr sc_enaddr;
996 struct mutex sc_mpi_mutex;
997 };
998
999 const struct pci_matchid aq_devices[] = {
1000 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC100 },
1001 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC107 },
1002 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC108 },
1003 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC109 },
1004 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC111 },
1005 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC112 },
1006 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC113 },
1007 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC113C },
1008 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC113CA },
1009 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC113CS },
1010 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC114CS },
1011 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC115C },
1012 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC116C },
1013 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC100S },
1014 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC107S },
1015 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC108S },
1016 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC109S },
1017 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC111S },
1018 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC112S },
1019 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_D100 },
1020 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_D107 },
1021 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_D108 },
1022 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_D109 },
1023 };
1024
1025 const struct aq_product {
1026 pci_vendor_id_t aq_vendor;
1027 pci_product_id_t aq_product;
1028 enum aq_hwtype aq_hwtype;
1029 enum aq_media_type aq_media_type;
1030 enum aq_link_speed aq_available_rates;
1031 } aq_products[] = {
1032 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC100, HWTYPE_AQ1,
1033 AQ_MEDIA_TYPE_FIBRE, AQ_LINK_ALL
1034 },
1035 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC107, HWTYPE_AQ1,
1036 AQ_MEDIA_TYPE_TP, AQ_LINK_ALL
1037 },
1038 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC108, HWTYPE_AQ1,
1039 AQ_MEDIA_TYPE_TP, AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5 | AQ_LINK_5G
1040 },
1041 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC109, HWTYPE_AQ1,
1042 AQ_MEDIA_TYPE_TP, AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5
1043 },
1044 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC111, HWTYPE_AQ1,
1045 AQ_MEDIA_TYPE_TP, AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5 | AQ_LINK_5G
1046 },
1047 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC112, HWTYPE_AQ1,
1048 AQ_MEDIA_TYPE_TP, AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5
1049 },
1050 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC100S, HWTYPE_AQ1,
1051 AQ_MEDIA_TYPE_FIBRE, AQ_LINK_ALL
1052 },
1053 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC107S, HWTYPE_AQ1,
1054 AQ_MEDIA_TYPE_TP, AQ_LINK_ALL
1055 },
1056 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC108S, HWTYPE_AQ1,
1057 AQ_MEDIA_TYPE_TP, AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5 | AQ_LINK_5G
1058 },
1059 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC109S, HWTYPE_AQ1,
1060 AQ_MEDIA_TYPE_TP, AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5
1061 },
1062 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC111S, HWTYPE_AQ1,
1063 AQ_MEDIA_TYPE_TP, AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5 | AQ_LINK_5G
1064 },
1065 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC112S, HWTYPE_AQ1,
1066 AQ_MEDIA_TYPE_TP, AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5
1067 },
1068 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_D100, HWTYPE_AQ1,
1069 AQ_MEDIA_TYPE_FIBRE, AQ_LINK_ALL
1070 },
1071 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_D107, HWTYPE_AQ1,
1072 AQ_MEDIA_TYPE_TP, AQ_LINK_ALL
1073 },
1074 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_D108, HWTYPE_AQ1,
1075 AQ_MEDIA_TYPE_TP, AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5 | AQ_LINK_5G
1076 },
1077 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_D109, HWTYPE_AQ1,
1078 AQ_MEDIA_TYPE_TP, AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5
1079 },
1080
1081 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC113, HWTYPE_AQ2,
1082 AQ_MEDIA_TYPE_TP, AQ_LINK_ALL | AQ_LINK_10M
1083 },
1084 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC113C, HWTYPE_AQ2,
1085 AQ_MEDIA_TYPE_TP, AQ_LINK_ALL | AQ_LINK_10M
1086 },
1087 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC113CA, HWTYPE_AQ2,
1088 AQ_MEDIA_TYPE_TP, AQ_LINK_ALL | AQ_LINK_10M
1089 },
1090 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC113CS, HWTYPE_AQ2,
1091 AQ_MEDIA_TYPE_TP, AQ_LINK_ALL | AQ_LINK_10M
1092 },
1093 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC114CS, HWTYPE_AQ2,
1094 AQ_MEDIA_TYPE_TP,
1095 AQ_LINK_10M | AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5 | AQ_LINK_5G
1096 },
1097 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC115C, HWTYPE_AQ2,
1098 AQ_MEDIA_TYPE_TP,
1099 AQ_LINK_10M | AQ_LINK_100M | AQ_LINK_1G | AQ_LINK_2G5
1100 },
1101 { PCI_VENDOR_AQUANTIA, PCI_PRODUCT_AQUANTIA_AQC116C, HWTYPE_AQ2,
1102 AQ_MEDIA_TYPE_TP, AQ_LINK_10M | AQ_LINK_100M | AQ_LINK_1G
1103 },
1104 };
1105
1106 int aq_match(struct device *, void *, void *);
1107 void aq_attach(struct device *, struct device *, void *);
1108 int aq_activate(struct device *, int);
1109 int aq_intr(void *);
1110 int aq_intr_link(void *);
1111 int aq_intr_queue(void *);
1112 int aq_init_rss(struct aq_softc *);
1113 int aq_hw_reset(struct aq_softc *);
1114 int aq_hw_init(struct aq_softc *, int, int);
1115 void aq_hw_qos_set(struct aq_softc *);
1116 void aq_hw_init_tx_path(struct aq_softc *);
1117 void aq_hw_init_rx_path(struct aq_softc *);
1118 int aq_set_mac_addr(struct aq_softc *, int, uint8_t *);
1119 int aq_set_linkmode(struct aq_softc *, enum aq_link_speed,
1120 enum aq_link_fc, enum aq_link_eee);
1121 void aq_watchdog(struct ifnet *);
1122 void aq_enable_intr(struct aq_softc *, int, int);
1123 int aq_rxrinfo(struct aq_softc *, struct if_rxrinfo *);
1124 int aq_ioctl(struct ifnet *, u_long, caddr_t);
1125 int aq_up(struct aq_softc *);
1126 void aq_down(struct aq_softc *);
1127 void aq_iff(struct aq_softc *);
1128 void aq_start(struct ifqueue *);
1129 void aq_ifmedia_status(struct ifnet *, struct ifmediareq *);
1130 int aq_ifmedia_change(struct ifnet *);
1131 void aq_update_link_status(struct aq_softc *);
1132
1133 int aq1_fw_reboot(struct aq_softc *);
1134 int aq1_fw_read_version(struct aq_softc *);
1135 int aq1_fw_version_init(struct aq_softc *);
1136 int aq1_hw_init_ucp(struct aq_softc *);
1137 void aq1_global_software_reset(struct aq_softc *);
1138 int aq1_mac_soft_reset(struct aq_softc *, enum aq_fw_bootloader_mode *);
1139 int aq1_mac_soft_reset_rbl(struct aq_softc *, enum aq_fw_bootloader_mode *);
1140 int aq1_mac_soft_reset_flb(struct aq_softc *);
1141 int aq1_fw_downld_dwords(struct aq_softc *, uint32_t, uint32_t *, uint32_t);
1142
1143 int aq2_interface_buffer_read(struct aq_softc *, uint32_t, uint32_t *,
1144 uint32_t);
1145 int aq2_fw_reboot(struct aq_softc *);
1146 int aq2_filter_art_set(struct aq_softc *, uint32_t, uint32_t, uint32_t,
1147 uint32_t action);
1148
1149 void aq_refill(void *);
1150 int aq_rx_fill(struct aq_softc *, struct aq_rxring *);
1151 static inline unsigned int aq_rx_fill_slots(struct aq_softc *,
1152 struct aq_rxring *, uint);
1153
1154 int aq_dmamem_alloc(struct aq_softc *, struct aq_dmamem *,
1155 bus_size_t, u_int);
1156 void aq_dmamem_free(struct aq_softc *, struct aq_dmamem *);
1157
1158 int aq1_get_mac_addr(struct aq_softc *);
1159
1160 int aq_fw1x_reset(struct aq_softc *);
1161 int aq_fw1x_get_mode(struct aq_softc *, enum aq_hw_fw_mpi_state *,
1162 enum aq_link_speed *, enum aq_link_fc *, enum aq_link_eee *);
1163 int aq_fw1x_set_mode(struct aq_softc *, enum aq_hw_fw_mpi_state,
1164 enum aq_link_speed, enum aq_link_fc, enum aq_link_eee);
1165 int aq_fw1x_get_stats(struct aq_softc *, struct aq_hw_stats_s *);
1166
1167 int aq_fw2x_reset(struct aq_softc *);
1168 int aq_fw2x_get_mode(struct aq_softc *, enum aq_hw_fw_mpi_state *,
1169 enum aq_link_speed *, enum aq_link_fc *, enum aq_link_eee *);
1170 int aq_fw2x_set_mode(struct aq_softc *, enum aq_hw_fw_mpi_state,
1171 enum aq_link_speed, enum aq_link_fc, enum aq_link_eee);
1172 int aq_fw2x_get_stats(struct aq_softc *, struct aq_hw_stats_s *);
1173
1174 int aq2_fw_reset(struct aq_softc *);
1175 int aq2_get_mac_addr(struct aq_softc *);
1176 int aq2_fw_get_mode(struct aq_softc *, enum aq_hw_fw_mpi_state *,
1177 enum aq_link_speed *, enum aq_link_fc *, enum aq_link_eee *);
1178 int aq2_fw_set_mode(struct aq_softc *, enum aq_hw_fw_mpi_state,
1179 enum aq_link_speed, enum aq_link_fc, enum aq_link_eee);
1180 int aq2_fw_get_stats(struct aq_softc *, struct aq_hw_stats_s *);
1181
1182 const struct aq_firmware_ops aq_fw1x_ops = {
1183 .reset = aq_fw1x_reset,
1184 .get_mac_addr = aq1_get_mac_addr,
1185 .set_mode = aq_fw1x_set_mode,
1186 .get_mode = aq_fw1x_get_mode,
1187 .get_stats = aq_fw1x_get_stats,
1188 };
1189
1190 const struct aq_firmware_ops aq_fw2x_ops = {
1191 .reset = aq_fw2x_reset,
1192 .get_mac_addr = aq1_get_mac_addr,
1193 .set_mode = aq_fw2x_set_mode,
1194 .get_mode = aq_fw2x_get_mode,
1195 .get_stats = aq_fw2x_get_stats,
1196 };
1197
1198 const struct aq_firmware_ops aq2_fw_ops = {
1199 .reset = aq2_fw_reset,
1200 .get_mac_addr = aq2_get_mac_addr,
1201 .set_mode = aq2_fw_set_mode,
1202 .get_mode = aq2_fw_get_mode,
1203 .get_stats = aq2_fw_get_stats
1204 };
1205
1206 const struct cfattach aq_ca = {
1207 sizeof(struct aq_softc), aq_match, aq_attach, NULL,
1208 aq_activate
1209 };
1210
1211 struct cfdriver aq_cd = {
1212 NULL, "aq", DV_IFNET
1213 };
1214
1215 int
aq_match(struct device * dev,void * match,void * aux)1216 aq_match(struct device *dev, void *match, void *aux)
1217 {
1218 return pci_matchbyid((struct pci_attach_args *)aux, aq_devices,
1219 sizeof(aq_devices) / sizeof(aq_devices[0]));
1220 }
1221
1222 const struct aq_product *
aq_lookup(const struct pci_attach_args * pa)1223 aq_lookup(const struct pci_attach_args *pa)
1224 {
1225 unsigned int i;
1226
1227 for (i = 0; i < sizeof(aq_products) / sizeof(aq_products[0]); i++) {
1228 if (PCI_VENDOR(pa->pa_id) == aq_products[i].aq_vendor &&
1229 PCI_PRODUCT(pa->pa_id) == aq_products[i].aq_product) {
1230 return &aq_products[i];
1231 }
1232 }
1233
1234 return NULL;
1235 }
1236
1237 void
aq_attach(struct device * parent,struct device * self,void * aux)1238 aq_attach(struct device *parent, struct device *self, void *aux)
1239 {
1240 struct aq_softc *sc = (struct aq_softc *)self;
1241 struct pci_attach_args *pa = aux;
1242 const struct aq_product *aqp;
1243 pcireg_t bar, memtype;
1244 pci_chipset_tag_t pc;
1245 pci_intr_handle_t ih;
1246 int (*isr)(void *);
1247 const char *intrstr;
1248 pcitag_t tag;
1249 struct ifnet *ifp = &sc->sc_arpcom.ac_if;
1250 int txmin, txmax, rxmin, rxmax;
1251 int irqmode, irqnum;
1252 int i;
1253
1254 mtx_init(&sc->sc_mpi_mutex, IPL_NET);
1255
1256 sc->sc_dmat = pa->pa_dmat;
1257 sc->sc_pc = pc = pa->pa_pc;
1258 sc->sc_pcitag = tag = pa->pa_tag;
1259
1260 sc->sc_product = PCI_PRODUCT(pa->pa_id);
1261 sc->sc_revision = PCI_REVISION(pa->pa_class);
1262
1263 aqp = aq_lookup(pa);
1264
1265 bar = pci_conf_read(pc, tag, AQ_BAR0);
1266 if (PCI_MAPREG_TYPE(bar) != PCI_MAPREG_TYPE_MEM) {
1267 printf(": wrong BAR type\n");
1268 return;
1269 }
1270
1271 memtype = pci_mapreg_type(pc, tag, AQ_BAR0);
1272 if (pci_mapreg_map(pa, AQ_BAR0, memtype, 0, &sc->sc_iot, &sc->sc_ioh,
1273 NULL, NULL, 0)) {
1274 printf(": failed to map BAR0\n");
1275 return;
1276 }
1277
1278 sc->sc_nqueues = 1;
1279 sc->sc_linkstat_irq = AQ_LINKSTAT_IRQ;
1280 isr = aq_intr;
1281 irqnum = 0;
1282
1283 if (pci_intr_map_msix(pa, 0, &ih) == 0) {
1284 int nmsix = pci_intr_msix_count(pa);
1285 /* don't do rss on aq2 yet */
1286 if (aqp->aq_hwtype == HWTYPE_AQ1 && nmsix > 1) {
1287 nmsix--;
1288 sc->sc_intrmap = intrmap_create(&sc->sc_dev,
1289 nmsix, AQ_MAXQ, INTRMAP_POWEROF2);
1290 sc->sc_nqueues = intrmap_count(sc->sc_intrmap);
1291 KASSERT(sc->sc_nqueues > 0);
1292 KASSERT(powerof2(sc->sc_nqueues));
1293
1294 sc->sc_linkstat_irq = 0;
1295 isr = aq_intr_link;
1296 irqnum++;
1297 }
1298 irqmode = AQ_INTR_CTRL_IRQMODE_MSIX;
1299 } else if (pci_intr_map_msi(pa, &ih) == 0) {
1300 irqmode = AQ_INTR_CTRL_IRQMODE_MSI;
1301 } else if (pci_intr_map(pa, &ih) == 0) {
1302 irqmode = AQ_INTR_CTRL_IRQMODE_LEGACY;
1303 } else {
1304 printf(": failed to map interrupt\n");
1305 return;
1306 }
1307
1308 sc->sc_ih = pci_intr_establish(pa->pa_pc, ih,
1309 IPL_NET | IPL_MPSAFE, isr, sc, self->dv_xname);
1310 intrstr = pci_intr_string(pa->pa_pc, ih);
1311 if (intrstr)
1312 printf(": %s", intrstr);
1313
1314 if (sc->sc_nqueues > 1)
1315 printf(", %d queues", sc->sc_nqueues);
1316
1317 switch (aqp->aq_hwtype) {
1318 case HWTYPE_AQ1:
1319 if (aq1_fw_reboot(sc))
1320 return;
1321 break;
1322 case HWTYPE_AQ2:
1323 if (aq2_fw_reboot(sc))
1324 return;
1325 break;
1326 default:
1327 return;
1328 }
1329
1330 if (aq_hw_reset(sc))
1331 return;
1332
1333 if (sc->sc_fw_ops->get_mac_addr(sc))
1334 return;
1335 printf(", address %s", ether_sprintf(sc->sc_enaddr.ether_addr_octet));
1336
1337 if (aq_init_rss(sc))
1338 return;
1339
1340 if (aq_hw_init(sc, irqmode, (sc->sc_nqueues > 1)))
1341 return;
1342
1343 sc->sc_media_type = aqp->aq_media_type;
1344 sc->sc_available_rates = aqp->aq_available_rates;
1345
1346 ifmedia_init(&sc->sc_media, IFM_IMASK, aq_ifmedia_change,
1347 aq_ifmedia_status);
1348
1349 bcopy(sc->sc_enaddr.ether_addr_octet, sc->sc_arpcom.ac_enaddr, 6);
1350 strlcpy(ifp->if_xname, self->dv_xname, IFNAMSIZ);
1351 ifp->if_softc = sc;
1352 ifp->if_flags = IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX;
1353 ifp->if_xflags = IFXF_MPSAFE;
1354 ifp->if_ioctl = aq_ioctl;
1355 ifp->if_qstart = aq_start;
1356 ifp->if_watchdog = aq_watchdog;
1357 ifp->if_hardmtu = 9000;
1358 ifp->if_capabilities = IFCAP_VLAN_MTU | IFCAP_CSUM_IPv4 |
1359 IFCAP_CSUM_UDPv4 | IFCAP_CSUM_UDPv6 | IFCAP_CSUM_TCPv4 |
1360 IFCAP_CSUM_TCPv6;
1361 #if NVLAN > 0
1362 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING;
1363 #endif
1364 ifq_init_maxlen(&ifp->if_snd, AQ_TXD_NUM);
1365
1366 ifmedia_init(&sc->sc_media, IFM_IMASK, aq_ifmedia_change,
1367 aq_ifmedia_status);
1368 if (sc->sc_available_rates & AQ_LINK_10M) {
1369 ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_10_T, 0, NULL);
1370 ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_10_T|IFM_FDX, 0,
1371 NULL);
1372 }
1373
1374 if (sc->sc_available_rates & AQ_LINK_100M) {
1375 ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_100_TX, 0, NULL);
1376 ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_100_TX|IFM_FDX, 0,
1377 NULL);
1378 }
1379
1380 if (sc->sc_available_rates & AQ_LINK_1G) {
1381 ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_1000_T, 0, NULL);
1382 ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_1000_T|IFM_FDX, 0,
1383 NULL);
1384 }
1385
1386 if (sc->sc_available_rates & AQ_LINK_2G5) {
1387 ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_2500_T, 0, NULL);
1388 ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_2500_T | IFM_FDX,
1389 0, NULL);
1390 }
1391
1392 if (sc->sc_available_rates & AQ_LINK_5G) {
1393 ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_5000_T, 0, NULL);
1394 ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_5000_T | IFM_FDX,
1395 0, NULL);
1396 }
1397
1398 if (sc->sc_available_rates & AQ_LINK_10G) {
1399 ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10G_T, 0, NULL);
1400 ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10G_T | IFM_FDX,
1401 0, NULL);
1402 }
1403
1404 ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_AUTO, 0, NULL);
1405 ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_AUTO | IFM_FDX, 0, NULL);
1406 ifmedia_set(&sc->sc_media, IFM_ETHER | IFM_AUTO);
1407 aq_set_linkmode(sc, AQ_LINK_AUTO, AQ_FC_NONE, AQ_EEE_DISABLE);
1408
1409 if_attach(ifp);
1410 ether_ifattach(ifp);
1411
1412 if_attach_iqueues(ifp, sc->sc_nqueues);
1413 if_attach_queues(ifp, sc->sc_nqueues);
1414
1415 /*
1416 * set interrupt moderation for up to 20k interrupts per second,
1417 * more rx than tx. these values are in units of 2us.
1418 */
1419 txmin = 20;
1420 txmax = 200;
1421 rxmin = 6;
1422 rxmax = 60;
1423
1424 for (i = 0; i < sc->sc_nqueues; i++) {
1425 struct aq_queues *aq = &sc->sc_queues[i];
1426 struct aq_rxring *rx = &aq->q_rx;
1427 struct aq_txring *tx = &aq->q_tx;
1428 pci_intr_handle_t ih;
1429
1430 aq->q_sc = sc;
1431 aq->q_index = i;
1432 rx->rx_q = i;
1433 rx->rx_ifiq = ifp->if_iqs[i];
1434 rx->rx_m_head = NULL;
1435 rx->rx_m_tail = &rx->rx_m_head;
1436 rx->rx_m_error = 0;
1437 ifp->if_iqs[i]->ifiq_softc = aq;
1438 timeout_set(&rx->rx_refill, aq_refill, rx);
1439
1440 tx->tx_q = i;
1441 tx->tx_ifq = ifp->if_ifqs[i];
1442 ifp->if_ifqs[i]->ifq_softc = aq;
1443
1444 snprintf(aq->q_name, sizeof(aq->q_name), "%s:%u",
1445 DEVNAME(sc), i);
1446
1447 if (sc->sc_nqueues > 1) {
1448 if (pci_intr_map_msix(pa, irqnum, &ih)) {
1449 printf(": unable to map msi-x vector %d\n",
1450 irqnum);
1451 return;
1452 }
1453
1454 aq->q_ihc = pci_intr_establish_cpu(sc->sc_pc, ih,
1455 IPL_NET | IPL_MPSAFE, intrmap_cpu(sc->sc_intrmap, i),
1456 aq_intr_queue, aq, aq->q_name);
1457 if (aq->q_ihc == NULL) {
1458 printf(": unable to establish interrupt %d\n",
1459 irqnum);
1460 return;
1461 }
1462 rx->rx_irq = irqnum;
1463 tx->tx_irq = irqnum;
1464 irqnum++;
1465 } else {
1466 rx->rx_irq = irqnum++;
1467 tx->tx_irq = irqnum++;
1468 }
1469
1470 if (HWTYPE_AQ2_P(sc)) {
1471 AQ_WRITE_REG_BIT(sc, AQ2_TX_INTR_MODERATION_CTL_REG(i),
1472 AQ2_TX_INTR_MODERATION_CTL_MIN, txmin);
1473 AQ_WRITE_REG_BIT(sc, AQ2_TX_INTR_MODERATION_CTL_REG(i),
1474 AQ2_TX_INTR_MODERATION_CTL_MAX, txmax);
1475 AQ_WRITE_REG_BIT(sc, AQ2_TX_INTR_MODERATION_CTL_REG(i),
1476 AQ2_TX_INTR_MODERATION_CTL_EN, 1);
1477 } else {
1478 AQ_WRITE_REG_BIT(sc, TX_INTR_MODERATION_CTL_REG(i),
1479 TX_INTR_MODERATION_CTL_MIN, txmin);
1480 AQ_WRITE_REG_BIT(sc, TX_INTR_MODERATION_CTL_REG(i),
1481 TX_INTR_MODERATION_CTL_MAX, txmax);
1482 AQ_WRITE_REG_BIT(sc, TX_INTR_MODERATION_CTL_REG(i),
1483 TX_INTR_MODERATION_CTL_EN, 1);
1484 }
1485 AQ_WRITE_REG_BIT(sc, RX_INTR_MODERATION_CTL_REG(i),
1486 RX_INTR_MODERATION_CTL_MIN, rxmin);
1487 AQ_WRITE_REG_BIT(sc, RX_INTR_MODERATION_CTL_REG(i),
1488 RX_INTR_MODERATION_CTL_MAX, rxmax);
1489 AQ_WRITE_REG_BIT(sc, RX_INTR_MODERATION_CTL_REG(i),
1490 RX_INTR_MODERATION_CTL_EN, 1);
1491 }
1492
1493 AQ_WRITE_REG_BIT(sc, TX_DMA_INT_DESC_WRWB_EN_REG,
1494 TX_DMA_INT_DESC_WRWB_EN, 0);
1495 AQ_WRITE_REG_BIT(sc, TX_DMA_INT_DESC_WRWB_EN_REG,
1496 TX_DMA_INT_DESC_MODERATE_EN, 1);
1497 AQ_WRITE_REG_BIT(sc, RX_DMA_INT_DESC_WRWB_EN_REG,
1498 RX_DMA_INT_DESC_WRWB_EN, 0);
1499 AQ_WRITE_REG_BIT(sc, RX_DMA_INT_DESC_WRWB_EN_REG,
1500 RX_DMA_INT_DESC_MODERATE_EN, 1);
1501
1502 aq_enable_intr(sc, 1, 0);
1503 printf("\n");
1504 }
1505
1506 int
aq1_fw_reboot(struct aq_softc * sc)1507 aq1_fw_reboot(struct aq_softc *sc)
1508 {
1509 uint32_t ver, v, boot_exit_code;
1510 int i, error;
1511 enum aq_fw_bootloader_mode mode;
1512
1513 mode = FW_BOOT_MODE_UNKNOWN;
1514
1515 ver = AQ_READ_REG(sc, AQ_FW_VERSION_REG);
1516
1517 for (i = 1000; i > 0; i--) {
1518 v = AQ_READ_REG(sc, FW_MPI_DAISY_CHAIN_STATUS_REG);
1519 boot_exit_code = AQ_READ_REG(sc, FW_BOOT_EXIT_CODE_REG);
1520 if (v != 0x06000000 || boot_exit_code != 0)
1521 break;
1522 }
1523
1524 if (i <= 0) {
1525 printf(": F/W reset failed. Neither RBL nor FLB started");
1526 return ETIMEDOUT;
1527 }
1528
1529 sc->sc_rbl_enabled = (boot_exit_code != 0);
1530
1531 /*
1532 * Having FW version 0 is an indicator that cold start
1533 * is in progress. This means two things:
1534 * 1) Driver have to wait for FW/HW to finish boot (500ms giveup)
1535 * 2) Driver may skip reset sequence and save time.
1536 */
1537 if (sc->sc_fast_start_enabled && (ver != 0)) {
1538 if (aq1_fw_read_version(sc) == 0)
1539 goto faststart;
1540 }
1541
1542 error = aq1_mac_soft_reset(sc, &mode);
1543 if (error != 0) {
1544 printf("%s: MAC reset failed: %d\n", DEVNAME(sc), error);
1545 return error;
1546 }
1547
1548 switch (mode) {
1549 case FW_BOOT_MODE_FLB:
1550 DPRINTF(("%s: FLB> F/W successfully loaded from flash.",
1551 DEVNAME(sc)));
1552 sc->sc_flash_present = 1;
1553 break;
1554 case FW_BOOT_MODE_RBL_FLASH:
1555 DPRINTF(("%s: RBL> F/W loaded from flash. Host Bootload "
1556 "disabled.", DEVNAME(sc)));
1557 sc->sc_flash_present = 1;
1558 break;
1559 case FW_BOOT_MODE_UNKNOWN:
1560 printf("%s: F/W bootload error: unknown bootloader type",
1561 DEVNAME(sc));
1562 return ENOTSUP;
1563 case FW_BOOT_MODE_RBL_HOST_BOOTLOAD:
1564 printf("%s: RBL> F/W Host Bootload not implemented", DEVNAME(sc));
1565 return ENOTSUP;
1566 }
1567
1568 faststart:
1569 error = aq1_fw_read_version(sc);
1570 if (error != 0)
1571 return error;
1572
1573 error = aq1_fw_version_init(sc);
1574 if (error != 0)
1575 return error;
1576
1577 return aq1_hw_init_ucp(sc);
1578 }
1579
1580 int
aq1_mac_soft_reset_rbl(struct aq_softc * sc,enum aq_fw_bootloader_mode * mode)1581 aq1_mac_soft_reset_rbl(struct aq_softc *sc, enum aq_fw_bootloader_mode *mode)
1582 {
1583 int timo;
1584
1585 DPRINTF(("%s: RBL> MAC reset STARTED!\n", DEVNAME(sc)));
1586
1587 AQ_WRITE_REG(sc, AQ_FW_GLB_CTL2_REG, 0x40e1);
1588 AQ_WRITE_REG(sc, AQ_FW_GLB_CPU_SEM_REG(0), 1);
1589 AQ_WRITE_REG(sc, AQ_MBOXIF_POWER_GATING_CONTROL_REG, 0);
1590
1591 /* MAC FW will reload PHY FW if 1E.1000.3 was cleaned - #undone */
1592 AQ_WRITE_REG(sc, FW_BOOT_EXIT_CODE_REG, RBL_STATUS_DEAD);
1593
1594 aq1_global_software_reset(sc);
1595
1596 AQ_WRITE_REG(sc, AQ_FW_GLB_CTL2_REG, 0x40e0);
1597
1598 /* Wait for RBL to finish boot process. */
1599 #define RBL_TIMEOUT_MS 10000
1600 uint16_t rbl_status;
1601 for (timo = RBL_TIMEOUT_MS; timo > 0; timo--) {
1602 rbl_status = AQ_READ_REG(sc, FW_BOOT_EXIT_CODE_REG) & 0xffff;
1603 if (rbl_status != 0 && rbl_status != RBL_STATUS_DEAD)
1604 break;
1605 delay(1000);
1606 }
1607
1608 if (timo <= 0) {
1609 printf("%s: RBL> RBL restart failed: timeout\n", DEVNAME(sc));
1610 return EBUSY;
1611 }
1612
1613 switch (rbl_status) {
1614 case RBL_STATUS_SUCCESS:
1615 if (mode != NULL)
1616 *mode = FW_BOOT_MODE_RBL_FLASH;
1617 DPRINTF(("%s: RBL> reset complete! [Flash]\n", DEVNAME(sc)));
1618 break;
1619 case RBL_STATUS_HOST_BOOT:
1620 if (mode != NULL)
1621 *mode = FW_BOOT_MODE_RBL_HOST_BOOTLOAD;
1622 DPRINTF(("%s: RBL> reset complete! [Host Bootload]\n",
1623 DEVNAME(sc)));
1624 break;
1625 case RBL_STATUS_FAILURE:
1626 default:
1627 printf("%s: unknown RBL status 0x%x\n", DEVNAME(sc),
1628 rbl_status);
1629 return EBUSY;
1630 }
1631
1632 return 0;
1633 }
1634
1635 int
aq1_mac_soft_reset_flb(struct aq_softc * sc)1636 aq1_mac_soft_reset_flb(struct aq_softc *sc)
1637 {
1638 uint32_t v;
1639 int timo;
1640
1641 AQ_WRITE_REG(sc, AQ_FW_GLB_CTL2_REG, 0x40e1);
1642 /*
1643 * Let Felicity hardware to complete SMBUS transaction before
1644 * Global software reset.
1645 */
1646 delay(50000);
1647
1648 /*
1649 * If SPI burst transaction was interrupted(before running the script),
1650 * global software reset may not clear SPI interface.
1651 * Clean it up manually before global reset.
1652 */
1653 AQ_WRITE_REG(sc, AQ_GLB_NVR_PROVISIONING2_REG, 0x00a0);
1654 AQ_WRITE_REG(sc, AQ_GLB_NVR_INTERFACE1_REG, 0x009f);
1655 AQ_WRITE_REG(sc, AQ_GLB_NVR_INTERFACE1_REG, 0x809f);
1656 delay(50000);
1657
1658 v = AQ_READ_REG(sc, AQ_FW_SOFTRESET_REG);
1659 v &= ~AQ_FW_SOFTRESET_DIS;
1660 v |= AQ_FW_SOFTRESET_RESET;
1661 AQ_WRITE_REG(sc, AQ_FW_SOFTRESET_REG, v);
1662
1663 /* Kickstart. */
1664 AQ_WRITE_REG(sc, AQ_FW_GLB_CTL2_REG, 0x80e0);
1665 AQ_WRITE_REG(sc, AQ_MBOXIF_POWER_GATING_CONTROL_REG, 0);
1666 if (!sc->sc_fast_start_enabled)
1667 AQ_WRITE_REG(sc, AQ_GLB_GENERAL_PROVISIONING9_REG, 1);
1668
1669 /*
1670 * For the case SPI burst transaction was interrupted (by MCP reset
1671 * above), wait until it is completed by hardware.
1672 */
1673 delay(50000);
1674
1675 /* MAC Kickstart */
1676 if (!sc->sc_fast_start_enabled) {
1677 AQ_WRITE_REG(sc, AQ_FW_GLB_CTL2_REG, 0x180e0);
1678
1679 uint32_t flb_status;
1680 for (timo = 0; timo < 1000; timo++) {
1681 flb_status = AQ_READ_REG(sc,
1682 FW_MPI_DAISY_CHAIN_STATUS_REG) & 0x10;
1683 if (flb_status != 0)
1684 break;
1685 delay(1000);
1686 }
1687 if (flb_status == 0) {
1688 printf("%s: FLB> MAC kickstart failed: timed out\n",
1689 DEVNAME(sc));
1690 return ETIMEDOUT;
1691 }
1692 DPRINTF(("%s: FLB> MAC kickstart done, %d ms\n", DEVNAME(sc),
1693 timo));
1694 /* FW reset */
1695 AQ_WRITE_REG(sc, AQ_FW_GLB_CTL2_REG, 0x80e0);
1696 /*
1697 * Let Felicity hardware complete SMBUS transaction before
1698 * Global software reset.
1699 */
1700 delay(50000);
1701 sc->sc_fast_start_enabled = true;
1702 }
1703 AQ_WRITE_REG(sc, AQ_FW_GLB_CPU_SEM_REG(0), 1);
1704
1705 /* PHY Kickstart: #undone */
1706 aq1_global_software_reset(sc);
1707
1708 for (timo = 0; timo < 1000; timo++) {
1709 if (AQ_READ_REG(sc, AQ_FW_VERSION_REG) != 0)
1710 break;
1711 delay(10000);
1712 }
1713 if (timo >= 1000) {
1714 printf("%s: FLB> Global Soft Reset failed\n", DEVNAME(sc));
1715 return ETIMEDOUT;
1716 }
1717 DPRINTF(("%s: FLB> F/W restart: %d ms\n", DEVNAME(sc), timo * 10));
1718
1719 return 0;
1720
1721 }
1722
1723 int
aq1_mac_soft_reset(struct aq_softc * sc,enum aq_fw_bootloader_mode * mode)1724 aq1_mac_soft_reset(struct aq_softc *sc, enum aq_fw_bootloader_mode *mode)
1725 {
1726 if (sc->sc_rbl_enabled)
1727 return aq1_mac_soft_reset_rbl(sc, mode);
1728
1729 if (mode != NULL)
1730 *mode = FW_BOOT_MODE_FLB;
1731 return aq1_mac_soft_reset_flb(sc);
1732 }
1733
1734 void
aq1_global_software_reset(struct aq_softc * sc)1735 aq1_global_software_reset(struct aq_softc *sc)
1736 {
1737 uint32_t v;
1738
1739 AQ_WRITE_REG_BIT(sc, RX_SYSCONTROL_REG, RX_SYSCONTROL_RESET_DIS, 0);
1740 AQ_WRITE_REG_BIT(sc, TX_SYSCONTROL_REG, TX_SYSCONTROL_RESET_DIS, 0);
1741 AQ_WRITE_REG_BIT(sc, FW_MPI_RESETCTRL_REG,
1742 FW_MPI_RESETCTRL_RESET_DIS, 0);
1743
1744 v = AQ_READ_REG(sc, AQ_FW_SOFTRESET_REG);
1745 v &= ~AQ_FW_SOFTRESET_DIS;
1746 v |= AQ_FW_SOFTRESET_RESET;
1747 AQ_WRITE_REG(sc, AQ_FW_SOFTRESET_REG, v);
1748 }
1749
1750 int
aq1_fw_read_version(struct aq_softc * sc)1751 aq1_fw_read_version(struct aq_softc *sc)
1752 {
1753 int i, error = EBUSY;
1754 #define MAC_FW_START_TIMEOUT_MS 10000
1755 for (i = 0; i < MAC_FW_START_TIMEOUT_MS; i++) {
1756 sc->sc_fw_version = AQ_READ_REG(sc, AQ_FW_VERSION_REG);
1757 if (sc->sc_fw_version != 0) {
1758 error = 0;
1759 break;
1760 }
1761 delay(1000);
1762 }
1763 return error;
1764 }
1765
1766 int
aq1_fw_version_init(struct aq_softc * sc)1767 aq1_fw_version_init(struct aq_softc *sc)
1768 {
1769 int error = 0;
1770 char fw_vers[sizeof("F/W version xxxxx.xxxxx.xxxxx")];
1771
1772 if (FW_VERSION_MAJOR(sc) == 1) {
1773 sc->sc_fw_ops = &aq_fw1x_ops;
1774 } else if ((FW_VERSION_MAJOR(sc) == 2) || (FW_VERSION_MAJOR(sc) == 3)) {
1775 sc->sc_fw_ops = &aq_fw2x_ops;
1776 } else {
1777 printf(": Unsupported F/W version %d.%d.%d\n",
1778 FW_VERSION_MAJOR(sc), FW_VERSION_MINOR(sc),
1779 FW_VERSION_BUILD(sc));
1780 return ENOTSUP;
1781 }
1782 snprintf(fw_vers, sizeof(fw_vers), "F/W version %d.%d.%d",
1783 FW_VERSION_MAJOR(sc), FW_VERSION_MINOR(sc), FW_VERSION_BUILD(sc));
1784
1785 /* detect revision */
1786 uint32_t hwrev = AQ_READ_REG(sc, AQ_HW_REVISION_REG);
1787 switch (hwrev & 0x0000000f) {
1788 case 0x01:
1789 printf(", Atlantic A0, %s", fw_vers);
1790 sc->sc_features |= FEATURES_AQ1_REV_A0 |
1791 FEATURES_MPI_AQ | FEATURES_MIPS;
1792 break;
1793 case 0x02:
1794 printf(", Atlantic B0, %s", fw_vers);
1795 sc->sc_features |= FEATURES_AQ1_REV_B0 |
1796 FEATURES_MPI_AQ | FEATURES_MIPS |
1797 FEATURES_TPO2 | FEATURES_RPF2;
1798 break;
1799 case 0x0A:
1800 printf(", Atlantic B1, %s", fw_vers);
1801 sc->sc_features |= FEATURES_AQ1_REV_B1 |
1802 FEATURES_MPI_AQ | FEATURES_MIPS |
1803 FEATURES_TPO2 | FEATURES_RPF2;
1804 break;
1805 default:
1806 printf(": Unknown revision (0x%08x)\n", hwrev);
1807 error = ENOTSUP;
1808 break;
1809 }
1810 return error;
1811 }
1812
1813 int
aq1_hw_init_ucp(struct aq_softc * sc)1814 aq1_hw_init_ucp(struct aq_softc *sc)
1815 {
1816 int timo;
1817
1818 if (FW_VERSION_MAJOR(sc) == 1) {
1819 if (AQ_READ_REG(sc, FW1X_MPI_INIT2_REG) == 0) {
1820 uint32_t data;
1821 arc4random_buf(&data, sizeof(data));
1822 data &= 0xfefefefe;
1823 data |= 0x02020202;
1824 AQ_WRITE_REG(sc, FW1X_MPI_INIT2_REG, data);
1825 }
1826 AQ_WRITE_REG(sc, FW1X_MPI_INIT1_REG, 0);
1827 }
1828
1829 for (timo = 100; timo > 0; timo--) {
1830 sc->sc_mbox_addr = AQ_READ_REG(sc, FW_MPI_MBOX_ADDR_REG);
1831 if (sc->sc_mbox_addr != 0)
1832 break;
1833 delay(1000);
1834 }
1835
1836 #define AQ_FW_MIN_VERSION 0x01050006
1837 #define AQ_FW_MIN_VERSION_STR "1.5.6"
1838 if (sc->sc_fw_version < AQ_FW_MIN_VERSION) {
1839 printf("%s: atlantic: wrong FW version: " AQ_FW_MIN_VERSION_STR
1840 " or later required, this is %d.%d.%d\n",
1841 DEVNAME(sc),
1842 FW_VERSION_MAJOR(sc),
1843 FW_VERSION_MINOR(sc),
1844 FW_VERSION_BUILD(sc));
1845 return ENOTSUP;
1846 }
1847
1848 if (sc->sc_mbox_addr == 0)
1849 printf("%s: NULL MBOX!!\n", DEVNAME(sc));
1850
1851 return 0;
1852 }
1853
1854 int
aq2_interface_buffer_read(struct aq_softc * sc,uint32_t reg0,uint32_t * data0,uint32_t size0)1855 aq2_interface_buffer_read(struct aq_softc *sc, uint32_t reg0, uint32_t *data0,
1856 uint32_t size0)
1857 {
1858 uint32_t tid0, tid1, reg, *data, size;
1859 int timo;
1860
1861 for (timo = 10000; timo > 0; timo--) {
1862 tid0 = AQ_READ_REG(sc, AQ2_FW_INTERFACE_OUT_TRANSACTION_ID_REG);
1863 if (((tid0 & AQ2_FW_INTERFACE_OUT_TRANSACTION_ID_A)
1864 >> AQ2_FW_INTERFACE_OUT_TRANSACTION_ID_A_S) !=
1865 ((tid0 & AQ2_FW_INTERFACE_OUT_TRANSACTION_ID_B)
1866 >> AQ2_FW_INTERFACE_OUT_TRANSACTION_ID_B_S)) {
1867 delay(10);
1868 continue;
1869 }
1870
1871 for (reg = reg0, data = data0, size = size0;
1872 size >= 4; reg += 4, data++, size -= 4) {
1873 *data = AQ_READ_REG(sc, reg);
1874 }
1875
1876 tid1 = AQ_READ_REG(sc, AQ2_FW_INTERFACE_OUT_TRANSACTION_ID_REG);
1877 if (tid0 == tid1)
1878 break;
1879 }
1880 if (timo == 0) {
1881 printf("%s: interface buffer read timeout\n", DEVNAME(sc));
1882 return ETIMEDOUT;
1883 }
1884 return 0;
1885 }
1886
1887 int
aq2_fw_reboot(struct aq_softc * sc)1888 aq2_fw_reboot(struct aq_softc *sc)
1889 {
1890 uint32_t v;
1891 int timo, err;
1892 char buf[32];
1893 uint32_t filter_caps[3];
1894
1895 sc->sc_fw_ops = &aq2_fw_ops;
1896 sc->sc_features = FEATURES_AQ2;
1897
1898 AQ_WRITE_REG(sc, AQ2_MCP_HOST_REQ_INT_CLR_REG, 1);
1899 AQ_WRITE_REG(sc, AQ2_MIF_BOOT_REG, 1); /* reboot request */
1900 for (timo = 200000; timo > 0; timo--) {
1901 v = AQ_READ_REG(sc, AQ2_MIF_BOOT_REG);
1902 if ((v & AQ2_MIF_BOOT_BOOT_STARTED) && v != 0xffffffff)
1903 break;
1904 delay(10);
1905 }
1906 if (timo <= 0) {
1907 printf(": FW reboot timeout\n");
1908 return ETIMEDOUT;
1909 }
1910
1911 for (timo = 2000000; timo > 0; timo--) {
1912 v = AQ_READ_REG(sc, AQ2_MIF_BOOT_REG);
1913 if ((v & AQ2_MIF_BOOT_FW_INIT_FAILED) ||
1914 (v & AQ2_MIF_BOOT_FW_INIT_COMP_SUCCESS))
1915 break;
1916 v = AQ_READ_REG(sc, AQ2_MCP_HOST_REQ_INT_REG);
1917 if (v & AQ2_MCP_HOST_REQ_INT_READY)
1918 break;
1919 delay(10);
1920 }
1921 if (timo <= 0) {
1922 printf(": FW restart timeout\n");
1923 return ETIMEDOUT;
1924 }
1925
1926 v = AQ_READ_REG(sc, AQ2_MIF_BOOT_REG);
1927 if (v & AQ2_MIF_BOOT_FW_INIT_FAILED) {
1928 printf(": FW restart failed\n");
1929 return ETIMEDOUT;
1930 }
1931
1932 v = AQ_READ_REG(sc, AQ2_MCP_HOST_REQ_INT_REG);
1933 if (v & AQ2_MCP_HOST_REQ_INT_READY) {
1934 printf(": firmware required\n");
1935 return ENXIO;
1936 }
1937
1938 /*
1939 * Get aq2 firmware version.
1940 * Note that the bit layout and its meaning are different from aq1.
1941 */
1942 err = aq2_interface_buffer_read(sc, AQ2_FW_INTERFACE_OUT_VERSION_BUNDLE_REG,
1943 (uint32_t *)&v, sizeof(v));
1944 if (err != 0)
1945 return err;
1946
1947 sc->sc_fw_version =
1948 (((v & AQ2_FW_INTERFACE_OUT_VERSION_MAJOR) >>
1949 AQ2_FW_INTERFACE_OUT_VERSION_MAJOR_S) << 24) |
1950 (((v & AQ2_FW_INTERFACE_OUT_VERSION_MINOR) >>
1951 AQ2_FW_INTERFACE_OUT_VERSION_MINOR_S) << 16) |
1952 (((v & AQ2_FW_INTERFACE_OUT_VERSION_BUILD) >>
1953 AQ2_FW_INTERFACE_OUT_VERSION_BUILD_S));
1954
1955 err = aq2_interface_buffer_read(sc, AQ2_FW_INTERFACE_OUT_VERSION_IFACE_REG,
1956 (uint32_t *)&v, sizeof(v));
1957 if (err != 0)
1958 return err;
1959
1960 switch (v & AQ2_FW_INTERFACE_OUT_VERSION_IFACE_VER) {
1961 case AQ2_FW_INTERFACE_OUT_VERSION_IFACE_VER_A0:
1962 sc->sc_features |= FEATURES_AQ2_IFACE_A0;
1963 strncpy(buf, "A0", sizeof(buf));
1964 break;
1965 case AQ2_FW_INTERFACE_OUT_VERSION_IFACE_VER_B0:
1966 sc->sc_features |= FEATURES_AQ2_IFACE_B0;
1967 strncpy(buf, "B0", sizeof(buf));
1968 break;
1969 default:
1970 snprintf(buf, sizeof(buf), "(unknown 0x%08x)", v);
1971 break;
1972 }
1973 printf(", Atlantic2 %s, F/W version %d.%d.%d", buf,
1974 FW_VERSION_MAJOR(sc), FW_VERSION_MINOR(sc), FW_VERSION_BUILD(sc));
1975
1976 aq2_interface_buffer_read(sc, AQ2_FW_INTERFACE_OUT_FILTER_CAPS_REG,
1977 filter_caps, sizeof(filter_caps));
1978 sc->sc_art_filter_base_index = ((filter_caps[2] &
1979 AQ2_FW_INTERFACE_OUT_FILTER_CAPS3_RESOLVER_BASE_INDEX) >>
1980 AQ2_FW_INTERFACE_OUT_FILTER_CAPS3_RESOLVER_BASE_INDEX_SHIFT) * 8;
1981
1982 /* debug info */
1983 v = AQ_READ_REG(sc, AQ_HW_REVISION_REG);
1984 DPRINTF(("%s: HW Rev: 0x%08x\n", DEVNAME(sc), v));
1985
1986 return 0;
1987 }
1988
1989 int
aq_hw_reset(struct aq_softc * sc)1990 aq_hw_reset(struct aq_softc *sc)
1991 {
1992 int error;
1993
1994 /* disable irq */
1995 AQ_WRITE_REG_BIT(sc, AQ_INTR_CTRL_REG, AQ_INTR_CTRL_RESET_DIS, 0);
1996
1997 /* apply */
1998 AQ_WRITE_REG_BIT(sc, AQ_INTR_CTRL_REG, AQ_INTR_CTRL_RESET_IRQ, 1);
1999
2000 /* wait ack 10 times by 1ms */
2001 WAIT_FOR(
2002 (AQ_READ_REG(sc, AQ_INTR_CTRL_REG) & AQ_INTR_CTRL_RESET_IRQ) == 0,
2003 1000, 10, &error);
2004 if (error != 0) {
2005 printf(": IRQ reset failed: %d\n", error);
2006 return error;
2007 }
2008
2009 return sc->sc_fw_ops->reset(sc);
2010 }
2011
2012 int
aq1_get_mac_addr(struct aq_softc * sc)2013 aq1_get_mac_addr(struct aq_softc *sc)
2014 {
2015 uint32_t mac_addr[2];
2016 uint32_t efuse_shadow_addr;
2017 int err;
2018
2019 efuse_shadow_addr = 0;
2020 if (FW_VERSION_MAJOR(sc) >= 2)
2021 efuse_shadow_addr = AQ_READ_REG(sc, FW2X_MPI_EFUSEADDR_REG);
2022 else
2023 efuse_shadow_addr = AQ_READ_REG(sc, FW1X_MPI_EFUSEADDR_REG);
2024
2025 if (efuse_shadow_addr == 0) {
2026 printf(": cannot get efuse addr\n");
2027 return ENXIO;
2028 }
2029
2030 DPRINTF(("%s: efuse_shadow_addr = %x\n", DEVNAME(sc), efuse_shadow_addr));
2031
2032 memset(mac_addr, 0, sizeof(mac_addr));
2033 err = aq1_fw_downld_dwords(sc, efuse_shadow_addr + (40 * 4),
2034 mac_addr, 2);
2035 if (err < 0)
2036 return err;
2037
2038 if (mac_addr[0] == 0 && mac_addr[1] == 0) {
2039 printf(": mac address not found\n");
2040 return ENXIO;
2041 }
2042
2043 DPRINTF(("%s: mac0 %x mac1 %x\n", DEVNAME(sc), mac_addr[0],
2044 mac_addr[1]));
2045
2046 mac_addr[0] = htobe32(mac_addr[0]);
2047 mac_addr[1] = htobe32(mac_addr[1]);
2048
2049 DPRINTF(("%s: mac0 %x mac1 %x\n", DEVNAME(sc), mac_addr[0],
2050 mac_addr[1]));
2051
2052 memcpy(sc->sc_enaddr.ether_addr_octet,
2053 (uint8_t *)mac_addr, ETHER_ADDR_LEN);
2054
2055 return 0;
2056 }
2057
2058 int
aq_activate(struct device * self,int act)2059 aq_activate(struct device *self, int act)
2060 {
2061 return 0;
2062 }
2063
2064 int
aq1_fw_downld_dwords(struct aq_softc * sc,uint32_t addr,uint32_t * p,uint32_t cnt)2065 aq1_fw_downld_dwords(struct aq_softc *sc, uint32_t addr, uint32_t *p,
2066 uint32_t cnt)
2067 {
2068 uint32_t v;
2069 int error = 0;
2070
2071 WAIT_FOR(AQ_READ_REG(sc, AQ_FW_SEM_RAM_REG) == 1, 1, 10000, &error);
2072 if (error != 0) {
2073 AQ_WRITE_REG(sc, AQ_FW_SEM_RAM_REG, 1);
2074 v = AQ_READ_REG(sc, AQ_FW_SEM_RAM_REG);
2075 if (v == 0) {
2076 printf("%s: %s:%d: timeout\n",
2077 DEVNAME(sc), __func__, __LINE__);
2078 return ETIMEDOUT;
2079 }
2080 }
2081
2082 AQ_WRITE_REG(sc, AQ_FW_MBOX_ADDR_REG, addr);
2083
2084 error = 0;
2085 for (; cnt > 0 && error == 0; cnt--) {
2086 /* execute mailbox interface */
2087 AQ_WRITE_REG_BIT(sc, AQ_FW_MBOX_CMD_REG,
2088 AQ_FW_MBOX_CMD_EXECUTE, 1);
2089 if (sc->sc_features & FEATURES_AQ1_REV_B1) {
2090 WAIT_FOR(AQ_READ_REG(sc, AQ_FW_MBOX_ADDR_REG) != addr,
2091 1, 1000, &error);
2092 } else {
2093 WAIT_FOR((AQ_READ_REG(sc, AQ_FW_MBOX_CMD_REG) &
2094 AQ_FW_MBOX_CMD_BUSY) == 0,
2095 1, 1000, &error);
2096 }
2097 *p++ = AQ_READ_REG(sc, AQ_FW_MBOX_VAL_REG);
2098 addr += sizeof(uint32_t);
2099 }
2100 AQ_WRITE_REG(sc, AQ_FW_SEM_RAM_REG, 1);
2101
2102 if (error != 0)
2103 printf("%s: %s:%d: timeout\n",
2104 DEVNAME(sc), __func__, __LINE__);
2105
2106 return error;
2107 }
2108
2109 int
aq_fw2x_reset(struct aq_softc * sc)2110 aq_fw2x_reset(struct aq_softc *sc)
2111 {
2112 struct aq_fw2x_capabilities caps = { 0 };
2113 int error;
2114
2115 error = aq1_fw_downld_dwords(sc,
2116 sc->sc_mbox_addr + offsetof(struct aq_fw2x_mailbox, caps),
2117 (uint32_t *)&caps, sizeof caps / sizeof(uint32_t));
2118 if (error != 0) {
2119 printf("%s: fw2x> can't get F/W capabilities mask, error %d\n",
2120 DEVNAME(sc), error);
2121 return error;
2122 }
2123 sc->sc_fw_caps = caps.caps_lo | ((uint64_t)caps.caps_hi << 32);
2124
2125 DPRINTF(("%s: fw2x> F/W capabilities=0x%llx\n", DEVNAME(sc),
2126 sc->sc_fw_caps));
2127
2128 return 0;
2129 }
2130
2131 int
aq_fw1x_reset(struct aq_softc * sc)2132 aq_fw1x_reset(struct aq_softc *sc)
2133 {
2134 printf("%s: unimplemented %s\n", DEVNAME(sc), __func__);
2135 return 0;
2136 }
2137
2138 int
aq_fw1x_set_mode(struct aq_softc * sc,enum aq_hw_fw_mpi_state w,enum aq_link_speed x,enum aq_link_fc y,enum aq_link_eee z)2139 aq_fw1x_set_mode(struct aq_softc *sc, enum aq_hw_fw_mpi_state w,
2140 enum aq_link_speed x, enum aq_link_fc y, enum aq_link_eee z)
2141 {
2142 return 0;
2143 }
2144
2145 int
aq_fw1x_get_mode(struct aq_softc * sc,enum aq_hw_fw_mpi_state * w,enum aq_link_speed * x,enum aq_link_fc * y,enum aq_link_eee * z)2146 aq_fw1x_get_mode(struct aq_softc *sc, enum aq_hw_fw_mpi_state *w,
2147 enum aq_link_speed *x, enum aq_link_fc *y, enum aq_link_eee *z)
2148 {
2149 return 0;
2150 }
2151
2152 int
aq_fw1x_get_stats(struct aq_softc * sc,struct aq_hw_stats_s * w)2153 aq_fw1x_get_stats(struct aq_softc *sc, struct aq_hw_stats_s *w)
2154 {
2155 return 0;
2156 }
2157
2158
2159 int
aq_fw2x_get_mode(struct aq_softc * sc,enum aq_hw_fw_mpi_state * modep,enum aq_link_speed * speedp,enum aq_link_fc * fcp,enum aq_link_eee * eeep)2160 aq_fw2x_get_mode(struct aq_softc *sc, enum aq_hw_fw_mpi_state *modep,
2161 enum aq_link_speed *speedp, enum aq_link_fc *fcp, enum aq_link_eee *eeep)
2162 {
2163 uint64_t mpi_state, mpi_ctrl;
2164 enum aq_link_speed speed;
2165 enum aq_link_fc fc;
2166
2167 AQ_MPI_LOCK(sc);
2168
2169 mpi_state = AQ_READ64_REG(sc, FW2X_MPI_STATE_REG);
2170 if (modep != NULL) {
2171 mpi_ctrl = AQ_READ64_REG(sc, FW2X_MPI_CONTROL_REG);
2172 if (mpi_ctrl & FW2X_CTRL_RATE_MASK)
2173 *modep = MPI_INIT;
2174 else
2175 *modep = MPI_DEINIT;
2176 }
2177
2178 AQ_MPI_UNLOCK(sc);
2179
2180 if (mpi_state & FW2X_CTRL_RATE_10G)
2181 speed = AQ_LINK_10G;
2182 else if (mpi_state & FW2X_CTRL_RATE_5G)
2183 speed = AQ_LINK_5G;
2184 else if (mpi_state & FW2X_CTRL_RATE_2G5)
2185 speed = AQ_LINK_2G5;
2186 else if (mpi_state & FW2X_CTRL_RATE_1G)
2187 speed = AQ_LINK_1G;
2188 else if (mpi_state & FW2X_CTRL_RATE_100M)
2189 speed = AQ_LINK_100M;
2190 else
2191 speed = AQ_LINK_NONE;
2192 if (speedp != NULL)
2193 *speedp = speed;
2194
2195 fc = AQ_FC_NONE;
2196 if (mpi_state & FW2X_CTRL_PAUSE)
2197 fc |= AQ_FC_RX;
2198 if (mpi_state & FW2X_CTRL_ASYMMETRIC_PAUSE)
2199 fc |= AQ_FC_TX;
2200 if (fcp != NULL)
2201 *fcp = fc;
2202
2203 if (eeep != NULL)
2204 *eeep = AQ_EEE_DISABLE;
2205
2206 return 0;
2207 }
2208
2209 int
aq_fw2x_get_stats(struct aq_softc * sc,struct aq_hw_stats_s * w)2210 aq_fw2x_get_stats(struct aq_softc *sc, struct aq_hw_stats_s *w)
2211 {
2212 return 0;
2213 }
2214
2215 static int
aq2_fw_wait_shared_ack(struct aq_softc * sc)2216 aq2_fw_wait_shared_ack(struct aq_softc *sc)
2217 {
2218 int error;
2219
2220 AQ_WRITE_REG(sc, AQ2_MIF_HOST_FINISHED_STATUS_WRITE_REG,
2221 AQ2_MIF_HOST_FINISHED_STATUS_ACK);
2222 WAIT_FOR((AQ_READ_REG(sc, AQ2_MIF_HOST_FINISHED_STATUS_READ_REG) &
2223 AQ2_MIF_HOST_FINISHED_STATUS_ACK) == 0, 100, 100000, &error);
2224
2225 return error;
2226 }
2227
2228 int
aq2_fw_reset(struct aq_softc * sc)2229 aq2_fw_reset(struct aq_softc *sc)
2230 {
2231 uint32_t v;
2232 int error;
2233
2234 AQ_WRITE_REG_BIT(sc, AQ2_FW_INTERFACE_IN_LINK_CONTROL_REG,
2235 AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE,
2236 AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE_ACTIVE);
2237
2238 AQ_WRITE_REG(sc, AQ2_FW_INTERFACE_IN_MTU_REG,
2239 /*AQ2_JUMBO_MTU*/ MCLBYTES + sizeof(struct ether_header));
2240
2241 v = AQ_READ_REG(sc, AQ2_FW_INTERFACE_IN_REQUEST_POLICY_REG);
2242 v |= AQ2_FW_INTERFACE_IN_REQUEST_POLICY_MCAST_QUEUE_OR_TC;
2243 v &= ~AQ2_FW_INTERFACE_IN_REQUEST_POLICY_MCAST_RX_QUEUE_TC_INDEX;
2244 v |= AQ2_FW_INTERFACE_IN_REQUEST_POLICY_MCAST_ACCEPT;
2245 v |= AQ2_FW_INTERFACE_IN_REQUEST_POLICY_BCAST_QUEUE_OR_TC;
2246 v &= AQ2_FW_INTERFACE_IN_REQUEST_POLICY_BCAST_RX_QUEUE_TC_INDEX;
2247 v |= AQ2_FW_INTERFACE_IN_REQUEST_POLICY_BCAST_ACCEPT;
2248 v |= AQ2_FW_INTERFACE_IN_REQUEST_POLICY_PROMISC_QUEUE_OR_TC;
2249 v &= ~AQ2_FW_INTERFACE_IN_REQUEST_POLICY_PROMISC_RX_QUEUE_TX_INDEX;
2250 AQ_WRITE_REG(sc, AQ2_FW_INTERFACE_IN_REQUEST_POLICY_REG, v);
2251
2252 error = aq2_fw_wait_shared_ack(sc);
2253 if (error != 0)
2254 printf(": reset timed out\n");
2255 return error;
2256 }
2257
2258 int
aq2_get_mac_addr(struct aq_softc * sc)2259 aq2_get_mac_addr(struct aq_softc *sc)
2260 {
2261 uint32_t mac_addr[2];
2262
2263 memset(mac_addr, 0, sizeof(mac_addr));
2264 AQ_READ_REGS(sc, AQ2_FW_INTERFACE_IN_MAC_ADDRESS_REG,
2265 mac_addr, nitems(mac_addr));
2266
2267 #ifdef __HAVE_FDT
2268 if (mac_addr[0] == 0 && mac_addr[1] == 0 &&
2269 PCITAG_NODE(sc->sc_pcitag)) {
2270 OF_getprop(PCITAG_NODE(sc->sc_pcitag), "local-mac-address",
2271 mac_addr, ETHER_ADDR_LEN);
2272 }
2273 #endif
2274
2275 if (mac_addr[0] == 0 && mac_addr[1] == 0) {
2276 printf(": mac address not found\n");
2277 return ENXIO;
2278 }
2279
2280 mac_addr[0] = htole32(mac_addr[0]);
2281 mac_addr[1] = htole32(mac_addr[1]);
2282
2283 memcpy(sc->sc_enaddr.ether_addr_octet,
2284 (uint8_t *)mac_addr, ETHER_ADDR_LEN);
2285 return 0;
2286 }
2287
2288 int
aq2_fw_set_mode(struct aq_softc * sc,enum aq_hw_fw_mpi_state w,enum aq_link_speed speed,enum aq_link_fc fc,enum aq_link_eee eee)2289 aq2_fw_set_mode(struct aq_softc *sc, enum aq_hw_fw_mpi_state w,
2290 enum aq_link_speed speed, enum aq_link_fc fc, enum aq_link_eee eee)
2291 {
2292 uint32_t v, ov;
2293 int error;
2294
2295 AQ_MPI_LOCK(sc);
2296
2297 v = AQ_READ_REG(sc, AQ2_FW_INTERFACE_IN_LINK_OPTIONS_REG);
2298 v &= ~(
2299 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_10G |
2300 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_N5G |
2301 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_5G |
2302 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_N2G5 |
2303 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_2G5 |
2304 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_1G |
2305 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_100M |
2306 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_10M |
2307 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_1G_HD |
2308 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_100M_HD |
2309 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_10M_HD);
2310
2311 v &= ~AQ2_FW_INTERFACE_IN_LINK_OPTIONS_LINK_UP;
2312 ov = v;
2313
2314 if (speed & AQ_LINK_10G)
2315 v |= AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_10G;
2316 if (speed & AQ_LINK_5G)
2317 v |= AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_N5G |
2318 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_5G;
2319 if (speed & AQ_LINK_2G5)
2320 v |= AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_N2G5 |
2321 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_2G5;
2322 if (speed & AQ_LINK_1G)
2323 v |= AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_1G |
2324 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_1G_HD;
2325 if (speed & AQ_LINK_100M)
2326 v |= AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_100M |
2327 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_100M_HD;
2328 if (speed & AQ_LINK_10M) {
2329 v |= AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_10M |
2330 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_RATE_10M_HD;
2331 }
2332
2333 /* flow control */
2334 v &= ~(AQ2_FW_INTERFACE_IN_LINK_OPTIONS_PAUSE_TX |
2335 AQ2_FW_INTERFACE_IN_LINK_OPTIONS_PAUSE_RX);
2336 if (fc & AQ_FC_TX)
2337 v |= AQ2_FW_INTERFACE_IN_LINK_OPTIONS_PAUSE_TX;
2338 if (fc & AQ_FC_RX)
2339 v |= AQ2_FW_INTERFACE_IN_LINK_OPTIONS_PAUSE_RX;
2340
2341 if (speed == AQ_LINK_NONE) {
2342 AQ_WRITE_REG_BIT(sc, AQ2_FW_INTERFACE_IN_LINK_CONTROL_REG,
2343 AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE,
2344 AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE_SHUTDOWN);
2345 } else {
2346 AQ_WRITE_REG_BIT(sc, AQ2_FW_INTERFACE_IN_LINK_CONTROL_REG,
2347 AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE,
2348 AQ2_FW_INTERFACE_IN_LINK_CONTROL_MODE_ACTIVE);
2349 v |= AQ2_FW_INTERFACE_IN_LINK_OPTIONS_LINK_UP;
2350 }
2351
2352 AQ_WRITE_REG(sc, AQ2_FW_INTERFACE_IN_LINK_OPTIONS_REG, v);
2353 error = aq2_fw_wait_shared_ack(sc);
2354
2355 AQ_MPI_UNLOCK(sc);
2356 return error;
2357 }
2358
2359 int
aq2_fw_get_mode(struct aq_softc * sc,enum aq_hw_fw_mpi_state * modep,enum aq_link_speed * speedp,enum aq_link_fc * fcp,enum aq_link_eee * eeep)2360 aq2_fw_get_mode(struct aq_softc *sc, enum aq_hw_fw_mpi_state *modep,
2361 enum aq_link_speed *speedp, enum aq_link_fc *fcp, enum aq_link_eee *eeep)
2362 {
2363 uint32_t v;
2364 enum aq_link_speed speed;
2365 enum aq_link_fc fc = 0;
2366 enum aq_link_eee eee;
2367
2368 if (modep != NULL)
2369 *modep = MPI_INIT;
2370
2371 v = AQ_READ_REG(sc, AQ2_FW_INTERFACE_OUT_LINK_STATUS_REG);
2372 switch ((v & AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE) >>
2373 AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_S) {
2374 case AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_10G:
2375 speed = AQ_LINK_10G;
2376 break;
2377 case AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_5G:
2378 speed = AQ_LINK_5G;
2379 break;
2380 case AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_2G5:
2381 speed = AQ_LINK_2G5;
2382 break;
2383 case AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_1G:
2384 speed = AQ_LINK_1G;
2385 break;
2386 case AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_100M:
2387 speed = AQ_LINK_100M;
2388 break;
2389 case AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_10M:
2390 speed = AQ_LINK_10M;
2391 break;
2392 case AQ2_FW_INTERFACE_OUT_LINK_STATUS_RATE_INVALID:
2393 default:
2394 speed = AQ_LINK_NONE;
2395 break;
2396 }
2397 if (speedp != NULL)
2398 *speedp = speed;
2399
2400 if (v & AQ2_FW_INTERFACE_OUT_LINK_STATUS_PAUSE_TX)
2401 fc |= AQ_FC_TX;
2402 if (v & AQ2_FW_INTERFACE_OUT_LINK_STATUS_PAUSE_RX)
2403 fc |= AQ_FC_RX;
2404 if (fcp != NULL)
2405 *fcp = fc;
2406
2407 eee = (v & AQ2_FW_INTERFACE_OUT_LINK_STATUS_EEE) ?
2408 AQ_EEE_ENABLE : AQ_EEE_DISABLE;
2409 if (eeep != NULL)
2410 *eeep = eee;
2411
2412 return 0;
2413 }
2414
2415 int
aq2_fw_get_stats(struct aq_softc * sc,struct aq_hw_stats_s * w)2416 aq2_fw_get_stats(struct aq_softc *sc, struct aq_hw_stats_s *w)
2417 {
2418 return 0;
2419 }
2420
2421 void
aq_hw_l3_filter_set(struct aq_softc * sc)2422 aq_hw_l3_filter_set(struct aq_softc *sc)
2423 {
2424 int i;
2425
2426 /* clear all filter */
2427 for (i = 0; i < 8; i++) {
2428 AQ_WRITE_REG_BIT(sc, RPF_L3_FILTER_REG(i),
2429 RPF_L3_FILTER_L4_EN, 0);
2430 }
2431 }
2432
2433 int
aq_hw_init(struct aq_softc * sc,int irqmode,int multivec)2434 aq_hw_init(struct aq_softc *sc, int irqmode, int multivec)
2435 {
2436 uint32_t v;
2437
2438 if (HWTYPE_AQ1_P(sc)) {
2439 /* Force limit MRRS on RDM/TDM to 2K */
2440 v = AQ_READ_REG(sc, AQ_PCI_REG_CONTROL_6_REG);
2441 AQ_WRITE_REG(sc, AQ_PCI_REG_CONTROL_6_REG,
2442 (v & ~0x0707) | 0x0404);
2443
2444 /*
2445 * TX DMA total request limit. B0 hardware is not capable to
2446 * handle more than (8K-MRRS) incoming DMA data.
2447 * Value 24 in 256byte units
2448 */
2449 AQ_WRITE_REG(sc, AQ_HW_TX_DMA_TOTAL_REQ_LIMIT_REG, 24);
2450 }
2451
2452 if (HWTYPE_AQ2_P(sc)) {
2453 uint32_t fpgaver, speed;
2454 fpgaver = AQ_READ_REG(sc, AQ2_HW_FPGA_VERSION_REG);
2455 if (fpgaver < 0x01000000)
2456 speed = AQ2_LAUNCHTIME_CTRL_RATIO_SPEED_FULL;
2457 else if (fpgaver >= 0x01008502)
2458 speed = AQ2_LAUNCHTIME_CTRL_RATIO_SPEED_HALF;
2459 else
2460 speed = AQ2_LAUNCHTIME_CTRL_RATIO_SPEED_QUARTER;
2461 AQ_WRITE_REG_BIT(sc, AQ2_LAUNCHTIME_CTRL_REG,
2462 AQ2_LAUNCHTIME_CTRL_RATIO, speed);
2463 }
2464
2465 aq_hw_init_tx_path(sc);
2466 aq_hw_init_rx_path(sc);
2467
2468 if (aq_set_mac_addr(sc, AQ_HW_MAC_OWN, sc->sc_enaddr.ether_addr_octet))
2469 return EINVAL;
2470
2471 aq_set_linkmode(sc, AQ_LINK_NONE, AQ_FC_NONE, AQ_EEE_DISABLE);
2472
2473 aq_hw_qos_set(sc);
2474
2475 if (HWTYPE_AQ2_P(sc)) {
2476 AQ_WRITE_REG_BIT(sc, AQ2_RPF_NEW_CTRL_REG,
2477 AQ2_RPF_NEW_CTRL_ENABLE, 1);
2478 }
2479
2480 /* Enable interrupt */
2481 AQ_WRITE_REG(sc, AQ_INTR_CTRL_REG, AQ_INTR_CTRL_RESET_DIS);
2482 AQ_WRITE_REG_BIT(sc, AQ_INTR_CTRL_REG, AQ_INTR_CTRL_MULTIVEC, multivec);
2483
2484 AQ_WRITE_REG_BIT(sc, AQ_INTR_CTRL_REG, AQ_INTR_CTRL_IRQMODE, irqmode);
2485
2486 AQ_WRITE_REG(sc, AQ_INTR_AUTOMASK_REG, 0xffffffff);
2487
2488 AQ_WRITE_REG(sc, AQ_GEN_INTR_MAP_REG(0),
2489 ((AQ_B0_ERR_INT << 24) | (1U << 31)) |
2490 ((AQ_B0_ERR_INT << 16) | (1 << 23))
2491 );
2492
2493 /* link interrupt */
2494 AQ_WRITE_REG(sc, AQ_GEN_INTR_MAP_REG(3),
2495 (1 << 7) | sc->sc_linkstat_irq);
2496
2497 return 0;
2498 }
2499
2500 void
aq_hw_init_tx_path(struct aq_softc * sc)2501 aq_hw_init_tx_path(struct aq_softc *sc)
2502 {
2503 /* Tx TC/RSS number config */
2504 AQ_WRITE_REG_BIT(sc, TPB_TX_BUF_REG, TPB_TX_BUF_TC_MODE_EN, 1);
2505
2506 AQ_WRITE_REG_BIT(sc, THM_LSO_TCP_FLAG1_REG,
2507 THM_LSO_TCP_FLAG1_FIRST, 0x0ff6);
2508 AQ_WRITE_REG_BIT(sc, THM_LSO_TCP_FLAG1_REG,
2509 THM_LSO_TCP_FLAG1_MID, 0x0ff6);
2510 AQ_WRITE_REG_BIT(sc, THM_LSO_TCP_FLAG2_REG,
2511 THM_LSO_TCP_FLAG2_LAST, 0x0f7f);
2512
2513 /* misc */
2514 AQ_WRITE_REG(sc, TX_TPO2_REG,
2515 (sc->sc_features & FEATURES_TPO2) ? TX_TPO2_EN : 0);
2516 AQ_WRITE_REG_BIT(sc, TDM_DCA_REG, TDM_DCA_EN, 0);
2517 AQ_WRITE_REG_BIT(sc, TDM_DCA_REG, TDM_DCA_MODE, 0);
2518
2519 AQ_WRITE_REG_BIT(sc, TPB_TX_BUF_REG, TPB_TX_BUF_SCP_INS_EN, 1);
2520
2521 if ((sc->sc_features & FEATURES_AQ1_REV_B) || HWTYPE_AQ2_P(sc)) {
2522 AQ_WRITE_REG_BIT(sc, TPB_TX_BUF_REG, TPB_TX_BUF_CLK_GATE_EN, 0);
2523 }
2524 }
2525
2526 void
aq_hw_init_rx_path(struct aq_softc * sc)2527 aq_hw_init_rx_path(struct aq_softc *sc)
2528 {
2529 int i;
2530
2531 /* clear setting */
2532 AQ_WRITE_REG_BIT(sc, RPB_RPF_RX_REG, RPB_RPF_RX_TC_MODE, 0);
2533 AQ_WRITE_REG_BIT(sc, RPB_RPF_RX_REG, RPB_RPF_RX_FC_MODE, 0);
2534
2535 if (HWTYPE_AQ2_P(sc)) {
2536 AQ_WRITE_REG_BIT(sc, AQ2_RPF_REDIR2_REG,
2537 AQ2_RPF_REDIR2_HASHTYPE, AQ2_RPF_REDIR2_HASHTYPE_ALL);
2538 }
2539
2540 if (sc->sc_nqueues > 1) {
2541 uint32_t bits;
2542
2543 AQ_WRITE_REG_BIT(sc, RPB_RPF_RX_REG, RPB_RPF_RX_TC_MODE, 1);
2544 AQ_WRITE_REG_BIT(sc, RPB_RPF_RX_REG, RPB_RPF_RX_FC_MODE, 1);
2545
2546 switch (sc->sc_nqueues) {
2547 case 2:
2548 bits = 0x11111111;
2549 break;
2550 case 4:
2551 bits = 0x22222222;
2552 break;
2553 case 8:
2554 bits = 0x33333333;
2555 break;
2556 }
2557
2558 AQ_WRITE_REG(sc, RX_FLR_RSS_CONTROL1_REG,
2559 RX_FLR_RSS_CONTROL1_EN | bits);
2560 } else {
2561 AQ_WRITE_REG(sc, RX_FLR_RSS_CONTROL1_REG, 0);
2562 }
2563
2564 if (HWTYPE_AQ1_P(sc)) {
2565 for (i = 0; i < 32; i++) {
2566 AQ_WRITE_REG_BIT(sc, RPF_ETHERTYPE_FILTER_REG(i),
2567 RPF_ETHERTYPE_FILTER_EN, 0);
2568 }
2569 }
2570
2571 /* L2 and Multicast filters */
2572 for (i = 0; i < AQ_HW_MAC_NUM; i++) {
2573 AQ_WRITE_REG_BIT(sc, RPF_L2UC_MSW_REG(i), RPF_L2UC_MSW_EN, 0);
2574 AQ_WRITE_REG_BIT(sc, RPF_L2UC_MSW_REG(i), RPF_L2UC_MSW_ACTION,
2575 RPF_ACTION_HOST);
2576 }
2577 AQ_WRITE_REG(sc, RPF_MCAST_FILTER_MASK_REG, 0);
2578 AQ_WRITE_REG(sc, RPF_MCAST_FILTER_REG(0), 0x00010fff);
2579
2580 /* Vlan filters */
2581 AQ_WRITE_REG_BIT(sc, RPF_VLAN_TPID_REG, RPF_VLAN_TPID_OUTER,
2582 ETHERTYPE_QINQ);
2583 AQ_WRITE_REG_BIT(sc, RPF_VLAN_TPID_REG, RPF_VLAN_TPID_INNER,
2584 ETHERTYPE_VLAN);
2585 AQ_WRITE_REG_BIT(sc, RPF_VLAN_MODE_REG, RPF_VLAN_MODE_PROMISC, 1);
2586
2587 if ((sc->sc_features & FEATURES_AQ1_REV_B) || HWTYPE_AQ2_P(sc)) {
2588 AQ_WRITE_REG_BIT(sc, RPF_VLAN_MODE_REG,
2589 RPF_VLAN_MODE_ACCEPT_UNTAGGED, 1);
2590 AQ_WRITE_REG_BIT(sc, RPF_VLAN_MODE_REG,
2591 RPF_VLAN_MODE_UNTAGGED_ACTION, RPF_ACTION_HOST);
2592 }
2593
2594 if (HWTYPE_AQ2_P(sc)) {
2595 AQ_WRITE_REG_BIT(sc, AQ2_RPF_REC_TAB_ENABLE_REG,
2596 AQ2_RPF_REC_TAB_ENABLE_MASK, 0xffff);
2597 AQ_WRITE_REG_BIT(sc, RPF_L2UC_MSW_REG(0),
2598 RPF_L2UC_MSW_TAG, 1);
2599 AQ_WRITE_REG_BIT(sc, AQ2_RPF_L2BC_TAG_REG,
2600 AQ2_RPF_L2BC_TAG_MASK, 1);
2601
2602 aq2_filter_art_set(sc, AQ2_RPF_INDEX_L2_PROMISC_OFF,
2603 0, AQ2_RPF_TAG_UC_MASK | AQ2_RPF_TAG_ALLMC_MASK,
2604 AQ2_ART_ACTION_DROP);
2605 aq2_filter_art_set(sc, AQ2_RPF_INDEX_VLAN_PROMISC_OFF,
2606 0, AQ2_RPF_TAG_VLAN_MASK | AQ2_RPF_TAG_UNTAG_MASK,
2607 AQ2_ART_ACTION_DROP);
2608
2609 for (i = 0; i < 8; i++) {
2610 aq2_filter_art_set(sc, AQ2_RPF_INDEX_PCP_TO_TC + i,
2611 (i << AQ2_RPF_TAG_PCP_SHIFT), AQ2_RPF_TAG_PCP_MASK,
2612 AQ2_ART_ACTION_ASSIGN_TC(i % sc->sc_nqueues));
2613 }
2614
2615 } else if (HWTYPE_AQ1_P(sc)) {
2616 if (sc->sc_features & FEATURES_RPF2)
2617 AQ_WRITE_REG(sc, RX_TCP_RSS_HASH_REG,
2618 RX_TCP_RSS_HASH_RPF2);
2619 else
2620 AQ_WRITE_REG(sc, RX_TCP_RSS_HASH_REG, 0);
2621
2622 /* we might want to figure out what this magic number does */
2623 AQ_WRITE_REG_BIT(sc, RX_TCP_RSS_HASH_REG,
2624 RX_TCP_RSS_HASH_TYPE, 0x001e);
2625 }
2626
2627 AQ_WRITE_REG_BIT(sc, RPF_L2BC_REG, RPF_L2BC_EN, 1);
2628 AQ_WRITE_REG_BIT(sc, RPF_L2BC_REG, RPF_L2BC_ACTION, RPF_ACTION_HOST);
2629 AQ_WRITE_REG_BIT(sc, RPF_L2BC_REG, RPF_L2BC_THRESHOLD, 0xffff);
2630
2631 AQ_WRITE_REG_BIT(sc, RX_DMA_DCA_REG, RX_DMA_DCA_EN, 0);
2632 AQ_WRITE_REG_BIT(sc, RX_DMA_DCA_REG, RX_DMA_DCA_MODE, 0);
2633 }
2634
2635 /* set multicast filter. index 0 for own address */
2636 int
aq_set_mac_addr(struct aq_softc * sc,int index,uint8_t * enaddr)2637 aq_set_mac_addr(struct aq_softc *sc, int index, uint8_t *enaddr)
2638 {
2639 uint32_t h, l;
2640
2641 if (index >= AQ_HW_MAC_NUM)
2642 return EINVAL;
2643
2644 if (enaddr == NULL) {
2645 /* disable */
2646 AQ_WRITE_REG_BIT(sc,
2647 RPF_L2UC_MSW_REG(index), RPF_L2UC_MSW_EN, 0);
2648 return 0;
2649 }
2650
2651 h = (enaddr[0] << 8) | (enaddr[1]);
2652 l = ((uint32_t)enaddr[2] << 24) | (enaddr[3] << 16) |
2653 (enaddr[4] << 8) | (enaddr[5]);
2654
2655 /* disable, set, and enable */
2656 AQ_WRITE_REG_BIT(sc, RPF_L2UC_MSW_REG(index), RPF_L2UC_MSW_EN, 0);
2657 AQ_WRITE_REG(sc, RPF_L2UC_LSW_REG(index), l);
2658 AQ_WRITE_REG_BIT(sc, RPF_L2UC_MSW_REG(index),
2659 RPF_L2UC_MSW_MACADDR_HI, h);
2660 AQ_WRITE_REG_BIT(sc, RPF_L2UC_MSW_REG(index),
2661 RPF_L2UC_MSW_ACTION, RPF_ACTION_HOST);
2662 if (HWTYPE_AQ2_P(sc))
2663 AQ_WRITE_REG_BIT(sc, RPF_L2UC_MSW_REG(index),
2664 RPF_L2UC_MSW_TAG, 1);
2665 AQ_WRITE_REG_BIT(sc, RPF_L2UC_MSW_REG(index), RPF_L2UC_MSW_EN, 1);
2666
2667 return 0;
2668 }
2669
2670 int
aq_get_linkmode(struct aq_softc * sc,enum aq_link_speed * speed,enum aq_link_fc * fc,enum aq_link_eee * eee)2671 aq_get_linkmode(struct aq_softc *sc, enum aq_link_speed *speed,
2672 enum aq_link_fc *fc, enum aq_link_eee *eee)
2673 {
2674 enum aq_hw_fw_mpi_state mode;
2675 int error;
2676
2677 error = sc->sc_fw_ops->get_mode(sc, &mode, speed, fc, eee);
2678 if (error != 0)
2679 return error;
2680 if (mode != MPI_INIT)
2681 return ENXIO;
2682
2683 return 0;
2684 }
2685
2686 int
aq_set_linkmode(struct aq_softc * sc,enum aq_link_speed speed,enum aq_link_fc fc,enum aq_link_eee eee)2687 aq_set_linkmode(struct aq_softc *sc, enum aq_link_speed speed,
2688 enum aq_link_fc fc, enum aq_link_eee eee)
2689 {
2690 return sc->sc_fw_ops->set_mode(sc, MPI_INIT, speed, fc, eee);
2691 }
2692
2693 int
aq_fw2x_set_mode(struct aq_softc * sc,enum aq_hw_fw_mpi_state mode,enum aq_link_speed speed,enum aq_link_fc fc,enum aq_link_eee eee)2694 aq_fw2x_set_mode(struct aq_softc *sc, enum aq_hw_fw_mpi_state mode,
2695 enum aq_link_speed speed, enum aq_link_fc fc, enum aq_link_eee eee)
2696 {
2697 uint64_t mpi_ctrl;
2698 int error = 0;
2699
2700 AQ_MPI_LOCK(sc);
2701
2702 mpi_ctrl = AQ_READ64_REG(sc, FW2X_MPI_CONTROL_REG);
2703
2704 switch (mode) {
2705 case MPI_INIT:
2706 mpi_ctrl &= ~FW2X_CTRL_RATE_MASK;
2707 if (speed & AQ_LINK_10G)
2708 mpi_ctrl |= FW2X_CTRL_RATE_10G;
2709 if (speed & AQ_LINK_5G)
2710 mpi_ctrl |= FW2X_CTRL_RATE_5G;
2711 if (speed & AQ_LINK_2G5)
2712 mpi_ctrl |= FW2X_CTRL_RATE_2G5;
2713 if (speed & AQ_LINK_1G)
2714 mpi_ctrl |= FW2X_CTRL_RATE_1G;
2715 if (speed & AQ_LINK_100M)
2716 mpi_ctrl |= FW2X_CTRL_RATE_100M;
2717
2718 mpi_ctrl &= ~FW2X_CTRL_LINK_DROP;
2719
2720 mpi_ctrl &= ~FW2X_CTRL_EEE_MASK;
2721 if (eee == AQ_EEE_ENABLE)
2722 mpi_ctrl |= FW2X_CTRL_EEE_MASK;
2723
2724 mpi_ctrl &= ~(FW2X_CTRL_PAUSE | FW2X_CTRL_ASYMMETRIC_PAUSE);
2725 if (fc & AQ_FC_RX)
2726 mpi_ctrl |= FW2X_CTRL_PAUSE;
2727 if (fc & AQ_FC_TX)
2728 mpi_ctrl |= FW2X_CTRL_ASYMMETRIC_PAUSE;
2729 break;
2730 case MPI_DEINIT:
2731 mpi_ctrl &= ~(FW2X_CTRL_RATE_MASK | FW2X_CTRL_EEE_MASK);
2732 mpi_ctrl &= ~(FW2X_CTRL_PAUSE | FW2X_CTRL_ASYMMETRIC_PAUSE);
2733 break;
2734 default:
2735 printf("%s: fw2x> unknown MPI state %d\n", DEVNAME(sc), mode);
2736 error = EINVAL;
2737 goto failure;
2738 }
2739 AQ_WRITE64_REG(sc, FW2X_MPI_CONTROL_REG, mpi_ctrl);
2740
2741 failure:
2742 AQ_MPI_UNLOCK(sc);
2743 return error;
2744 }
2745
2746 void
aq_hw_qos_set(struct aq_softc * sc)2747 aq_hw_qos_set(struct aq_softc *sc)
2748 {
2749 uint32_t tc = 0;
2750 uint32_t buff_size;
2751
2752 /* TPS Descriptor rate init */
2753 AQ_WRITE_REG_BIT(sc, TPS_DESC_RATE_REG, TPS_DESC_RATE_TA_RST, 0);
2754 AQ_WRITE_REG_BIT(sc, TPS_DESC_RATE_REG, TPS_DESC_RATE_LIM, 0xa);
2755
2756 /* TPS VM init */
2757 AQ_WRITE_REG_BIT(sc, TPS_DESC_VM_ARB_MODE_REG, TPS_DESC_VM_ARB_MODE, 0);
2758
2759 /* TPS TC credits init */
2760 AQ_WRITE_REG_BIT(sc, TPS_DESC_TC_ARB_MODE_REG, TPS_DESC_TC_ARB_MODE, 0);
2761 AQ_WRITE_REG_BIT(sc, TPS_DATA_TC_ARB_MODE_REG, TPS_DATA_TC_ARB_MODE, 0);
2762
2763 if (HWTYPE_AQ2_P(sc)) {
2764 AQ_WRITE_REG_BIT(sc, TPS_DATA_TCT_REG(tc),
2765 TPS2_DATA_TCT_CREDIT_MAX, 0xfff0);
2766 AQ_WRITE_REG_BIT(sc, TPS_DATA_TCT_REG(tc),
2767 TPS2_DATA_TCT_WEIGHT, 0x640);
2768 } else {
2769 AQ_WRITE_REG_BIT(sc, TPS_DATA_TCT_REG(tc),
2770 TPS_DATA_TCT_CREDIT_MAX, 0xfff);
2771 AQ_WRITE_REG_BIT(sc, TPS_DATA_TCT_REG(tc),
2772 TPS_DATA_TCT_WEIGHT, 0x64);
2773 }
2774 AQ_WRITE_REG_BIT(sc, TPS_DESC_TCT_REG(tc),
2775 TPS_DESC_TCT_CREDIT_MAX, 0x50);
2776 AQ_WRITE_REG_BIT(sc, TPS_DESC_TCT_REG(tc),
2777 TPS_DESC_TCT_WEIGHT, 0x1e);
2778
2779 /* Tx buf size */
2780 tc = 0;
2781 buff_size = HWTYPE_AQ2_P(sc) ? AQ2_HW_TXBUF_MAX : AQ_HW_TXBUF_MAX;
2782 AQ_WRITE_REG_BIT(sc, TPB_TXB_BUFSIZE_REG(tc), TPB_TXB_BUFSIZE,
2783 buff_size);
2784 AQ_WRITE_REG_BIT(sc, TPB_TXB_THRESH_REG(tc), TPB_TXB_THRESH_HI,
2785 (buff_size * (1024 / 32) * 66) / 100);
2786 AQ_WRITE_REG_BIT(sc, TPB_TXB_THRESH_REG(tc), TPB_TXB_THRESH_LO,
2787 (buff_size * (1024 / 32) * 50) / 100);
2788
2789 /* QoS Rx buf size per TC */
2790 tc = 0;
2791 buff_size = HWTYPE_AQ2_P(sc) ? AQ2_HW_RXBUF_MAX : AQ_HW_RXBUF_MAX;
2792 AQ_WRITE_REG_BIT(sc, RPB_RXB_BUFSIZE_REG(tc), RPB_RXB_BUFSIZE,
2793 buff_size);
2794 AQ_WRITE_REG_BIT(sc, RPB_RXB_XOFF_REG(tc), RPB_RXB_XOFF_EN, 0);
2795 AQ_WRITE_REG_BIT(sc, RPB_RXB_XOFF_REG(tc), RPB_RXB_XOFF_THRESH_HI,
2796 (buff_size * (1024 / 32) * 66) / 100);
2797 AQ_WRITE_REG_BIT(sc, RPB_RXB_XOFF_REG(tc), RPB_RXB_XOFF_THRESH_LO,
2798 (buff_size * (1024 / 32) * 50) / 100);
2799
2800 /* QoS 802.1p priority -> TC mapping */
2801 int i_priority;
2802 for (i_priority = 0; i_priority < 8; i_priority++) {
2803 AQ_WRITE_REG_BIT(sc, RPF_RPB_RX_TC_UPT_REG,
2804 RPF_RPB_RX_TC_UPT_MASK(i_priority), 0);
2805 }
2806 }
2807
2808 int
aq_init_rss(struct aq_softc * sc)2809 aq_init_rss(struct aq_softc *sc)
2810 {
2811 uint32_t rss_key[AQ_RSS_KEYSIZE / sizeof(uint32_t)];
2812 uint32_t redir;
2813 int bits, queue;
2814 int error;
2815 int i;
2816
2817 if (sc->sc_nqueues == 1)
2818 return 0;
2819
2820 /* rss key is composed of 32 bit registers */
2821 stoeplitz_to_key(rss_key, sizeof(rss_key));
2822 for (i = 0; i < nitems(rss_key); i++) {
2823 AQ_WRITE_REG(sc, RPF_RSS_KEY_WR_DATA_REG, htole32(rss_key[i]));
2824 AQ_WRITE_REG_BIT(sc, RPF_RSS_KEY_ADDR_REG, RPF_RSS_KEY_ADDR,
2825 nitems(rss_key) - 1 - i);
2826 AQ_WRITE_REG_BIT(sc, RPF_RSS_KEY_ADDR_REG, RPF_RSS_KEY_WR_EN,
2827 1);
2828 WAIT_FOR((AQ_READ_REG(sc, RPF_RSS_KEY_ADDR_REG) &
2829 RPF_RSS_KEY_WR_EN) == 0, 1000, 10, &error);
2830 if (error != 0) {
2831 printf(": timed out setting rss key\n");
2832 return error;
2833 }
2834 }
2835
2836 /*
2837 * the redirection table has 64 entries, each entry is a 3 bit
2838 * queue number, packed into a 16 bit register, so there are 12
2839 * registers to program.
2840 */
2841 bits = 0;
2842 redir = 0;
2843 queue = 0;
2844 for (i = 0; i < AQ_RSS_REDIR_ENTRIES; i++) {
2845 while (bits < 16) {
2846 redir |= (queue << bits);
2847 bits += 3;
2848 queue++;
2849 if (queue == sc->sc_nqueues)
2850 queue = 0;
2851 }
2852
2853 AQ_WRITE_REG(sc, RPF_RSS_REDIR_WR_DATA_REG, htole16(redir));
2854 AQ_WRITE_REG_BIT(sc, RPF_RSS_REDIR_ADDR_REG, RPF_RSS_REDIR_ADDR,
2855 i);
2856 AQ_WRITE_REG_BIT(sc, RPF_RSS_REDIR_ADDR_REG,
2857 RPF_RSS_REDIR_WR_EN, 1);
2858 WAIT_FOR((AQ_READ_REG(sc, RPF_RSS_REDIR_ADDR_REG) &
2859 RPF_RSS_REDIR_WR_EN) == 0, 1000, 10, &error);
2860 if (error != 0) {
2861 printf(": timed out setting rss table\n");
2862 return error;
2863 }
2864 redir >>= 16;
2865 bits -= 16;
2866 }
2867
2868 return 0;
2869 }
2870
2871 void
aq_txring_reset(struct aq_softc * sc,struct aq_txring * tx,int start)2872 aq_txring_reset(struct aq_softc *sc, struct aq_txring *tx, int start)
2873 {
2874 daddr_t paddr;
2875
2876 tx->tx_prod = 0;
2877 tx->tx_cons = 0;
2878
2879 /* empty slots? */
2880
2881 AQ_WRITE_REG_BIT(sc, TX_DMA_DESC_REG(tx->tx_q), TX_DMA_DESC_EN, 0);
2882
2883 if (start == 0)
2884 return;
2885
2886 paddr = AQ_DMA_DVA(&tx->tx_mem);
2887 AQ_WRITE_REG(sc, TX_DMA_DESC_BASE_ADDRLSW_REG(tx->tx_q), paddr);
2888 AQ_WRITE_REG(sc, TX_DMA_DESC_BASE_ADDRMSW_REG(tx->tx_q),
2889 paddr >> 32);
2890
2891 AQ_WRITE_REG_BIT(sc, TX_DMA_DESC_REG(tx->tx_q), TX_DMA_DESC_LEN,
2892 AQ_TXD_NUM / 8);
2893
2894 tx->tx_prod = AQ_READ_REG(sc, TX_DMA_DESC_TAIL_PTR_REG(tx->tx_q));
2895 tx->tx_cons = tx->tx_prod;
2896 AQ_WRITE_REG(sc, TX_DMA_DESC_WRWB_THRESH_REG(tx->tx_q), 0);
2897
2898 AQ_WRITE_REG_BIT(sc, AQ_INTR_IRQ_MAP_TX_REG(tx->tx_q),
2899 AQ_INTR_IRQ_MAP_TX_IRQMAP(tx->tx_q), tx->tx_irq);
2900 AQ_WRITE_REG_BIT(sc, AQ_INTR_IRQ_MAP_TX_REG(tx->tx_q),
2901 AQ_INTR_IRQ_MAP_TX_EN(tx->tx_q), 1);
2902
2903 AQ_WRITE_REG_BIT(sc, TX_DMA_DESC_REG(tx->tx_q), TX_DMA_DESC_EN, 1);
2904
2905 AQ_WRITE_REG_BIT(sc, TDM_DCAD_REG(tx->tx_q), TDM_DCAD_CPUID, 0);
2906 AQ_WRITE_REG_BIT(sc, TDM_DCAD_REG(tx->tx_q), TDM_DCAD_CPUID_EN, 0);
2907 }
2908
2909 void
aq_rxring_reset(struct aq_softc * sc,struct aq_rxring * rx,int start)2910 aq_rxring_reset(struct aq_softc *sc, struct aq_rxring *rx, int start)
2911 {
2912 daddr_t paddr;
2913 int strip;
2914
2915 AQ_WRITE_REG_BIT(sc, RX_DMA_DESC_REG(rx->rx_q), RX_DMA_DESC_EN, 0);
2916 /* drain */
2917
2918 if (start == 0)
2919 return;
2920
2921 paddr = AQ_DMA_DVA(&rx->rx_mem);
2922 AQ_WRITE_REG(sc, RX_DMA_DESC_BASE_ADDRLSW_REG(rx->rx_q), paddr);
2923 AQ_WRITE_REG(sc, RX_DMA_DESC_BASE_ADDRMSW_REG(rx->rx_q),
2924 paddr >> 32);
2925
2926 AQ_WRITE_REG_BIT(sc, RX_DMA_DESC_REG(rx->rx_q), RX_DMA_DESC_LEN,
2927 AQ_RXD_NUM / 8);
2928
2929 AQ_WRITE_REG_BIT(sc, RX_DMA_DESC_BUFSIZE_REG(rx->rx_q),
2930 RX_DMA_DESC_BUFSIZE_DATA, MCLBYTES / 1024);
2931 AQ_WRITE_REG_BIT(sc, RX_DMA_DESC_BUFSIZE_REG(rx->rx_q),
2932 RX_DMA_DESC_BUFSIZE_HDR, 0);
2933 AQ_WRITE_REG_BIT(sc, RX_DMA_DESC_REG(rx->rx_q),
2934 RX_DMA_DESC_HEADER_SPLIT, 0);
2935
2936 #if NVLAN > 0
2937 strip = 1;
2938 #else
2939 strip = 0;
2940 #endif
2941 AQ_WRITE_REG_BIT(sc, RX_DMA_DESC_REG(rx->rx_q),
2942 RX_DMA_DESC_VLAN_STRIP, strip);
2943
2944 rx->rx_cons = AQ_READ_REG(sc, RX_DMA_DESC_HEAD_PTR_REG(rx->rx_q)) &
2945 RX_DMA_DESC_HEAD_PTR;
2946 AQ_WRITE_REG(sc, RX_DMA_DESC_TAIL_PTR_REG(rx->rx_q), rx->rx_cons);
2947 rx->rx_prod = rx->rx_cons;
2948
2949 AQ_WRITE_REG_BIT(sc, AQ_INTR_IRQ_MAP_RX_REG(rx->rx_q),
2950 AQ_INTR_IRQ_MAP_RX_IRQMAP(rx->rx_q), rx->rx_irq);
2951 AQ_WRITE_REG_BIT(sc, AQ_INTR_IRQ_MAP_RX_REG(rx->rx_q),
2952 AQ_INTR_IRQ_MAP_RX_EN(rx->rx_q), 1);
2953
2954 AQ_WRITE_REG_BIT(sc, RX_DMA_DCAD_REG(rx->rx_q),
2955 RX_DMA_DCAD_CPUID, 0);
2956 AQ_WRITE_REG_BIT(sc, RX_DMA_DCAD_REG(rx->rx_q),
2957 RX_DMA_DCAD_DESC_EN, 0);
2958 AQ_WRITE_REG_BIT(sc, RX_DMA_DCAD_REG(rx->rx_q),
2959 RX_DMA_DCAD_HEADER_EN, 0);
2960 AQ_WRITE_REG_BIT(sc, RX_DMA_DCAD_REG(rx->rx_q),
2961 RX_DMA_DCAD_PAYLOAD_EN, 0);
2962
2963 AQ_WRITE_REG_BIT(sc, RX_DMA_DESC_REG(rx->rx_q), RX_DMA_DESC_EN, 1);
2964 }
2965
2966 static inline unsigned int
aq_rx_fill_slots(struct aq_softc * sc,struct aq_rxring * rx,uint nslots)2967 aq_rx_fill_slots(struct aq_softc *sc, struct aq_rxring *rx, uint nslots)
2968 {
2969 struct aq_rx_desc_read *ring, *rd;
2970 struct aq_slot *as;
2971 struct mbuf *m;
2972 uint p, fills;
2973
2974 ring = AQ_DMA_KVA(&rx->rx_mem);
2975 p = rx->rx_prod;
2976
2977 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&rx->rx_mem), 0,
2978 AQ_DMA_LEN(&rx->rx_mem), BUS_DMASYNC_POSTWRITE);
2979
2980 for (fills = 0; fills < nslots; fills++) {
2981 as = &rx->rx_slots[p];
2982 rd = &ring[p];
2983
2984 m = MCLGETL(NULL, M_DONTWAIT, MCLBYTES + ETHER_ALIGN);
2985 if (m == NULL)
2986 break;
2987
2988 m->m_data += (m->m_ext.ext_size - (MCLBYTES + ETHER_ALIGN));
2989 m->m_data += ETHER_ALIGN;
2990 m->m_len = m->m_pkthdr.len = MCLBYTES;
2991
2992 if (bus_dmamap_load_mbuf(sc->sc_dmat, as->as_map, m,
2993 BUS_DMA_NOWAIT) != 0) {
2994 m_freem(m);
2995 break;
2996 }
2997 as->as_m = m;
2998
2999 bus_dmamap_sync(sc->sc_dmat, as->as_map, 0,
3000 as->as_map->dm_mapsize, BUS_DMASYNC_PREREAD);
3001 htolem64(&rd->buf_addr, as->as_map->dm_segs[0].ds_addr);
3002 rd->hdr_addr = 0;
3003 p++;
3004 if (p == AQ_RXD_NUM)
3005 p = 0;
3006 }
3007
3008 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&rx->rx_mem), 0,
3009 AQ_DMA_LEN(&rx->rx_mem), BUS_DMASYNC_PREWRITE);
3010
3011 rx->rx_prod = p;
3012 AQ_WRITE_REG(sc, RX_DMA_DESC_TAIL_PTR_REG(rx->rx_q), rx->rx_prod);
3013 return (nslots - fills);
3014 }
3015
3016 int
aq_rx_fill(struct aq_softc * sc,struct aq_rxring * rx)3017 aq_rx_fill(struct aq_softc *sc, struct aq_rxring *rx)
3018 {
3019 u_int slots;
3020
3021 slots = if_rxr_get(&rx->rx_rxr, AQ_RXD_NUM);
3022 if (slots == 0)
3023 return 1;
3024
3025 slots = aq_rx_fill_slots(sc, rx, slots);
3026 if_rxr_put(&rx->rx_rxr, slots);
3027 return 0;
3028 }
3029
3030 void
aq_refill(void * xq)3031 aq_refill(void *xq)
3032 {
3033 struct aq_queues *q = xq;
3034 struct aq_softc *sc = q->q_sc;
3035
3036 aq_rx_fill(sc, &q->q_rx);
3037
3038 if (if_rxr_inuse(&q->q_rx.rx_rxr) == 0)
3039 timeout_add(&q->q_rx.rx_refill, 1);
3040 }
3041
3042 void
aq_rxeof(struct aq_softc * sc,struct aq_rxring * rx)3043 aq_rxeof(struct aq_softc *sc, struct aq_rxring *rx)
3044 {
3045 struct ifnet *ifp = &sc->sc_arpcom.ac_if;
3046 struct aq_rx_desc_wb *rxd;
3047 struct aq_rx_desc_wb *ring;
3048 struct aq_slot *as;
3049 uint32_t end, idx;
3050 uint16_t pktlen, status;
3051 uint32_t rxd_type;
3052 struct mbuf *m, *mb;
3053 struct mbuf_list ml = MBUF_LIST_INITIALIZER();
3054 int rxfree;
3055
3056 if (!ISSET(ifp->if_flags, IFF_RUNNING))
3057 return;
3058
3059 end = AQ_READ_REG(sc, RX_DMA_DESC_HEAD_PTR_REG(rx->rx_q)) &
3060 RX_DMA_DESC_HEAD_PTR;
3061
3062 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&rx->rx_mem), 0,
3063 AQ_DMA_LEN(&rx->rx_mem), BUS_DMASYNC_POSTREAD);
3064
3065 rxfree = 0;
3066 idx = rx->rx_cons;
3067 ring = AQ_DMA_KVA(&rx->rx_mem);
3068 while (idx != end) {
3069 rxd = &ring[idx];
3070 as = &rx->rx_slots[idx];
3071
3072 bus_dmamap_sync(sc->sc_dmat, as->as_map, 0,
3073 as->as_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
3074 bus_dmamap_unload(sc->sc_dmat, as->as_map);
3075
3076 status = lemtoh16(&rxd->status);
3077 if ((status & AQ_RXDESC_STATUS_DD) == 0)
3078 break;
3079
3080 rxfree++;
3081 mb = as->as_m;
3082 as->as_m = NULL;
3083
3084 pktlen = lemtoh16(&rxd->pkt_len);
3085 rxd_type = lemtoh32(&rxd->type);
3086 if ((rxd_type & AQ_RXDESC_TYPE_RSSTYPE) != 0) {
3087 mb->m_pkthdr.ph_flowid = lemtoh32(&rxd->rss_hash);
3088 mb->m_pkthdr.csum_flags |= M_FLOWID;
3089 }
3090
3091 mb->m_pkthdr.len = 0;
3092 mb->m_next = NULL;
3093 *rx->rx_m_tail = mb;
3094 rx->rx_m_tail = &mb->m_next;
3095
3096 m = rx->rx_m_head;
3097
3098 #if NVLAN > 0
3099 if (rxd_type & (AQ_RXDESC_TYPE_VLAN | AQ_RXDESC_TYPE_VLAN2)) {
3100 m->m_pkthdr.ether_vtag = lemtoh16(&rxd->vlan);
3101 m->m_flags |= M_VLANTAG;
3102 }
3103 #endif
3104
3105 if ((rxd_type & AQ_RXDESC_TYPE_V4_SUM) &&
3106 ((status & AQ_RXDESC_STATUS_V4_SUM_NG) == 0))
3107 m->m_pkthdr.csum_flags |= M_IPV4_CSUM_IN_OK;
3108
3109 if ((rxd_type & AQ_RXDESC_TYPE_L4_SUM) &&
3110 (status & AQ_RXDESC_STATUS_L4_SUM_OK))
3111 m->m_pkthdr.csum_flags |= M_UDP_CSUM_IN_OK |
3112 M_TCP_CSUM_IN_OK;
3113
3114 if ((status & AQ_RXDESC_STATUS_MACERR) ||
3115 (rxd_type & AQ_RXDESC_TYPE_DMA_ERR)) {
3116 printf("%s:rx: rx error (status %x type %x)\n",
3117 DEVNAME(sc), status, rxd_type);
3118 rx->rx_m_error = 1;
3119 }
3120
3121 if (status & AQ_RXDESC_STATUS_EOP) {
3122 mb->m_len = pktlen - m->m_pkthdr.len;
3123 m->m_pkthdr.len = pktlen;
3124 if (rx->rx_m_error != 0) {
3125 ifp->if_ierrors++;
3126 m_freem(m);
3127 } else {
3128 ml_enqueue(&ml, m);
3129 }
3130
3131 rx->rx_m_head = NULL;
3132 rx->rx_m_tail = &rx->rx_m_head;
3133 rx->rx_m_error = 0;
3134 } else {
3135 mb->m_len = MCLBYTES;
3136 m->m_pkthdr.len += mb->m_len;
3137 }
3138
3139 idx++;
3140 if (idx == AQ_RXD_NUM)
3141 idx = 0;
3142 }
3143
3144 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&rx->rx_mem), 0,
3145 AQ_DMA_LEN(&rx->rx_mem), BUS_DMASYNC_PREREAD);
3146
3147 rx->rx_cons = idx;
3148
3149 if (rxfree > 0) {
3150 if_rxr_put(&rx->rx_rxr, rxfree);
3151 if (ifiq_input(rx->rx_ifiq, &ml))
3152 if_rxr_livelocked(&rx->rx_rxr);
3153
3154 aq_rx_fill(sc, rx);
3155 if (if_rxr_inuse(&rx->rx_rxr) == 0)
3156 timeout_add(&rx->rx_refill, 1);
3157 }
3158 }
3159
3160 void
aq_txeof(struct aq_softc * sc,struct aq_txring * tx)3161 aq_txeof(struct aq_softc *sc, struct aq_txring *tx)
3162 {
3163 struct ifnet *ifp = &sc->sc_arpcom.ac_if;
3164 struct aq_slot *as;
3165 uint32_t idx, end, free;
3166
3167 if (!ISSET(ifp->if_flags, IFF_RUNNING))
3168 return;
3169
3170 idx = tx->tx_cons;
3171 end = AQ_READ_REG(sc, TX_DMA_DESC_HEAD_PTR_REG(tx->tx_q)) &
3172 TX_DMA_DESC_HEAD_PTR;
3173 free = 0;
3174
3175 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&tx->tx_mem), 0,
3176 AQ_DMA_LEN(&tx->tx_mem), BUS_DMASYNC_POSTREAD);
3177
3178 while (idx != end) {
3179 as = &tx->tx_slots[idx];
3180
3181 if (as->as_m != NULL) {
3182 bus_dmamap_sync(sc->sc_dmat, as->as_map, 0,
3183 as->as_map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
3184 bus_dmamap_unload(sc->sc_dmat, as->as_map);
3185
3186 m_freem(as->as_m);
3187 as->as_m = NULL;
3188 }
3189
3190 idx++;
3191 if (idx == AQ_TXD_NUM)
3192 idx = 0;
3193 free++;
3194 }
3195
3196 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&tx->tx_mem), 0,
3197 AQ_DMA_LEN(&tx->tx_mem), BUS_DMASYNC_PREREAD);
3198
3199 tx->tx_cons = idx;
3200
3201 if (free != 0) {
3202 if (ifq_is_oactive(tx->tx_ifq))
3203 ifq_restart(tx->tx_ifq);
3204 }
3205 }
3206
3207 void
aq_start(struct ifqueue * ifq)3208 aq_start(struct ifqueue *ifq)
3209 {
3210 struct aq_queues *aq = ifq->ifq_softc;
3211 struct aq_softc *sc = aq->q_sc;
3212 struct aq_txring *tx = &aq->q_tx;
3213 struct aq_tx_desc *ring, *txd;
3214 struct aq_slot *as;
3215 struct mbuf *m;
3216 uint32_t idx, free, used, ctl1, ctl2;
3217 int error, i;
3218
3219 idx = tx->tx_prod;
3220 free = tx->tx_cons + AQ_TXD_NUM - tx->tx_prod;
3221 used = 0;
3222
3223 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&tx->tx_mem), 0,
3224 AQ_DMA_LEN(&tx->tx_mem), BUS_DMASYNC_POSTWRITE);
3225 ring = (struct aq_tx_desc *)AQ_DMA_KVA(&tx->tx_mem);
3226
3227 for (;;) {
3228 if (used + AQ_TX_MAX_SEGMENTS + 1 >= free) {
3229 ifq_set_oactive(ifq);
3230 break;
3231 }
3232
3233 m = ifq_dequeue(ifq);
3234 if (m == NULL)
3235 break;
3236
3237 as = &tx->tx_slots[idx];
3238
3239 error = bus_dmamap_load_mbuf(sc->sc_dmat, as->as_map, m,
3240 BUS_DMA_STREAMING | BUS_DMA_NOWAIT);
3241 if (error == EFBIG) {
3242 if (m_defrag(m, M_DONTWAIT)) {
3243 m_freem(m);
3244 break;
3245 }
3246
3247 error = bus_dmamap_load_mbuf(sc->sc_dmat, as->as_map,
3248 m, BUS_DMA_STREAMING | BUS_DMA_NOWAIT);
3249 }
3250 if (error != 0) {
3251 m_freem(m);
3252 break;
3253 }
3254
3255 as->as_m = m;
3256
3257 #if NBPFILTER > 0
3258 if (ifq->ifq_if->if_bpf)
3259 bpf_mtap_ether(ifq->ifq_if->if_bpf, m, BPF_DIRECTION_OUT);
3260 #endif
3261 bus_dmamap_sync(sc->sc_dmat, as->as_map, 0,
3262 as->as_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
3263
3264 ctl2 = m->m_pkthdr.len << AQ_TXDESC_CTL2_LEN_SHIFT;
3265 ctl1 = AQ_TXDESC_CTL1_TYPE_TXD | AQ_TXDESC_CTL1_CMD_FCS;
3266 #if NVLAN > 0
3267 if (m->m_flags & M_VLANTAG) {
3268 txd = ring + idx;
3269 txd->buf_addr = 0;
3270 txd->ctl1 = htole32(AQ_TXDESC_CTL1_TYPE_TXC |
3271 (m->m_pkthdr.ether_vtag << AQ_TXDESC_CTL1_VLAN_SHIFT));
3272 txd->ctl2 = 0;
3273
3274 ctl1 |= AQ_TXDESC_CTL1_CMD_VLAN;
3275 ctl2 |= AQ_TXDESC_CTL2_CTX_EN;
3276
3277 idx++;
3278 if (idx == AQ_TXD_NUM)
3279 idx = 0;
3280 used++;
3281 }
3282 #endif
3283
3284 if (m->m_pkthdr.csum_flags & M_IPV4_CSUM_OUT)
3285 ctl1 |= AQ_TXDESC_CTL1_CMD_IP4CSUM;
3286 if (m->m_pkthdr.csum_flags & (M_TCP_CSUM_OUT | M_UDP_CSUM_OUT))
3287 ctl1 |= AQ_TXDESC_CTL1_CMD_L4CSUM;
3288
3289 for (i = 0; i < as->as_map->dm_nsegs; i++) {
3290
3291 if (i == as->as_map->dm_nsegs - 1)
3292 ctl1 |= AQ_TXDESC_CTL1_CMD_EOP |
3293 AQ_TXDESC_CTL1_CMD_WB;
3294
3295 txd = ring + idx;
3296 txd->buf_addr = htole64(as->as_map->dm_segs[i].ds_addr);
3297 txd->ctl1 = htole32(ctl1 |
3298 (as->as_map->dm_segs[i].ds_len <<
3299 AQ_TXDESC_CTL1_BLEN_SHIFT));
3300 txd->ctl2 = htole32(ctl2);
3301
3302 idx++;
3303 if (idx == AQ_TXD_NUM)
3304 idx = 0;
3305 used++;
3306 }
3307 }
3308
3309 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&tx->tx_mem), 0,
3310 AQ_DMA_LEN(&tx->tx_mem), BUS_DMASYNC_PREWRITE);
3311
3312 if (used != 0) {
3313 tx->tx_prod = idx;
3314 AQ_WRITE_REG(sc, TX_DMA_DESC_TAIL_PTR_REG(tx->tx_q),
3315 tx->tx_prod);
3316 }
3317 }
3318
3319 int
aq_intr_queue(void * arg)3320 aq_intr_queue(void *arg)
3321 {
3322 struct aq_queues *aq = arg;
3323 struct aq_softc *sc = aq->q_sc;
3324 uint32_t status;
3325 uint32_t clear;
3326
3327 status = AQ_READ_REG(sc, AQ_INTR_STATUS_REG);
3328 clear = 0;
3329 if (status & (1 << aq->q_tx.tx_irq)) {
3330 clear |= (1 << aq->q_tx.tx_irq);
3331 aq_txeof(sc, &aq->q_tx);
3332 }
3333
3334 if (status & (1 << aq->q_rx.rx_irq)) {
3335 clear |= (1 << aq->q_rx.rx_irq);
3336 aq_rxeof(sc, &aq->q_rx);
3337 }
3338
3339 AQ_WRITE_REG(sc, AQ_INTR_STATUS_CLR_REG, clear);
3340 return (clear != 0);
3341 }
3342
3343 int
aq_intr_link(void * arg)3344 aq_intr_link(void *arg)
3345 {
3346 struct aq_softc *sc = arg;
3347 uint32_t status;
3348
3349 status = AQ_READ_REG(sc, AQ_INTR_STATUS_REG);
3350 if (status & (1 << sc->sc_linkstat_irq)) {
3351 aq_update_link_status(sc);
3352 AQ_WRITE_REG(sc, AQ_INTR_STATUS_REG, (1 << sc->sc_linkstat_irq));
3353 return 1;
3354 }
3355
3356 return 0;
3357 }
3358
3359 int
aq_intr(void * arg)3360 aq_intr(void *arg)
3361 {
3362 struct aq_softc *sc = arg;
3363 struct aq_queues *aq = &sc->sc_queues[0];
3364 uint32_t status;
3365
3366 status = AQ_READ_REG(sc, AQ_INTR_STATUS_REG);
3367 AQ_WRITE_REG(sc, AQ_INTR_STATUS_CLR_REG, 0xffffffff);
3368
3369 if (status & (1 << sc->sc_linkstat_irq))
3370 aq_update_link_status(sc);
3371
3372 if (status & (1 << aq->q_tx.tx_irq)) {
3373 aq_txeof(sc, &aq->q_tx);
3374 AQ_WRITE_REG(sc, AQ_INTR_STATUS_CLR_REG,
3375 (1 << aq->q_tx.tx_irq));
3376 }
3377 if (status & (1 << aq->q_rx.rx_irq)) {
3378 aq_rxeof(sc, &aq->q_rx);
3379 AQ_WRITE_REG(sc, AQ_INTR_STATUS_CLR_REG,
3380 (1 << aq->q_rx.rx_irq));
3381 }
3382
3383 return 1;
3384 }
3385
3386 void
aq_watchdog(struct ifnet * ifp)3387 aq_watchdog(struct ifnet *ifp)
3388 {
3389
3390 }
3391
3392 void
aq_free_slots(struct aq_softc * sc,struct aq_slot * slots,int allocated,int total)3393 aq_free_slots(struct aq_softc *sc, struct aq_slot *slots, int allocated,
3394 int total)
3395 {
3396 struct aq_slot *as;
3397
3398 int i = allocated;
3399 while (i-- > 0) {
3400 as = &slots[i];
3401 bus_dmamap_destroy(sc->sc_dmat, as->as_map);
3402 if (as->as_m != NULL)
3403 m_freem(as->as_m);
3404 }
3405 free(slots, M_DEVBUF, total * sizeof(*as));
3406 }
3407
3408 int
aq_queue_up(struct aq_softc * sc,struct aq_queues * aq)3409 aq_queue_up(struct aq_softc *sc, struct aq_queues *aq)
3410 {
3411 struct aq_rxring *rx;
3412 struct aq_txring *tx;
3413 struct aq_slot *as;
3414 int i, mtu;
3415
3416 rx = &aq->q_rx;
3417 rx->rx_slots = mallocarray(sizeof(*as), AQ_RXD_NUM, M_DEVBUF,
3418 M_WAITOK | M_ZERO);
3419 if (rx->rx_slots == NULL) {
3420 printf("%s: failed to allocate rx slots %d\n", DEVNAME(sc),
3421 aq->q_index);
3422 return ENOMEM;
3423 }
3424
3425 for (i = 0; i < AQ_RXD_NUM; i++) {
3426 as = &rx->rx_slots[i];
3427 if (bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1, MCLBYTES, 0,
3428 BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW | BUS_DMA_64BIT,
3429 &as->as_map) != 0) {
3430 printf("%s: failed to allocate rx dma maps %d\n",
3431 DEVNAME(sc), aq->q_index);
3432 goto destroy_rx_slots;
3433 }
3434 }
3435
3436 if (aq_dmamem_alloc(sc, &rx->rx_mem, AQ_RXD_NUM *
3437 sizeof(struct aq_rx_desc_read), PAGE_SIZE) != 0) {
3438 printf("%s: unable to allocate rx ring %d\n", DEVNAME(sc),
3439 aq->q_index);
3440 goto destroy_rx_slots;
3441 }
3442
3443 tx = &aq->q_tx;
3444 tx->tx_slots = mallocarray(sizeof(*as), AQ_TXD_NUM, M_DEVBUF,
3445 M_WAITOK | M_ZERO);
3446 if (tx->tx_slots == NULL) {
3447 printf("%s: failed to allocate tx slots %d\n", DEVNAME(sc),
3448 aq->q_index);
3449 goto destroy_rx_ring;
3450 }
3451
3452 mtu = sc->sc_arpcom.ac_if.if_hardmtu;
3453 for (i = 0; i < AQ_TXD_NUM; i++) {
3454 as = &tx->tx_slots[i];
3455 if (bus_dmamap_create(sc->sc_dmat, mtu, AQ_TX_MAX_SEGMENTS,
3456 MCLBYTES, 0, BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW | BUS_DMA_64BIT,
3457 &as->as_map) != 0) {
3458 printf("%s: failed to allocated tx dma maps %d\n",
3459 DEVNAME(sc), aq->q_index);
3460 goto destroy_tx_slots;
3461 }
3462 }
3463
3464 if (aq_dmamem_alloc(sc, &tx->tx_mem, AQ_TXD_NUM *
3465 sizeof(struct aq_tx_desc), PAGE_SIZE) != 0) {
3466 printf("%s: unable to allocate tx ring %d\n", DEVNAME(sc),
3467 aq->q_index);
3468 goto destroy_tx_slots;
3469 }
3470
3471 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&tx->tx_mem),
3472 0, AQ_DMA_LEN(&tx->tx_mem),
3473 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
3474
3475 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&rx->rx_mem),
3476 0, AQ_DMA_LEN(&rx->rx_mem),
3477 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
3478
3479 aq_txring_reset(sc, tx, 1);
3480 aq_rxring_reset(sc, rx, 1);
3481 return 0;
3482
3483 destroy_tx_slots:
3484 aq_free_slots(sc, tx->tx_slots, i, AQ_TXD_NUM);
3485 tx->tx_slots = NULL;
3486 i = AQ_RXD_NUM;
3487
3488 destroy_rx_ring:
3489 aq_dmamem_free(sc, &rx->rx_mem);
3490 destroy_rx_slots:
3491 aq_free_slots(sc, rx->rx_slots, i, AQ_RXD_NUM);
3492 rx->rx_slots = NULL;
3493 return ENOMEM;
3494 }
3495
3496 void
aq_queue_down(struct aq_softc * sc,struct aq_queues * aq)3497 aq_queue_down(struct aq_softc *sc, struct aq_queues *aq)
3498 {
3499 struct aq_txring *tx;
3500 struct aq_rxring *rx;
3501
3502 tx = &aq->q_tx;
3503 aq_txring_reset(sc, &aq->q_tx, 0);
3504 if (tx->tx_slots != NULL) {
3505 aq_free_slots(sc, tx->tx_slots, AQ_TXD_NUM, AQ_TXD_NUM);
3506 tx->tx_slots = NULL;
3507 }
3508
3509 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&tx->tx_mem),
3510 0, AQ_DMA_LEN(&tx->tx_mem),
3511 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
3512
3513 aq_dmamem_free(sc, &tx->tx_mem);
3514
3515 rx = &aq->q_rx;
3516 m_freem(rx->rx_m_head);
3517 rx->rx_m_head = NULL;
3518 rx->rx_m_tail = &rx->rx_m_head;
3519 rx->rx_m_error = 0;
3520 aq_rxring_reset(sc, &aq->q_rx, 0);
3521 if (rx->rx_slots != NULL) {
3522 aq_free_slots(sc, rx->rx_slots, AQ_RXD_NUM, AQ_RXD_NUM);
3523 rx->rx_slots = NULL;
3524 }
3525
3526 bus_dmamap_sync(sc->sc_dmat, AQ_DMA_MAP(&rx->rx_mem),
3527 0, AQ_DMA_LEN(&rx->rx_mem),
3528 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
3529
3530 aq_dmamem_free(sc, &rx->rx_mem);
3531 }
3532
3533 void
aq_invalidate_rx_desc_cache(struct aq_softc * sc)3534 aq_invalidate_rx_desc_cache(struct aq_softc *sc)
3535 {
3536 uint32_t cache;
3537
3538 cache = AQ_READ_REG(sc, RX_DMA_DESC_CACHE_INIT_REG);
3539 AQ_WRITE_REG_BIT(sc, RX_DMA_DESC_CACHE_INIT_REG, RX_DMA_DESC_CACHE_INIT,
3540 (cache & RX_DMA_DESC_CACHE_INIT) ^ RX_DMA_DESC_CACHE_INIT);
3541 }
3542
3543 int
aq_up(struct aq_softc * sc)3544 aq_up(struct aq_softc *sc)
3545 {
3546 struct ifnet *ifp = &sc->sc_arpcom.ac_if;
3547 int i;
3548
3549 aq_invalidate_rx_desc_cache(sc);
3550
3551 for (i = 0; i < sc->sc_nqueues; i++) {
3552 if (aq_queue_up(sc, &sc->sc_queues[i]) != 0)
3553 goto downqueues;
3554 }
3555
3556 aq_set_mac_addr(sc, AQ_HW_MAC_OWN, sc->sc_arpcom.ac_enaddr);
3557
3558 AQ_WRITE_REG_BIT(sc, TPO_HWCSUM_REG, TPO_HWCSUM_IP4CSUM_EN, 1);
3559 AQ_WRITE_REG_BIT(sc, TPO_HWCSUM_REG, TPO_HWCSUM_L4CSUM_EN, 1);
3560
3561 AQ_WRITE_REG_BIT(sc, RPO_HWCSUM_REG, RPO_HWCSUM_IP4CSUM_EN, 1);
3562 AQ_WRITE_REG_BIT(sc, RPO_HWCSUM_REG, RPO_HWCSUM_L4CSUM_EN, 1);
3563
3564 SET(ifp->if_flags, IFF_RUNNING);
3565 aq_enable_intr(sc, 1, 1);
3566 AQ_WRITE_REG_BIT(sc, TPB_TX_BUF_REG, TPB_TX_BUF_EN, 1);
3567 AQ_WRITE_REG_BIT(sc, RPB_RPF_RX_REG, RPB_RPF_RX_BUF_EN, 1);
3568
3569 for (i = 0; i < sc->sc_nqueues; i++) {
3570 struct aq_queues *aq = &sc->sc_queues[i];
3571
3572 if_rxr_init(&aq->q_rx.rx_rxr, howmany(ifp->if_hardmtu, MCLBYTES),
3573 AQ_RXD_NUM - 1);
3574 aq_rx_fill(sc, &aq->q_rx);
3575
3576 ifq_clr_oactive(aq->q_tx.tx_ifq);
3577 }
3578
3579 return ENETRESET;
3580
3581 downqueues:
3582 for (i = 0; i < sc->sc_nqueues; i++)
3583 aq_queue_down(sc, &sc->sc_queues[i]);
3584 return ENOMEM;
3585 }
3586
3587 void
aq_down(struct aq_softc * sc)3588 aq_down(struct aq_softc *sc)
3589 {
3590 struct ifnet *ifp = &sc->sc_arpcom.ac_if;
3591 int i;
3592
3593 CLR(ifp->if_flags, IFF_RUNNING);
3594
3595 aq_enable_intr(sc, 1, 0);
3596 intr_barrier(sc->sc_ih);
3597
3598 AQ_WRITE_REG_BIT(sc, RPB_RPF_RX_REG, RPB_RPF_RX_BUF_EN, 0);
3599 for (i = 0; i < sc->sc_nqueues; i++) {
3600 /* queue intr barrier? */
3601 aq_queue_down(sc, &sc->sc_queues[i]);
3602 }
3603
3604 aq_invalidate_rx_desc_cache(sc);
3605 }
3606
3607 void
aq_enable_intr(struct aq_softc * sc,int link,int txrx)3608 aq_enable_intr(struct aq_softc *sc, int link, int txrx)
3609 {
3610 uint32_t imask = 0;
3611 int i;
3612
3613 if (txrx) {
3614 for (i = 0; i < sc->sc_nqueues; i++) {
3615 imask |= (1 << sc->sc_queues[i].q_tx.tx_irq);
3616 imask |= (1 << sc->sc_queues[i].q_rx.rx_irq);
3617 }
3618 }
3619
3620 if (link)
3621 imask |= (1 << sc->sc_linkstat_irq);
3622
3623 AQ_WRITE_REG(sc, AQ_INTR_MASK_REG, imask);
3624 AQ_WRITE_REG(sc, AQ_INTR_STATUS_CLR_REG, 0xffffffff);
3625 }
3626
3627 void
aq_ifmedia_status(struct ifnet * ifp,struct ifmediareq * ifmr)3628 aq_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr)
3629 {
3630 struct aq_softc *aq = ifp->if_softc;
3631 enum aq_link_speed speed;
3632 enum aq_link_fc fc;
3633 int media;
3634 int flow;
3635
3636 if (aq_get_linkmode(aq, &speed, &fc, NULL) != 0)
3637 return;
3638
3639 switch (speed) {
3640 case AQ_LINK_10G:
3641 media = IFM_10G_T;
3642 break;
3643 case AQ_LINK_5G:
3644 media = IFM_5000_T;
3645 break;
3646 case AQ_LINK_2G5:
3647 media = IFM_2500_T;
3648 break;
3649 case AQ_LINK_1G:
3650 media = IFM_1000_T;
3651 break;
3652 case AQ_LINK_100M:
3653 media = IFM_100_TX;
3654 break;
3655 case AQ_LINK_10M:
3656 media = IFM_10_T;
3657 break;
3658 case AQ_LINK_NONE:
3659 media = 0;
3660 break;
3661 }
3662
3663 flow = 0;
3664 if (fc & AQ_FC_RX)
3665 flow |= IFM_ETH_RXPAUSE;
3666 if (fc & AQ_FC_TX)
3667 flow |= IFM_ETH_TXPAUSE;
3668
3669 ifmr->ifm_status = IFM_AVALID;
3670 if (speed != AQ_LINK_NONE) {
3671 ifmr->ifm_status |= IFM_ACTIVE;
3672 ifmr->ifm_active = IFM_ETHER | IFM_AUTO | media | flow;
3673 }
3674 }
3675
3676 int
aq_ifmedia_change(struct ifnet * ifp)3677 aq_ifmedia_change(struct ifnet *ifp)
3678 {
3679 struct aq_softc *sc = ifp->if_softc;
3680 enum aq_link_speed rate = AQ_LINK_NONE;
3681 enum aq_link_fc fc = AQ_FC_NONE;
3682
3683 if (IFM_TYPE(sc->sc_media.ifm_media) != IFM_ETHER)
3684 return EINVAL;
3685
3686 switch (IFM_SUBTYPE(sc->sc_media.ifm_media)) {
3687 case IFM_AUTO:
3688 rate = AQ_LINK_AUTO;
3689 break;
3690 case IFM_NONE:
3691 rate = AQ_LINK_NONE;
3692 break;
3693 case IFM_10_T:
3694 rate = AQ_LINK_10M;
3695 break;
3696 case IFM_100_TX:
3697 rate = AQ_LINK_100M;
3698 break;
3699 case IFM_1000_T:
3700 rate = AQ_LINK_1G;
3701 break;
3702 case IFM_2500_T:
3703 rate = AQ_LINK_2G5;
3704 break;
3705 case IFM_5000_T:
3706 rate = AQ_LINK_5G;
3707 break;
3708 case IFM_10G_T:
3709 rate = AQ_LINK_10G;
3710 break;
3711 default:
3712 return ENODEV;
3713 }
3714
3715 if (sc->sc_media.ifm_media & IFM_FLOW)
3716 fc = AQ_FC_ALL;
3717
3718 return aq_set_linkmode(sc, rate, fc, AQ_EEE_DISABLE);
3719 }
3720
3721 void
aq_update_link_status(struct aq_softc * sc)3722 aq_update_link_status(struct aq_softc *sc)
3723 {
3724 struct ifnet *ifp = &sc->sc_arpcom.ac_if;
3725 enum aq_link_speed speed;
3726 enum aq_link_fc fc;
3727
3728 if (aq_get_linkmode(sc, &speed, &fc, NULL) != 0)
3729 return;
3730
3731 if (speed == AQ_LINK_NONE) {
3732 if (ifp->if_link_state != LINK_STATE_DOWN) {
3733 ifp->if_link_state = LINK_STATE_DOWN;
3734 if_link_state_change(ifp);
3735 }
3736 } else {
3737 if (ifp->if_link_state != LINK_STATE_FULL_DUPLEX) {
3738 ifp->if_link_state = LINK_STATE_FULL_DUPLEX;
3739 if_link_state_change(ifp);
3740 }
3741 }
3742 }
3743
3744 int
aq_rxrinfo(struct aq_softc * sc,struct if_rxrinfo * ifri)3745 aq_rxrinfo(struct aq_softc *sc, struct if_rxrinfo *ifri)
3746 {
3747 struct if_rxring_info *ifr;
3748 int i;
3749 int error;
3750
3751 ifr = mallocarray(sc->sc_nqueues, sizeof(*ifr), M_TEMP,
3752 M_WAITOK | M_ZERO | M_CANFAIL);
3753 if (ifr == NULL)
3754 return (ENOMEM);
3755
3756 for (i = 0; i < sc->sc_nqueues; i++) {
3757 ifr[i].ifr_size = MCLBYTES;
3758 ifr[i].ifr_info = sc->sc_queues[i].q_rx.rx_rxr;
3759 }
3760
3761 error = if_rxr_info_ioctl(ifri, sc->sc_nqueues, ifr);
3762 free(ifr, M_TEMP, sc->sc_nqueues * sizeof(*ifr));
3763
3764 return (error);
3765 }
3766
3767 int
aq_ioctl(struct ifnet * ifp,u_long cmd,caddr_t data)3768 aq_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
3769 {
3770 struct aq_softc *sc = ifp->if_softc;
3771 struct ifreq *ifr = (struct ifreq *)data;
3772 int error = 0, s;
3773
3774 s = splnet();
3775
3776 switch (cmd) {
3777 case SIOCSIFADDR:
3778 ifp->if_flags |= IFF_UP;
3779 if ((ifp->if_flags & IFF_RUNNING) == 0)
3780 error = aq_up(sc);
3781 break;
3782 case SIOCSIFFLAGS:
3783 if (ifp->if_flags & IFF_UP) {
3784 if (ifp->if_flags & IFF_RUNNING)
3785 error = ENETRESET;
3786 else
3787 error = aq_up(sc);
3788 } else {
3789 if (ifp->if_flags & IFF_RUNNING)
3790 aq_down(sc);
3791 }
3792 break;
3793 case SIOCSIFMEDIA:
3794 case SIOCGIFMEDIA:
3795 error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
3796 break;
3797
3798 case SIOCGIFRXR:
3799 error = aq_rxrinfo(sc, (struct if_rxrinfo *)ifr->ifr_data);
3800 break;
3801
3802 default:
3803 error = ether_ioctl(ifp, &sc->sc_arpcom, cmd, data);
3804 }
3805
3806 if (error == ENETRESET) {
3807 if (ifp->if_flags & IFF_RUNNING)
3808 aq_iff(sc);
3809 error = 0;
3810 }
3811
3812 splx(s);
3813 return error;
3814 }
3815
3816 int
aq2_filter_art_set(struct aq_softc * sc,uint32_t idx,uint32_t tag,uint32_t mask,uint32_t action)3817 aq2_filter_art_set(struct aq_softc *sc, uint32_t idx,
3818 uint32_t tag, uint32_t mask, uint32_t action)
3819 {
3820 int error;
3821
3822 AQ_MPI_LOCK(sc);
3823
3824 WAIT_FOR(AQ_READ_REG(sc, AQ2_ART_SEM_REG) == 1, 10, 1000, &error);
3825 if (error != 0) {
3826 printf("%s: AQ2_ART_SEM_REG timeout\n", DEVNAME(sc));
3827 goto out;
3828 }
3829
3830 idx += sc->sc_art_filter_base_index;
3831 AQ_WRITE_REG(sc, AQ2_RPF_ACT_ART_REQ_TAG_REG(idx), tag);
3832 AQ_WRITE_REG(sc, AQ2_RPF_ACT_ART_REQ_MASK_REG(idx), mask);
3833 AQ_WRITE_REG(sc, AQ2_RPF_ACT_ART_REQ_ACTION_REG(idx), action);
3834
3835 AQ_WRITE_REG(sc, AQ2_ART_SEM_REG, 1);
3836
3837 out:
3838 AQ_MPI_UNLOCK(sc);
3839 return error;
3840 }
3841
3842 void
aq_iff(struct aq_softc * sc)3843 aq_iff(struct aq_softc *sc)
3844 {
3845 struct ifnet *ifp = &sc->sc_arpcom.ac_if;
3846 struct arpcom *ac = &sc->sc_arpcom;
3847 struct ether_multi *enm;
3848 struct ether_multistep step;
3849 uint32_t action;
3850 int idx;
3851
3852 if (HWTYPE_AQ2_P(sc)) {
3853 action = (ifp->if_flags & IFF_PROMISC) ?
3854 AQ2_ART_ACTION_DISABLE : AQ2_ART_ACTION_DROP;
3855 aq2_filter_art_set(sc, AQ2_RPF_INDEX_L2_PROMISC_OFF, 0,
3856 AQ2_RPF_TAG_UC_MASK | AQ2_RPF_TAG_ALLMC_MASK, action);
3857 aq2_filter_art_set(sc, AQ2_RPF_INDEX_VLAN_PROMISC_OFF, 0,
3858 AQ2_RPF_TAG_VLAN_MASK | AQ2_RPF_TAG_UNTAG_MASK, action);
3859 }
3860
3861 if (ifp->if_flags & IFF_PROMISC) {
3862 ifp->if_flags |= IFF_ALLMULTI;
3863 AQ_WRITE_REG_BIT(sc, RPF_L2BC_REG, RPF_L2BC_PROMISC, 1);
3864 } else if (ac->ac_multirangecnt > 0 ||
3865 ac->ac_multicnt >= AQ_HW_MAC_NUM) {
3866 ifp->if_flags |= IFF_ALLMULTI;
3867 AQ_WRITE_REG_BIT(sc, RPF_L2BC_REG, RPF_L2BC_PROMISC, 0);
3868 AQ_WRITE_REG_BIT(sc, RPF_MCAST_FILTER_MASK_REG,
3869 RPF_MCAST_FILTER_MASK_ALLMULTI, 1);
3870 AQ_WRITE_REG_BIT(sc, RPF_MCAST_FILTER_REG(0),
3871 RPF_MCAST_FILTER_EN, 1);
3872 } else {
3873 ifp->if_flags &= ~IFF_ALLMULTI;
3874 idx = AQ_HW_MAC_OWN + 1;
3875
3876 AQ_WRITE_REG_BIT(sc, RPF_L2BC_REG, RPF_L2BC_PROMISC, 0);
3877
3878 ETHER_FIRST_MULTI(step, ac, enm);
3879 while (enm != NULL) {
3880 aq_set_mac_addr(sc, idx++, enm->enm_addrlo);
3881 ETHER_NEXT_MULTI(step, enm);
3882 }
3883
3884 for (; idx < AQ_HW_MAC_NUM; idx++)
3885 aq_set_mac_addr(sc, idx, NULL);
3886
3887 AQ_WRITE_REG_BIT(sc, RPF_MCAST_FILTER_MASK_REG,
3888 RPF_MCAST_FILTER_MASK_ALLMULTI, 0);
3889 AQ_WRITE_REG_BIT(sc, RPF_MCAST_FILTER_REG(0),
3890 RPF_MCAST_FILTER_EN, 0);
3891 }
3892 }
3893
3894 int
aq_dmamem_alloc(struct aq_softc * sc,struct aq_dmamem * aqm,bus_size_t size,u_int align)3895 aq_dmamem_alloc(struct aq_softc *sc, struct aq_dmamem *aqm,
3896 bus_size_t size, u_int align)
3897 {
3898 aqm->aqm_size = size;
3899
3900 if (bus_dmamap_create(sc->sc_dmat, aqm->aqm_size, 1,
3901 aqm->aqm_size, 0,
3902 BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW | BUS_DMA_64BIT,
3903 &aqm->aqm_map) != 0)
3904 return (1);
3905 if (bus_dmamem_alloc(sc->sc_dmat, aqm->aqm_size,
3906 align, 0, &aqm->aqm_seg, 1, &aqm->aqm_nsegs,
3907 BUS_DMA_WAITOK | BUS_DMA_ZERO) != 0)
3908 goto destroy;
3909 if (bus_dmamem_map(sc->sc_dmat, &aqm->aqm_seg, aqm->aqm_nsegs,
3910 aqm->aqm_size, &aqm->aqm_kva,
3911 BUS_DMA_WAITOK | BUS_DMA_COHERENT) != 0)
3912 goto free;
3913 if (bus_dmamap_load(sc->sc_dmat, aqm->aqm_map, aqm->aqm_kva,
3914 aqm->aqm_size, NULL, BUS_DMA_WAITOK) != 0)
3915 goto unmap;
3916
3917 return (0);
3918 unmap:
3919 bus_dmamem_unmap(sc->sc_dmat, aqm->aqm_kva, aqm->aqm_size);
3920 free:
3921 bus_dmamem_free(sc->sc_dmat, &aqm->aqm_seg, 1);
3922 destroy:
3923 bus_dmamap_destroy(sc->sc_dmat, aqm->aqm_map);
3924 return (1);
3925 }
3926
3927 void
aq_dmamem_free(struct aq_softc * sc,struct aq_dmamem * aqm)3928 aq_dmamem_free(struct aq_softc *sc, struct aq_dmamem *aqm)
3929 {
3930 bus_dmamap_unload(sc->sc_dmat, aqm->aqm_map);
3931 bus_dmamem_unmap(sc->sc_dmat, aqm->aqm_kva, aqm->aqm_size);
3932 bus_dmamem_free(sc->sc_dmat, &aqm->aqm_seg, 1);
3933 bus_dmamap_destroy(sc->sc_dmat, aqm->aqm_map);
3934 }
3935