Print this page
212 Atheros AR8132 / L1c Gigabit Ethernet Adapter
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/io/atge/atge_main.c
+++ new/usr/src/uts/common/io/atge/atge_main.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 + * Copyright (c) 2012 Gary Mills
24 + *
23 25 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
24 26 */
27 +/*
28 + * Copyright (c) 2009, Pyun YongHyeon <yongari@FreeBSD.org>
29 + * All rights reserved.
30 + *
31 + * Redistribution and use in source and binary forms, with or without
32 + * modification, are permitted provided that the following conditions
33 + * are met:
34 + * 1. Redistributions of source code must retain the above copyright
35 + * notice unmodified, this list of conditions, and the following
36 + * disclaimer.
37 + * 2. Redistributions in binary form must reproduce the above copyright
38 + * notice, this list of conditions and the following disclaimer in the
39 + * documentation and/or other materials provided with the distribution.
40 + *
41 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
42 + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 + * SUCH DAMAGE.
52 + */
25 53
26 54 #include <sys/types.h>
27 55 #include <sys/stream.h>
28 56 #include <sys/strsun.h>
29 57 #include <sys/stat.h>
30 58 #include <sys/modctl.h>
31 59 #include <sys/kstat.h>
32 60 #include <sys/ethernet.h>
33 61 #include <sys/devops.h>
34 62 #include <sys/debug.h>
35 63 #include <sys/conf.h>
36 64 #include <sys/mii.h>
37 65 #include <sys/miiregs.h>
38 66 #include <sys/mac.h>
39 67 #include <sys/mac_provider.h>
40 68 #include <sys/mac_ether.h>
41 69 #include <sys/sysmacros.h>
42 70 #include <sys/dditypes.h>
43 71 #include <sys/ddi.h>
44 72 #include <sys/sunddi.h>
45 73 #include <sys/byteorder.h>
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
46 74 #include <sys/note.h>
47 75 #include <sys/vlan.h>
48 76 #include <sys/strsubr.h>
49 77 #include <sys/crc32.h>
50 78 #include <sys/sdt.h>
51 79 #include <sys/pci.h>
52 80 #include <sys/pci_cap.h>
53 81
54 82 #include "atge.h"
55 83 #include "atge_cmn_reg.h"
84 +#include "atge_l1c_reg.h"
56 85 #include "atge_l1e_reg.h"
57 86 #include "atge_l1_reg.h"
58 87
59 88
60 89 /*
61 - * Atheros/Attansic Ethernet chips are of three types - L1, L2 and L1E.
62 - * This driver is for L1E/L1 but can be extended to support other chips.
90 + * Atheros/Attansic Ethernet chips are of four types - L1, L2, L1E and L1C.
91 + * This driver is for L1E/L1/L1C but can be extended to support other chips.
63 92 * L1E comes in 1Gigabit and Fast Ethernet flavors. L1 comes in 1Gigabit
64 - * flavors only.
93 + * flavors only. L1C comes in both flavours.
65 94 *
66 95 * Atheros/Attansic Ethernet controllers have descriptor based TX and RX
67 96 * with an exception of L1E. L1E's RX side is not descriptor based ring.
68 97 * The L1E's RX uses pages (not to be confused with MMU pages) for
69 98 * receiving pkts. The header has four fields :
70 99 *
71 100 * uint32_t seqno; Sequence number of the frame.
72 101 * uint32_t length; Length of the frame.
73 102 * uint32_t flags; Flags
74 103 * uint32_t vtag; We don't use hardware VTAG.
75 104 *
76 105 * We use only one queue for RX (each queue can have two pages) and each
77 106 * page is L1E_RX_PAGE_SZ large in bytes. That's the reason we don't
78 107 * use zero-copy RX because we are limited to two pages and each page
79 108 * accomodates large number of pkts.
80 109 *
81 110 * The TX side on all three chips is descriptor based ring; and all the
82 111 * more reason to have one driver for these chips.
83 112 *
84 113 * We use two locks - atge_intr_lock and atge_tx_lock. Both the locks
85 114 * should be held if the operation has impact on the driver instance.
86 115 *
87 116 * All the three chips have hash-based multicast filter.
88 117 *
89 118 * We use CMB (Coalescing Message Block) for RX but not for TX as there
90 119 * are some issues with TX. RX CMB is used to get the last descriptor
91 120 * posted by the chip. Each CMB is for a RX page (one queue can have two
92 121 * pages) and are uint32_t (4 bytes) long.
93 122 *
94 123 * The descriptor table should have 32-bit physical address limit due to
95 124 * the limitation of having same high address for TX/RX/SMB/CMB. The
96 125 * TX/RX buffers can be 64-bit.
97 126 *
98 127 * Every DMA memory in atge is represented by atge_dma_t be it TX/RX Buffers
99 128 * or TX/RX descriptor table or SMB/CMB. To keep the code simple, we have
100 129 * kept sgl as 1 so that we get contingous pages from root complex.
101 130 *
102 131 * L1 chip (0x1048) uses descriptor based TX and RX ring. Most of registers are
103 132 * common with L1E chip (0x1026).
104 133 */
105 134
106 135 /*
107 136 * Function Prototypes for debugging.
108 137 */
109 138 void atge_error(dev_info_t *, char *, ...);
110 139 void atge_debug_func(char *, ...);
111 140
112 141 /*
113 142 * Function Prototypes for driver operations.
114 143 */
115 144 static int atge_resume(dev_info_t *);
116 145 static int atge_add_intr(atge_t *);
117 146 static int atge_alloc_dma(atge_t *);
118 147 static void atge_remove_intr(atge_t *);
119 148 static void atge_free_dma(atge_t *);
120 149 static void atge_device_reset(atge_t *);
121 150 static void atge_device_init(atge_t *);
122 151 static void atge_device_start(atge_t *);
123 152 static void atge_disable_intrs(atge_t *);
124 153 atge_dma_t *atge_alloc_a_dma_blk(atge_t *, ddi_dma_attr_t *, int, int);
125 154 void atge_free_a_dma_blk(atge_dma_t *);
126 155 static void atge_rxfilter(atge_t *);
127 156 static void atge_device_reset_l1_l1e(atge_t *);
128 157 void atge_program_ether(atge_t *atgep);
129 158 void atge_device_restart(atge_t *);
130 159 void atge_device_stop(atge_t *);
131 160 static int atge_send_a_packet(atge_t *, mblk_t *);
132 161 static uint32_t atge_ether_crc(const uint8_t *, int);
133 162
134 163
135 164 /*
136 165 * L1E/L2E specific functions.
137 166 */
138 167 void atge_l1e_device_reset(atge_t *);
139 168 void atge_l1e_stop_mac(atge_t *);
140 169 int atge_l1e_alloc_dma(atge_t *);
141 170 void atge_l1e_free_dma(atge_t *);
142 171 void atge_l1e_init_tx_ring(atge_t *);
143 172 void atge_l1e_init_rx_pages(atge_t *);
144 173 void atge_l1e_program_dma(atge_t *);
|
↓ open down ↓ |
70 lines elided |
↑ open up ↑ |
145 174 void atge_l1e_send_packet(atge_ring_t *);
146 175 mblk_t *atge_l1e_receive(atge_t *);
147 176 uint_t atge_l1e_interrupt(caddr_t, caddr_t);
148 177 void atge_l1e_gather_stats(atge_t *);
149 178 void atge_l1e_clear_stats(atge_t *);
150 179
151 180 /*
152 181 * L1 specific functions.
153 182 */
154 183 int atge_l1_alloc_dma(atge_t *);
184 +void atge_l1_free_dma(atge_t *);
155 185 void atge_l1_init_tx_ring(atge_t *);
156 186 void atge_l1_init_rx_ring(atge_t *);
157 187 void atge_l1_init_rr_ring(atge_t *);
158 188 void atge_l1_init_cmb(atge_t *);
159 189 void atge_l1_init_smb(atge_t *);
160 190 void atge_l1_program_dma(atge_t *);
161 191 void atge_l1_stop_tx_mac(atge_t *);
162 192 void atge_l1_stop_rx_mac(atge_t *);
163 193 uint_t atge_l1_interrupt(caddr_t, caddr_t);
164 194 void atge_l1_send_packet(atge_ring_t *);
165 195
196 +/*
197 + * L1C specific functions.
198 + */
199 +int atge_l1c_alloc_dma(atge_t *);
200 +void atge_l1c_free_dma(atge_t *);
201 +void atge_l1c_init_tx_ring(atge_t *);
202 +void atge_l1c_init_rx_ring(atge_t *);
203 +void atge_l1c_init_rr_ring(atge_t *);
204 +void atge_l1c_init_cmb(atge_t *);
205 +void atge_l1c_init_smb(atge_t *);
206 +void atge_l1c_program_dma(atge_t *);
207 +void atge_l1c_stop_tx_mac(atge_t *);
208 +void atge_l1c_stop_rx_mac(atge_t *);
209 +uint_t atge_l1c_interrupt(caddr_t, caddr_t);
210 +void atge_l1c_send_packet(atge_ring_t *);
211 +void atge_l1c_gather_stats(atge_t *);
212 +void atge_l1c_clear_stats(atge_t *);
166 213
167 214 /*
168 215 * Function prototyps for MII operations.
169 216 */
170 217 uint16_t atge_mii_read(void *, uint8_t, uint8_t);
171 218 void atge_mii_write(void *, uint8_t, uint8_t, uint16_t);
219 +uint16_t atge_l1c_mii_read(void *, uint8_t, uint8_t);
220 +void atge_l1c_mii_write(void *, uint8_t, uint8_t, uint16_t);
172 221 void atge_l1e_mii_reset(void *);
173 222 void atge_l1_mii_reset(void *);
223 +void atge_l1c_mii_reset(void *);
174 224 static void atge_mii_notify(void *, link_state_t);
175 225 void atge_tx_reclaim(atge_t *atgep, int cons);
176 226
177 227 /*
178 228 * L1E/L2E chip.
179 229 */
180 230 static mii_ops_t atge_l1e_mii_ops = {
181 231 MII_OPS_VERSION,
182 232 atge_mii_read,
183 233 atge_mii_write,
184 234 atge_mii_notify,
185 235 atge_l1e_mii_reset
186 236 };
187 237
188 238 /*
189 239 * L1 chip.
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
190 240 */
191 241 static mii_ops_t atge_l1_mii_ops = {
192 242 MII_OPS_VERSION,
193 243 atge_mii_read,
194 244 atge_mii_write,
195 245 atge_mii_notify,
196 246 atge_l1_mii_reset
197 247 };
198 248
199 249 /*
250 + * L1C chip.
251 + */
252 +static mii_ops_t atge_l1c_mii_ops = {
253 + MII_OPS_VERSION,
254 + atge_l1c_mii_read,
255 + atge_l1c_mii_write,
256 + atge_mii_notify,
257 + NULL
258 +};
259 +
260 +/*
200 261 * Function Prototypes for MAC callbacks.
201 262 */
202 263 static int atge_m_stat(void *, uint_t, uint64_t *);
203 264 static int atge_m_start(void *);
204 265 static void atge_m_stop(void *);
205 266 static int atge_m_getprop(void *, const char *, mac_prop_id_t, uint_t,
206 267 void *);
207 268 static int atge_m_setprop(void *, const char *, mac_prop_id_t, uint_t,
208 269 const void *);
209 270 static void atge_m_propinfo(void *, const char *, mac_prop_id_t,
210 271 mac_prop_info_handle_t);
211 272 static int atge_m_unicst(void *, const uint8_t *);
212 273 static int atge_m_multicst(void *, boolean_t, const uint8_t *);
213 274 static int atge_m_promisc(void *, boolean_t);
214 275 static mblk_t *atge_m_tx(void *, mblk_t *);
215 276
216 277 static mac_callbacks_t atge_m_callbacks = {
217 278 MC_SETPROP | MC_GETPROP | MC_PROPINFO,
218 279 atge_m_stat,
219 280 atge_m_start,
220 281 atge_m_stop,
221 282 atge_m_promisc,
222 283 atge_m_multicst,
223 284 atge_m_unicst,
224 285 atge_m_tx,
225 286 NULL, /* mc_reserved */
226 287 NULL, /* mc_ioctl */
227 288 NULL, /* mc_getcapab */
228 289 NULL, /* mc_open */
229 290 NULL, /* mc_close */
230 291 atge_m_setprop,
231 292 atge_m_getprop,
232 293 atge_m_propinfo
233 294 };
234 295
235 296 /*
236 297 * DMA Data access requirements.
237 298 */
238 299 static struct ddi_device_acc_attr atge_dev_attr = {
239 300 DDI_DEVICE_ATTR_V0,
240 301 DDI_STRUCTURE_LE_ACC,
241 302 DDI_STRICTORDER_ACC
242 303 };
243 304
244 305 /*
245 306 * Buffers should be native endianness.
246 307 */
247 308 static struct ddi_device_acc_attr atge_buf_attr = {
248 309 DDI_DEVICE_ATTR_V0,
249 310 DDI_NEVERSWAP_ACC, /* native endianness */
250 311 DDI_STRICTORDER_ACC
251 312 };
252 313
253 314 /*
254 315 * DMA device attributes. Buffer can be 64-bit.
255 316 */
256 317 static ddi_dma_attr_t atge_dma_attr_buf = {
257 318 DMA_ATTR_V0, /* dma_attr_version */
258 319 0, /* dma_attr_addr_lo */
259 320 0x00ffffffffffull, /* dma_attr_addr_hi */
260 321 0x000000003fffull, /* dma_attr_count_max */
261 322 8, /* dma_attr_align */
262 323 0x00003ffc, /* dma_attr_burstsizes */
263 324 1, /* dma_attr_minxfer */
264 325 0x0000000027ffull, /* dma_attr_maxxfer */
|
↓ open down ↓ |
55 lines elided |
↑ open up ↑ |
265 326 0x0000ffffffffull, /* dma_attr_seg */
266 327 1, /* dma_attr_sgllen */
267 328 1, /* dma_attr_granular */
268 329 0 /* dma_attr_flags */
269 330 };
270 331
271 332 /*
272 333 * Table of supported devices.
273 334 */
274 335 #define ATGE_VENDOR_ID 0x1969
336 +#define ATGE_L1_STR "Attansic L1"
337 +#define ATGE_L1CG_STR "Atheros AR8131 Gigabit Ethernet"
338 +#define ATGE_L1CF_STR "Atheros AR8132 Fast Ethernet"
275 339 #define ATGE_L1E_STR "Atheros AR8121/8113/8114"
340 +#define ATGE_AR8151V1_STR "Atheros AR8151 v1.0 Gigabit Ethernet"
341 +#define ATGE_AR8151V2_STR "Atheros AR8151 v2.0 Gigabit Ethernet"
342 +#define ATGE_AR8152V1_STR "Atheros AR8152 v1.1 Fast Ethernet"
343 +#define ATGE_AR8152V2_STR "Atheros AR8152 v2.0 Fast Ethernet"
276 344
277 345 static atge_cards_t atge_cards[] = {
346 + {ATGE_VENDOR_ID, ATGE_CHIP_AR8151V2_DEV_ID, ATGE_AR8151V2_STR,
347 + ATGE_CHIP_L1C},
348 + {ATGE_VENDOR_ID, ATGE_CHIP_AR8151V1_DEV_ID, ATGE_AR8151V1_STR,
349 + ATGE_CHIP_L1C},
350 + {ATGE_VENDOR_ID, ATGE_CHIP_AR8152V2_DEV_ID, ATGE_AR8152V2_STR,
351 + ATGE_CHIP_L1C},
352 + {ATGE_VENDOR_ID, ATGE_CHIP_AR8152V1_DEV_ID, ATGE_AR8152V1_STR,
353 + ATGE_CHIP_L1C},
354 + {ATGE_VENDOR_ID, ATGE_CHIP_L1CG_DEV_ID, ATGE_L1CG_STR, ATGE_CHIP_L1C},
355 + {ATGE_VENDOR_ID, ATGE_CHIP_L1CF_DEV_ID, ATGE_L1CF_STR, ATGE_CHIP_L1C},
278 356 {ATGE_VENDOR_ID, ATGE_CHIP_L1E_DEV_ID, ATGE_L1E_STR, ATGE_CHIP_L1E},
279 - {ATGE_VENDOR_ID, ATGE_CHIP_L1_DEV_ID, "Attansic L1", ATGE_CHIP_L1},
357 + {ATGE_VENDOR_ID, ATGE_CHIP_L1_DEV_ID, ATGE_L1_STR, ATGE_CHIP_L1},
280 358 };
281 359
282 360 /*
283 361 * Global Debugging flag. Developer level debugging is done only in DEBUG mode.
284 362 */
285 363 int atge_debug = 1;
286 364
287 365 /*
288 366 * Debugging and error reporting.
289 367 */
290 368 void
291 369 atge_debug_func(char *fmt, ...)
292 370 {
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
293 371 va_list ap;
294 372 char buf[256];
295 373
296 374 va_start(ap, fmt);
297 375 (void) vsnprintf(buf, sizeof (buf), fmt, ap);
298 376 va_end(ap);
299 377
300 378 DTRACE_PROBE1(atge__debug, char *, buf);
301 379 }
302 380
381 +static
303 382 void
304 -atge_error(dev_info_t *dip, char *fmt, ...)
383 +atge_message(dev_info_t *dip, int level, char *fmt, va_list ap)
305 384 {
306 - va_list ap;
307 385 char buf[256];
386 + char *p = "!%s%d: %s";
387 + char *q = "!atge: %s";
308 388
309 - va_start(ap, fmt);
310 389 (void) vsnprintf(buf, sizeof (buf), fmt, ap);
311 - va_end(ap);
312 390
391 + if (level != CE_NOTE) {
392 + p++;
393 + q++;
394 + }
395 +
313 396 if (dip) {
314 - cmn_err(CE_WARN, "%s%d: %s",
397 + cmn_err(level, p,
315 398 ddi_driver_name(dip), ddi_get_instance(dip), buf);
316 399 } else {
317 - cmn_err(CE_WARN, "atge: %s", buf);
400 + cmn_err(level, q, buf);
318 401 }
319 402 }
320 403
321 404 void
405 +atge_notice(dev_info_t *dip, char *fmt, ...)
406 +{
407 + va_list ap;
408 +
409 + va_start(ap, fmt);
410 + (void) atge_message(dip, CE_NOTE, fmt, ap);
411 + va_end(ap);
412 +}
413 +
414 +void
415 +atge_error(dev_info_t *dip, char *fmt, ...)
416 +{
417 + va_list ap;
418 +
419 + va_start(ap, fmt);
420 + (void) atge_message(dip, CE_WARN, fmt, ap);
421 + va_end(ap);
422 +}
423 +
424 +void
322 425 atge_mac_config(atge_t *atgep)
323 426 {
324 427 uint32_t reg;
325 428 int speed;
326 429 link_duplex_t ld;
327 430
431 + /* Re-enable TX/RX MACs */
328 432 reg = INL(atgep, ATGE_MAC_CFG);
329 433 reg &= ~(ATGE_CFG_FULL_DUPLEX | ATGE_CFG_TX_FC | ATGE_CFG_RX_FC |
330 434 ATGE_CFG_SPEED_MASK);
331 435
436 + switch (ATGE_MODEL(atgep)) {
437 + case ATGE_CHIP_L1C:
438 + switch (ATGE_DID(atgep)) {
439 + case ATGE_CHIP_AR8151V2_DEV_ID:
440 + case ATGE_CHIP_AR8151V1_DEV_ID:
441 + case ATGE_CHIP_AR8152V2_DEV_ID:
442 + reg |= ATGE_CFG_HASH_ALG_CRC32 | ATGE_CFG_SPEED_MODE_SW;
443 + break;
444 + }
445 + break;
446 + }
447 +
332 448 speed = mii_get_speed(atgep->atge_mii);
333 449 switch (speed) {
334 450 case 10:
335 451 case 100:
336 452 reg |= ATGE_CFG_SPEED_10_100;
337 453 break;
338 454 case 1000:
339 455 reg |= ATGE_CFG_SPEED_1000;
340 456 break;
341 457 }
342 458
343 459 ld = mii_get_duplex(atgep->atge_mii);
344 460 if (ld == LINK_DUPLEX_FULL)
345 461 reg |= ATGE_CFG_FULL_DUPLEX;
346 462
347 463 /* Re-enable TX/RX MACs */
348 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
464 + switch (ATGE_MODEL(atgep)) {
465 + case ATGE_CHIP_L1E:
349 466 reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB | ATGE_CFG_RX_FC;
350 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
467 + break;
468 + case ATGE_CHIP_L1:
469 + case ATGE_CHIP_L1C:
351 470 reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB;
471 + break;
352 472 }
353 473
354 474 OUTL(atgep, ATGE_MAC_CFG, reg);
355 475
356 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
476 + switch (ATGE_MODEL(atgep)) {
477 + case ATGE_CHIP_L1E:
357 478 reg = ATGE_USECS(ATGE_IM_RX_TIMER_DEFAULT) << IM_TIMER_RX_SHIFT;
358 479 reg |= ATGE_USECS(ATGE_IM_TX_TIMER_DEFAULT) <<
359 480 IM_TIMER_TX_SHIFT;
360 481 OUTL(atgep, ATGE_IM_TIMER, reg);
482 + break;
483 + case ATGE_CHIP_L1:
484 + break;
485 + case ATGE_CHIP_L1C:
486 + /* Configure interrupt moderation timer. */
487 + reg = ATGE_USECS(atgep->atge_int_rx_mod) << IM_TIMER_RX_SHIFT;
488 + reg |= ATGE_USECS(atgep->atge_int_tx_mod) << IM_TIMER_TX_SHIFT;
489 + OUTL(atgep, ATGE_IM_TIMER, reg);
490 + /*
491 + * We don't want to automatic interrupt clear as task queue
492 + * for the interrupt should know interrupt status.
493 + */
494 + reg = 0;
495 + if (ATGE_USECS(atgep->atge_int_rx_mod) != 0)
496 + reg |= MASTER_IM_RX_TIMER_ENB;
497 + if (ATGE_USECS(atgep->atge_int_tx_mod) != 0)
498 + reg |= MASTER_IM_TX_TIMER_ENB;
499 + OUTL(atgep, ATGE_MASTER_CFG, reg);
500 + break;
361 501 }
362 502
363 503 ATGE_DB(("%s: %s() mac_cfg is : %x",
364 504 atgep->atge_name, __func__, INL(atgep, ATGE_MAC_CFG)));
365 505 }
366 506
367 507 static void
368 508 atge_mii_notify(void *arg, link_state_t link)
369 509 {
370 510 atge_t *atgep = arg;
371 511
372 512 ATGE_DB(("%s: %s() LINK STATUS CHANGED from %x -> %x",
373 513 atgep->atge_name, __func__, atgep->atge_link_state, link));
374 514
375 515 mac_link_update(atgep->atge_mh, link);
376 516
377 517 /*
378 518 * Reconfigure MAC if link status is UP now.
379 519 */
380 520 mutex_enter(&atgep->atge_tx_lock);
381 521 if (link == LINK_STATE_UP) {
382 522 atgep->atge_link_state = LINK_STATE_UP;
383 523 atge_mac_config(atgep);
384 524 atgep->atge_tx_resched = 0;
385 525 } else {
386 526 atgep->atge_link_state = LINK_STATE_DOWN;
387 527 atgep->atge_flags |= ATGE_MII_CHECK;
388 528 }
389 529
390 530 mutex_exit(&atgep->atge_tx_lock);
391 531
392 532 if (link == LINK_STATE_UP)
393 533 mac_tx_update(atgep->atge_mh);
394 534 }
395 535
396 536 void
397 537 atge_tx_reclaim(atge_t *atgep, int end)
398 538 {
399 539 atge_tx_desc_t *txd;
400 540 atge_ring_t *r = atgep->atge_tx_ring;
401 541 uchar_t *c;
402 542 int start;
403 543
404 544 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
405 545 ASSERT(r != NULL);
406 546
407 547 start = r->r_consumer;
408 548
409 549 if (start == end)
410 550 return;
411 551
412 552 while (start != end) {
413 553 r->r_avail_desc++;
414 554 if (r->r_avail_desc > ATGE_TX_RING_CNT) {
415 555
416 556 atge_error(atgep->atge_dip,
417 557 "Reclaim : TX descriptor error");
418 558
419 559 if (r->r_avail_desc > (ATGE_TX_RING_CNT + 5)) {
420 560 atge_device_stop(atgep);
421 561 break;
422 562 }
423 563 }
424 564
425 565 c = (uchar_t *)r->r_desc_ring->addr;
426 566 c += (sizeof (atge_tx_desc_t) * start);
427 567 txd = (atge_tx_desc_t *)c;
428 568
429 569 /*
430 570 * Clearing TX descriptor helps in debugging some strange
431 571 * problems.
432 572 */
433 573 txd->addr = 0;
434 574 txd->len = 0;
435 575 txd->flags = 0;
436 576
437 577 ATGE_INC_SLOT(start, ATGE_TX_RING_CNT);
438 578 }
439 579
440 580 atgep->atge_tx_ring->r_consumer = start;
441 581
442 582 DMA_SYNC(r->r_desc_ring, 0, ATGE_TX_RING_SZ, DDI_DMA_SYNC_FORDEV);
443 583 }
444 584
445 585 /*
446 586 * Adds interrupt handler depending upon the type of interrupt supported by
447 587 * the chip.
448 588 */
449 589 static int
450 590 atge_add_intr_handler(atge_t *atgep, int intr_type)
451 591 {
452 592 int err;
453 593 int count = 0;
454 594 int avail = 0;
455 595 int i;
456 596 int flag;
457 597
458 598 if (intr_type != DDI_INTR_TYPE_FIXED) {
459 599 err = ddi_intr_get_nintrs(atgep->atge_dip, intr_type, &count);
460 600 if (err != DDI_SUCCESS) {
461 601 atge_error(atgep->atge_dip,
462 602 "ddi_intr_get_nintrs failed : %d", err);
463 603 return (DDI_FAILURE);
464 604 }
465 605
466 606 ATGE_DB(("%s: %s() count : %d",
467 607 atgep->atge_name, __func__, count));
468 608
469 609 err = ddi_intr_get_navail(atgep->atge_dip, intr_type, &avail);
470 610 if (err != DDI_SUCCESS) {
471 611 atge_error(atgep->atge_dip,
472 612 "ddi_intr_get_navail failed : %d", err);
473 613 return (DDI_FAILURE);
474 614 }
475 615
476 616 if (avail < count) {
477 617 atge_error(atgep->atge_dip, "count :%d,"
478 618 " avail : %d", count, avail);
479 619 }
480 620
481 621 flag = DDI_INTR_ALLOC_STRICT;
482 622 } else {
483 623 /*
484 624 * DDI_INTR_TYPE_FIXED case.
485 625 */
486 626 count = 1;
487 627 avail = 1;
488 628 flag = DDI_INTR_ALLOC_NORMAL;
489 629 }
490 630
491 631 atgep->atge_intr_size = avail * sizeof (ddi_intr_handle_t);
492 632 atgep->atge_intr_handle = kmem_zalloc(atgep->atge_intr_size, KM_SLEEP);
493 633
494 634 ATGE_DB(("%s: %s() avail:%d, count : %d, type : %d",
495 635 atgep->atge_name, __func__, avail, count,
496 636 intr_type));
497 637
498 638 err = ddi_intr_alloc(atgep->atge_dip, atgep->atge_intr_handle,
499 639 intr_type, 0, avail, &atgep->atge_intr_cnt, flag);
500 640
501 641 if (err != DDI_SUCCESS) {
502 642 atge_error(atgep->atge_dip, "ddi_intr_alloc failed : %d", err);
503 643 kmem_free(atgep->atge_intr_handle, atgep->atge_intr_size);
504 644 return (DDI_FAILURE);
505 645 }
506 646
507 647 ATGE_DB(("%s: atge_add_intr_handler() after alloc count"
508 648 " :%d, avail : %d", atgep->atge_name, count, avail));
509 649
510 650 err = ddi_intr_get_pri(atgep->atge_intr_handle[0],
511 651 &atgep->atge_intr_pri);
512 652 if (err != DDI_SUCCESS) {
513 653 atge_error(atgep->atge_dip, "ddi_intr_get_pri failed:%d", err);
514 654 for (i = 0; i < atgep->atge_intr_cnt; i++) {
515 655 (void) ddi_intr_free(atgep->atge_intr_handle[i]);
|
↓ open down ↓ |
145 lines elided |
↑ open up ↑ |
516 656 }
517 657 kmem_free(atgep->atge_intr_handle, atgep->atge_intr_size);
518 658
519 659 return (DDI_FAILURE);
520 660 }
521 661
522 662 /*
523 663 * Add interrupt handler now.
524 664 */
525 665 for (i = 0; i < atgep->atge_intr_cnt; i++) {
526 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
666 + switch (ATGE_MODEL(atgep)) {
667 + case ATGE_CHIP_L1E:
527 668 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
528 669 atge_l1e_interrupt, atgep, (caddr_t)(uintptr_t)i);
529 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
670 + break;
671 + case ATGE_CHIP_L1:
530 672 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
531 673 atge_l1_interrupt, atgep, (caddr_t)(uintptr_t)i);
674 + break;
675 + case ATGE_CHIP_L1C:
676 + err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
677 + atge_l1c_interrupt, atgep, (caddr_t)(uintptr_t)i);
678 + break;
532 679 }
533 680
534 681 if (err != DDI_SUCCESS) {
535 682 atge_error(atgep->atge_dip,
536 683 "ddi_intr_add_handler failed : %d", err);
537 684
538 685 (void) ddi_intr_free(atgep->atge_intr_handle[i]);
539 686 while (--i >= 0) {
540 687 (void) ddi_intr_remove_handler(
541 688 atgep->atge_intr_handle[i]);
542 689 (void) ddi_intr_free(
543 690 atgep->atge_intr_handle[i]);
544 691 }
545 692
546 693 kmem_free(atgep->atge_intr_handle,
547 694 atgep->atge_intr_size);
548 695
549 696 return (DDI_FAILURE);
550 697 }
551 698 }
552 699
553 700 err = ddi_intr_get_cap(atgep->atge_intr_handle[0],
554 701 &atgep->atge_intr_cap);
555 702
556 703 if (err != DDI_SUCCESS) {
557 704 atge_error(atgep->atge_dip,
558 705 "ddi_intr_get_cap failed : %d", err);
559 706 atge_remove_intr(atgep);
560 707 return (DDI_FAILURE);
561 708 }
562 709
563 710 if (intr_type == DDI_INTR_TYPE_FIXED)
564 711 atgep->atge_flags |= ATGE_FIXED_TYPE;
565 712 else if (intr_type == DDI_INTR_TYPE_MSI)
566 713 atgep->atge_flags |= ATGE_MSI_TYPE;
567 714 else if (intr_type == DDI_INTR_TYPE_MSIX)
568 715 atgep->atge_flags |= ATGE_MSIX_TYPE;
569 716
570 717 return (DDI_SUCCESS);
571 718 }
572 719
573 720 void
574 721 atge_remove_intr(atge_t *atgep)
575 722 {
576 723 int i;
577 724 int cap = 0;
578 725
579 726 if (atgep->atge_intr_handle == NULL)
580 727 return;
581 728
582 729 if (atgep->atge_intr_cap & DDI_INTR_FLAG_BLOCK) {
583 730 (void) ddi_intr_block_disable(atgep->atge_intr_handle,
584 731 atgep->atge_intr_cnt);
585 732
586 733 cap = 1;
587 734 }
588 735
589 736 for (i = 0; i < atgep->atge_intr_cnt; i++) {
590 737 if (cap == 0)
591 738 (void) ddi_intr_disable(atgep->atge_intr_handle[i]);
592 739
593 740 (void) ddi_intr_remove_handler(atgep->atge_intr_handle[i]);
594 741 (void) ddi_intr_free(atgep->atge_intr_handle[i]);
595 742 }
596 743
597 744 kmem_free(atgep->atge_intr_handle, atgep->atge_intr_size);
598 745 }
599 746
600 747 int
601 748 atge_enable_intrs(atge_t *atgep)
602 749 {
603 750 int err;
604 751 int i;
605 752
606 753 if (atgep->atge_intr_cap & DDI_INTR_FLAG_BLOCK) {
607 754 /*
608 755 * Do block enable.
609 756 */
610 757 err = ddi_intr_block_enable(atgep->atge_intr_handle,
611 758 atgep->atge_intr_cnt);
612 759
613 760 if (err != DDI_SUCCESS) {
614 761 atge_error(atgep->atge_dip,
615 762 "Failed to block enable intrs %d", err);
616 763 err = DDI_FAILURE;
617 764 } else {
618 765 err = DDI_SUCCESS;
619 766 }
620 767 } else {
621 768 /*
622 769 * Call ddi_intr_enable() for MSI non-block enable.
623 770 */
624 771 for (i = 0; i < atgep->atge_intr_cnt; i++) {
625 772 err = ddi_intr_enable(atgep->atge_intr_handle[i]);
626 773 if (err != DDI_SUCCESS) {
627 774 atge_error(atgep->atge_dip,
628 775 "Failed to enable intrs on %d with : %d",
629 776 i, err);
630 777 break;
631 778 }
632 779 }
633 780
634 781 if (err == DDI_SUCCESS)
635 782 err = DDI_SUCCESS;
636 783 else
637 784 err = DDI_FAILURE;
638 785 }
639 786
640 787 return (err);
641 788 }
642 789
643 790 /*
644 791 * Adds interrupt handler depending on the supported interrupt type by the
645 792 * chip.
646 793 */
647 794 static int
648 795 atge_add_intr(atge_t *atgep)
649 796 {
650 797 int err;
651 798
652 799 /*
653 800 * Get the supported interrupt types.
654 801 */
655 802 err = ddi_intr_get_supported_types(atgep->atge_dip,
656 803 &atgep->atge_intr_types);
657 804 if (err != DDI_SUCCESS) {
658 805 atge_error(atgep->atge_dip,
659 806 "ddi_intr_get_supported_types failed : %d", err);
660 807 return (DDI_FAILURE);
661 808 }
662 809
663 810 ATGE_DB(("%s: ddi_intr_get_supported_types() returned : %d",
664 811 atgep->atge_name, atgep->atge_intr_types));
665 812
666 813
667 814 if (atgep->atge_intr_types & DDI_INTR_TYPE_MSIX) {
668 815 err = atge_add_intr_handler(atgep, DDI_INTR_TYPE_MSIX);
669 816 if (err == DDI_SUCCESS) {
670 817 ATGE_DB(("%s: Using MSIx for interrupt",
671 818 atgep->atge_name));
672 819 return (err);
673 820 }
674 821 }
675 822
676 823 if (atgep->atge_intr_types & DDI_INTR_TYPE_MSI) {
677 824 err = atge_add_intr_handler(atgep, DDI_INTR_TYPE_MSI);
678 825 if (err == DDI_SUCCESS) {
679 826 ATGE_DB(("%s: Using MSI for interrupt",
680 827 atgep->atge_name));
681 828 return (err);
682 829 }
683 830 }
684 831
685 832 err = DDI_FAILURE;
686 833 if (atgep->atge_intr_types & DDI_INTR_TYPE_FIXED) {
687 834 err = atge_add_intr_handler(atgep, DDI_INTR_TYPE_FIXED);
688 835 if (err == DDI_SUCCESS) {
689 836 ATGE_DB(("%s: Using FIXED type for interrupt",
690 837 atgep->atge_name));
691 838 return (err);
692 839 }
693 840 }
694 841
695 842 return (err);
696 843 }
697 844
698 845 int
699 846 atge_identify_hardware(atge_t *atgep)
700 847 {
701 848 uint16_t vid, did;
|
↓ open down ↓ |
160 lines elided |
↑ open up ↑ |
702 849 int i;
703 850
704 851 vid = pci_config_get16(atgep->atge_conf_handle, PCI_CONF_VENID);
705 852 did = pci_config_get16(atgep->atge_conf_handle, PCI_CONF_DEVID);
706 853
707 854 atgep->atge_model = 0;
708 855 for (i = 0; i < (sizeof (atge_cards) / sizeof (atge_cards_t)); i++) {
709 856 if (atge_cards[i].vendor_id == vid &&
710 857 atge_cards[i].device_id == did) {
711 858 atgep->atge_model = atge_cards[i].model;
859 + atgep->atge_vid = vid;
860 + atgep->atge_did = did;
712 861 atgep->atge_revid =
713 862 pci_config_get8(atgep->atge_conf_handle,
714 863 PCI_CONF_REVID);
864 + atge_notice(atgep->atge_dip, "PCI-ID pci%x,%x,%x: %s",
865 + vid, did, atgep->atge_revid,
866 + atge_cards[i].cardname);
715 867 ATGE_DB(("%s: %s : PCI-ID pci%x,%x and model : %d",
716 868 atgep->atge_name, __func__, vid, did,
717 869 atgep->atge_model));
718 870
719 871 return (DDI_SUCCESS);
720 872 }
721 873 }
722 874
723 875 atge_error(atgep->atge_dip, "atge driver is attaching to unknown"
724 - " pci%d,%d vendor/device-id card", vid, did);
876 + " pci%x,%x vendor/device-id card", vid, did);
725 877
726 878 /*
727 - * Assume it's L1 chip.
879 + * Assume it's L1C chip.
728 880 */
729 - atgep->atge_model = ATGE_CHIP_L1;
881 + atgep->atge_model = ATGE_CHIP_L1C;
882 + atgep->atge_vid = vid;
883 + atgep->atge_did = did;
730 884 atgep->atge_revid = pci_config_get8(atgep->atge_conf_handle,
731 885 PCI_CONF_REVID);
732 886
733 887 /*
734 888 * We will leave the decision to caller.
735 889 */
736 890 return (DDI_FAILURE);
737 891 }
738 892
739 893 int
740 894 atge_get_macaddr(atge_t *atgep)
741 895 {
742 896 uint32_t reg;
743 897
744 898 reg = INL(atgep, ATGE_SPI_CTRL);
745 899 if ((reg & SPI_VPD_ENB) != 0) {
746 900 /*
747 901 * Get VPD stored in TWSI EEPROM.
748 902 */
749 903 reg &= ~SPI_VPD_ENB;
750 904 OUTL(atgep, ATGE_SPI_CTRL, reg);
751 905
752 906 ATGE_DB(("%s: %s called Get VPD", atgep->atge_name, __func__));
753 907 }
754 908
755 909 atgep->atge_ether_addr[5] = INB(atgep, ATGE_PAR0 + 0);
756 910 atgep->atge_ether_addr[4] = INB(atgep, ATGE_PAR0 + 1);
757 911 atgep->atge_ether_addr[3] = INB(atgep, ATGE_PAR0 + 2);
758 912 atgep->atge_ether_addr[2] = INB(atgep, ATGE_PAR0 + 3);
759 913 atgep->atge_ether_addr[1] = INB(atgep, ATGE_PAR1 + 0);
760 914 atgep->atge_ether_addr[0] = INB(atgep, ATGE_PAR1 + 1);
761 915
762 916 ATGE_DB(("%s: %s() Station Address - %x:%x:%x:%x:%x:%x",
763 917 atgep->atge_name, __func__,
764 918 atgep->atge_ether_addr[0],
765 919 atgep->atge_ether_addr[1],
766 920 atgep->atge_ether_addr[2],
|
↓ open down ↓ |
27 lines elided |
↑ open up ↑ |
767 921 atgep->atge_ether_addr[3],
768 922 atgep->atge_ether_addr[4],
769 923 atgep->atge_ether_addr[5]));
770 924
771 925 bcopy(atgep->atge_ether_addr, atgep->atge_dev_addr, ETHERADDRL);
772 926
773 927 return (DDI_SUCCESS);
774 928 }
775 929
776 930 /*
777 - * Reset functionality for L1 and L1E. It's same.
931 + * Reset functionality for L1, L1E, and L1C. It's same.
778 932 */
779 933 static void
780 934 atge_device_reset(atge_t *atgep)
781 935 {
782 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E ||
783 - ATGE_MODEL(atgep) == ATGE_CHIP_L1)
936 + switch (ATGE_MODEL(atgep)) {
937 + case ATGE_CHIP_L1E:
938 + case ATGE_CHIP_L1:
939 + case ATGE_CHIP_L1C:
784 940 atge_device_reset_l1_l1e(atgep);
941 + break;
942 + }
785 943 }
786 944
787 945 void
788 946 atge_device_reset_l1_l1e(atge_t *atgep)
789 947 {
790 948 uint32_t reg;
791 949 int t;
792 -
793 - OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET);
950 + switch (ATGE_MODEL(atgep)) {
951 + case ATGE_CHIP_L1C:
952 + OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET | 0x40);
953 + break;
954 + default:
955 + OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET);
956 + break;
957 + }
794 958 reg = INL(atgep, ATGE_MASTER_CFG);
795 959 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
796 960 drv_usecwait(10);
797 961 reg = INL(atgep, ATGE_MASTER_CFG);
798 962 if ((reg & MASTER_RESET) == 0)
799 963 break;
800 964 }
801 965
802 966 if (t == 0) {
803 967 atge_error(atgep->atge_dip, " master reset timeout reg : %x",
804 968 reg);
805 969 }
806 970
807 971 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
808 972 if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0)
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
809 973 break;
810 974
811 975 drv_usecwait(10);
812 976 }
813 977
814 978 if (t == 0) {
815 979 atge_error(atgep->atge_dip, "device reset timeout reg : %x",
816 980 reg);
817 981 }
818 982
819 - /*
820 - * Initialize PCIe module. These values came from FreeBSD and
821 - * we don't know the meaning of it.
822 - */
823 - OUTL(atgep, 0x12FC, 0x6500);
824 - reg = INL(atgep, 0x1008) | 0x8000;
825 - OUTL(atgep, 0x1008, reg);
983 + switch (ATGE_MODEL(atgep)) {
984 + case ATGE_CHIP_L1E:
985 + case ATGE_CHIP_L1:
986 + /*
987 + * Initialize PCIe module. These values came from FreeBSD and
988 + * we don't know the meaning of it.
989 + */
990 + OUTL(atgep, ATGE_LTSSM_ID_CFG, 0x6500);
991 + reg = INL(atgep, 0x1008) | 0x8000;
992 + OUTL(atgep, 0x1008, reg);
993 + break;
994 + case ATGE_CHIP_L1C:
995 + break;
996 + }
826 997
827 998 /*
828 999 * Get chip revision.
829 1000 */
830 1001 atgep->atge_chip_rev = INL(atgep, ATGE_MASTER_CFG) >>
831 1002 MASTER_CHIP_REV_SHIFT;
832 1003
833 1004 ATGE_DB(("%s: %s reset successfully rev : %x", atgep->atge_name,
834 1005 __func__, atgep->atge_chip_rev));
835 1006 }
836 1007
837 1008 /*
838 1009 * DMA allocation for L1 and L1E is bit different since L1E uses RX pages
839 1010 * instead of descriptor based RX model.
840 1011 */
841 1012 static int
842 1013 atge_alloc_dma(atge_t *atgep)
843 1014 {
844 1015 int err = DDI_FAILURE;
845 1016
846 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1017 + switch (ATGE_MODEL(atgep)) {
1018 + case ATGE_CHIP_L1E:
847 1019 err = atge_l1e_alloc_dma(atgep);
848 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
1020 + break;
1021 + case ATGE_CHIP_L1:
849 1022 err = atge_l1_alloc_dma(atgep);
1023 + break;
1024 + case ATGE_CHIP_L1C:
1025 + err = atge_l1c_alloc_dma(atgep);
1026 + break;
850 1027 }
851 1028
852 1029 return (err);
853 1030 }
854 1031
855 1032 static void
856 1033 atge_free_dma(atge_t *atgep)
857 1034 {
858 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1035 + switch (ATGE_MODEL(atgep)) {
1036 + case ATGE_CHIP_L1E:
859 1037 atge_l1e_free_dma(atgep);
1038 + break;
1039 + case ATGE_CHIP_L1:
1040 + atge_l1_free_dma(atgep);
1041 + break;
1042 + case ATGE_CHIP_L1C:
1043 + atge_l1c_free_dma(atgep);
1044 + break;
860 1045 }
861 1046 }
862 1047
863 1048 /*
864 1049 * Attach entry point in the driver.
865 1050 */
866 1051 static int
867 1052 atge_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd)
868 1053 {
869 1054 atge_t *atgep;
870 1055 mac_register_t *macreg;
871 1056 int instance;
872 1057 uint16_t cap_ptr;
873 1058 uint16_t burst;
874 1059 int err;
875 1060 mii_ops_t *mii_ops;
876 1061
877 1062 instance = ddi_get_instance(devinfo);
878 1063
879 1064 switch (cmd) {
880 - default:
881 - return (DDI_FAILURE);
882 -
883 1065 case DDI_RESUME:
884 1066 return (atge_resume(devinfo));
885 1067
886 1068 case DDI_ATTACH:
887 1069 ddi_set_driver_private(devinfo, NULL);
888 1070 break;
1071 + default:
1072 + return (DDI_FAILURE);
1073 +
889 1074 }
890 1075
891 1076 atgep = kmem_zalloc(sizeof (atge_t), KM_SLEEP);
892 1077 ddi_set_driver_private(devinfo, atgep);
893 1078 atgep->atge_dip = devinfo;
894 1079
895 1080 /*
896 1081 * Setup name and instance number to be used for debugging and
897 1082 * error reporting.
898 1083 */
899 1084 (void) snprintf(atgep->atge_name, sizeof (atgep->atge_name), "%s%d",
900 1085 "atge", instance);
901 1086
902 1087
903 1088 /*
904 1089 * Map PCI config space.
905 1090 */
906 1091 err = pci_config_setup(devinfo, &atgep->atge_conf_handle);
907 1092 if (err != DDI_SUCCESS) {
908 1093 atge_error(devinfo, "pci_config_setup() failed");
909 1094 goto fail1;
910 1095 }
911 1096
912 1097 (void) atge_identify_hardware(atgep);
913 1098
914 1099 /*
915 1100 * Map Device registers.
916 1101 */
917 1102 err = ddi_regs_map_setup(devinfo, ATGE_PCI_REG_NUMBER,
918 1103 &atgep->atge_io_regs, 0, 0, &atge_dev_attr, &atgep->atge_io_handle);
919 1104 if (err != DDI_SUCCESS) {
920 1105 atge_error(devinfo, "ddi_regs_map_setup() failed");
921 1106 goto fail2;
922 1107 }
923 1108
924 1109 /*
925 1110 * Add interrupt and its associated handler.
926 1111 */
927 1112 err = atge_add_intr(atgep);
928 1113 if (err != DDI_SUCCESS) {
929 1114 atge_error(devinfo, "Failed to add interrupt handler");
930 1115 goto fail3;
931 1116 }
932 1117
933 1118 mutex_init(&atgep->atge_intr_lock, NULL, MUTEX_DRIVER,
934 1119 DDI_INTR_PRI(atgep->atge_intr_pri));
935 1120
936 1121 mutex_init(&atgep->atge_tx_lock, NULL, MUTEX_DRIVER,
937 1122 DDI_INTR_PRI(atgep->atge_intr_pri));
938 1123
939 1124 mutex_init(&atgep->atge_rx_lock, NULL, MUTEX_DRIVER,
940 1125 DDI_INTR_PRI(atgep->atge_intr_pri));
941 1126
942 1127 mutex_init(&atgep->atge_mii_lock, NULL, MUTEX_DRIVER, NULL);
943 1128
|
↓ open down ↓ |
45 lines elided |
↑ open up ↑ |
944 1129 /*
945 1130 * Used to lock down MBOX register on L1 chip since RX consumer,
946 1131 * TX producer and RX return ring consumer are shared.
947 1132 */
948 1133 mutex_init(&atgep->atge_mbox_lock, NULL, MUTEX_DRIVER,
949 1134 DDI_INTR_PRI(atgep->atge_intr_pri));
950 1135
951 1136 atgep->atge_link_state = LINK_STATE_DOWN;
952 1137 atgep->atge_mtu = ETHERMTU;
953 1138
954 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1139 + switch (ATGE_MODEL(atgep)) {
1140 + case ATGE_CHIP_L1E:
955 1141 if (atgep->atge_revid > 0xF0) {
956 1142 /* L2E Rev. B. AR8114 */
957 1143 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
958 1144 } else {
959 1145 if ((INL(atgep, L1E_PHY_STATUS) &
960 1146 PHY_STATUS_100M) != 0) {
961 1147 /* L1E AR8121 */
962 1148 atgep->atge_flags |= ATGE_FLAG_JUMBO;
963 1149 } else {
964 1150 /* L2E Rev. A. AR8113 */
965 1151 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
966 1152 }
967 1153 }
1154 + break;
1155 + case ATGE_CHIP_L1:
1156 + break;
1157 + case ATGE_CHIP_L1C:
1158 + /*
1159 + * One odd thing is AR8132 uses the same PHY hardware(F1
1160 + * gigabit PHY) of AR8131. So atphy(4) of AR8132 reports
1161 + * the PHY supports 1000Mbps but that's not true. The PHY
1162 + * used in AR8132 can't establish gigabit link even if it
1163 + * shows the same PHY model/revision number of AR8131.
1164 + *
1165 + * It seems that AR813x/AR815x has silicon bug for SMB. In
1166 + * addition, Atheros said that enabling SMB wouldn't improve
1167 + * performance. However I think it's bad to access lots of
1168 + * registers to extract MAC statistics.
1169 + *
1170 + * Don't use Tx CMB. It is known to have silicon bug.
1171 + */
1172 + switch (ATGE_DID(atgep)) {
1173 + case ATGE_CHIP_AR8152V2_DEV_ID:
1174 + case ATGE_CHIP_AR8152V1_DEV_ID:
1175 + atgep->atge_flags |= ATGE_FLAG_APS |
1176 + ATGE_FLAG_FASTETHER |
1177 + ATGE_FLAG_ASPM_MON | ATGE_FLAG_JUMBO |
1178 + ATGE_FLAG_SMB_BUG | ATGE_FLAG_CMB_BUG;
1179 + break;
1180 + case ATGE_CHIP_AR8151V2_DEV_ID:
1181 + case ATGE_CHIP_AR8151V1_DEV_ID:
1182 + atgep->atge_flags |= ATGE_FLAG_APS |
1183 + ATGE_FLAG_ASPM_MON | ATGE_FLAG_JUMBO |
1184 + ATGE_FLAG_SMB_BUG | ATGE_FLAG_CMB_BUG;
1185 + break;
1186 + case ATGE_CHIP_L1CF_DEV_ID:
1187 + atgep->atge_flags |= ATGE_FLAG_FASTETHER;
1188 + break;
1189 + case ATGE_CHIP_L1CG_DEV_ID:
1190 + break;
1191 + }
1192 + break;
968 1193 }
969 1194
970 1195 /*
971 1196 * Get DMA parameters from PCIe device control register.
972 1197 */
973 1198 err = PCI_CAP_LOCATE(atgep->atge_conf_handle, PCI_CAP_ID_PCI_E,
974 1199 &cap_ptr);
975 1200
976 1201 if (err == DDI_FAILURE) {
977 1202 atgep->atge_dma_rd_burst = DMA_CFG_RD_BURST_128;
978 1203 atgep->atge_dma_wr_burst = DMA_CFG_WR_BURST_128;
979 1204 } else {
980 1205 atgep->atge_flags |= ATGE_FLAG_PCIE;
981 1206 burst = pci_config_get16(atgep->atge_conf_handle,
982 1207 cap_ptr + 0x08);
983 1208
984 1209 /*
985 1210 * Max read request size.
986 1211 */
987 1212 atgep->atge_dma_rd_burst = ((burst >> 12) & 0x07) <<
988 1213 DMA_CFG_RD_BURST_SHIFT;
989 1214
990 1215 /*
991 1216 * Max Payload Size.
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
992 1217 */
993 1218 atgep->atge_dma_wr_burst = ((burst >> 5) & 0x07) <<
994 1219 DMA_CFG_WR_BURST_SHIFT;
995 1220
996 1221 ATGE_DB(("%s: %s() MRR : %d, MPS : %d",
997 1222 atgep->atge_name, __func__,
998 1223 (128 << ((burst >> 12) & 0x07)),
999 1224 (128 << ((burst >> 5) & 0x07))));
1000 1225 }
1001 1226
1227 + /* Clear data link and flow-control protocol error. */
1228 + switch (ATGE_MODEL(atgep)) {
1229 + case ATGE_CHIP_L1E:
1230 + break;
1231 + case ATGE_CHIP_L1:
1232 + break;
1233 + case ATGE_CHIP_L1C:
1234 + OUTL_AND(atgep, ATGE_PEX_UNC_ERR_SEV,
1235 + ~(PEX_UNC_ERR_SEV_UC | PEX_UNC_ERR_SEV_FCP));
1236 + OUTL_AND(atgep, ATGE_LTSSM_ID_CFG, ~LTSSM_ID_WRO_ENB);
1237 + OUTL_OR(atgep, ATGE_PCIE_PHYMISC, PCIE_PHYMISC_FORCE_RCV_DET);
1238 + break;
1239 + }
1240 +
1002 1241 /*
1003 1242 * Allocate DMA resources.
1004 1243 */
1005 1244 err = atge_alloc_dma(atgep);
1006 1245 if (err != DDI_SUCCESS) {
1007 1246 atge_error(devinfo, "Failed to allocate DMA resources");
1008 1247 goto fail4;
1009 1248 }
1010 1249
1011 1250 /*
1012 1251 * Get station address.
1013 1252 */
1014 1253 (void) atge_get_macaddr(atgep);
1015 1254
1016 1255 /*
1017 1256 * Setup MII.
1018 1257 */
1019 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1258 + switch (ATGE_MODEL(atgep)) {
1259 + case ATGE_CHIP_L1E:
1020 1260 mii_ops = &atge_l1e_mii_ops;
1021 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
1261 + break;
1262 + case ATGE_CHIP_L1:
1022 1263 mii_ops = &atge_l1_mii_ops;
1264 + break;
1265 + case ATGE_CHIP_L1C:
1266 + mii_ops = &atge_l1c_mii_ops;
1267 + break;
1023 1268 }
1024 1269
1025 1270 if ((atgep->atge_mii = mii_alloc(atgep, devinfo,
1026 1271 mii_ops)) == NULL) {
1027 1272 atge_error(devinfo, "mii_alloc() failed");
1028 1273 goto fail4;
1029 1274 }
1030 1275
1031 1276 /*
1032 1277 * Register with MAC layer.
1033 1278 */
1034 1279 if ((macreg = mac_alloc(MAC_VERSION)) == NULL) {
1035 1280 atge_error(devinfo, "mac_alloc() failed due to version");
1036 1281 goto fail4;
1037 1282 }
1038 1283
1039 1284 macreg->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
1040 1285 macreg->m_driver = atgep;
1041 1286 macreg->m_dip = devinfo;
1042 1287 macreg->m_instance = instance;
1043 1288 macreg->m_src_addr = atgep->atge_ether_addr;
1044 1289 macreg->m_callbacks = &atge_m_callbacks;
1045 1290 macreg->m_min_sdu = 0;
1046 1291 macreg->m_max_sdu = atgep->atge_mtu;
1047 1292 macreg->m_margin = VLAN_TAGSZ;
1048 1293
1049 1294 if ((err = mac_register(macreg, &atgep->atge_mh)) != 0) {
1050 1295 atge_error(devinfo, "mac_register() failed with :%d", err);
1051 1296 mac_free(macreg);
1052 1297 goto fail4;
1053 1298 }
1054 1299
1055 1300 mac_free(macreg);
1056 1301
1057 1302 ATGE_DB(("%s: %s() driver attached successfully",
1058 1303 atgep->atge_name, __func__));
1059 1304
1060 1305 atge_device_reset(atgep);
1061 1306
1062 1307 atgep->atge_chip_state = ATGE_CHIP_INITIALIZED;
1063 1308
1064 1309 /*
|
↓ open down ↓ |
32 lines elided |
↑ open up ↑ |
1065 1310 * At last - enable interrupts.
1066 1311 */
1067 1312 err = atge_enable_intrs(atgep);
1068 1313 if (err == DDI_FAILURE) {
1069 1314 goto fail5;
1070 1315 }
1071 1316
1072 1317 /*
1073 1318 * Reset the PHY before starting.
1074 1319 */
1075 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1320 + switch (ATGE_MODEL(atgep)) {
1321 + case ATGE_CHIP_L1E:
1076 1322 atge_l1e_mii_reset(atgep);
1077 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
1323 + break;
1324 + case ATGE_CHIP_L1:
1078 1325 atge_l1_mii_reset(atgep);
1326 + break;
1327 + case ATGE_CHIP_L1C:
1328 + atge_l1c_mii_reset(atgep);
1329 + break;
1079 1330 }
1080 1331
1081 1332 /*
1082 1333 * Let the PHY run.
1083 1334 */
1084 1335 mii_start(atgep->atge_mii);
1085 1336
1086 1337 return (DDI_SUCCESS);
1087 1338
1088 1339 fail5:
1089 1340 (void) mac_unregister(atgep->atge_mh);
1090 1341 atge_device_stop(atgep);
1091 1342 mii_stop(atgep->atge_mii);
1092 1343 mii_free(atgep->atge_mii);
1093 1344 fail4:
1094 1345 atge_free_dma(atgep);
1095 1346 mutex_destroy(&atgep->atge_intr_lock);
1096 1347 mutex_destroy(&atgep->atge_tx_lock);
1097 1348 mutex_destroy(&atgep->atge_rx_lock);
1098 1349 atge_remove_intr(atgep);
1099 1350 fail3:
1100 1351 ddi_regs_map_free(&atgep->atge_io_handle);
1101 1352 fail2:
1102 1353 pci_config_teardown(&atgep->atge_conf_handle);
1103 1354 fail1:
1104 1355 if (atgep)
1105 1356 kmem_free(atgep, sizeof (atge_t));
1106 1357
1107 1358 return (DDI_FAILURE);
1108 1359 }
1109 1360
1110 1361 static int
1111 1362 atge_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1112 1363 {
1113 1364 atge_t *atgep;
1114 1365
1115 1366 atgep = ddi_get_driver_private(dip);
1116 1367 if (atgep == NULL) {
1117 1368 atge_error(dip, "No soft state in detach");
1118 1369 return (DDI_FAILURE);
1119 1370 }
1120 1371
1121 1372 switch (cmd) {
1122 1373 case DDI_DETACH:
1123 1374
1124 1375 /*
1125 1376 * First unregister with MAC layer before stopping DMA
1126 1377 */
1127 1378 if (mac_disable(atgep->atge_mh) != DDI_SUCCESS)
1128 1379 return (DDI_FAILURE);
1129 1380
1130 1381 mii_stop(atgep->atge_mii);
1131 1382
1132 1383 mutex_enter(&atgep->atge_intr_lock);
1133 1384 mutex_enter(&atgep->atge_tx_lock);
1134 1385 atge_device_stop(atgep);
1135 1386 mutex_exit(&atgep->atge_tx_lock);
1136 1387 mutex_exit(&atgep->atge_intr_lock);
1137 1388
1138 1389 mii_free(atgep->atge_mii);
1139 1390 atge_free_dma(atgep);
1140 1391
1141 1392 ddi_regs_map_free(&atgep->atge_io_handle);
1142 1393 atge_remove_intr(atgep);
1143 1394 pci_config_teardown(&atgep->atge_conf_handle);
1144 1395
1145 1396 (void) mac_unregister(atgep->atge_mh);
1146 1397 mutex_destroy(&atgep->atge_intr_lock);
1147 1398 mutex_destroy(&atgep->atge_tx_lock);
1148 1399 mutex_destroy(&atgep->atge_rx_lock);
1149 1400 kmem_free(atgep, sizeof (atge_t));
1150 1401 ddi_set_driver_private(dip, NULL);
1151 1402
1152 1403 return (DDI_SUCCESS);
1153 1404
1154 1405 case DDI_SUSPEND:
1155 1406 ATGE_DB(("%s: %s() is being suspended",
1156 1407 atgep->atge_name, __func__));
1157 1408
1158 1409 /*
1159 1410 * Suspend monitoring MII.
1160 1411 */
1161 1412 mii_suspend(atgep->atge_mii);
1162 1413
1163 1414 mutex_enter(&atgep->atge_intr_lock);
1164 1415 mutex_enter(&atgep->atge_tx_lock);
1165 1416 atgep->atge_chip_state |= ATGE_CHIP_SUSPENDED;
1166 1417 atge_device_stop(atgep);
1167 1418 mutex_exit(&atgep->atge_tx_lock);
1168 1419 mutex_exit(&atgep->atge_intr_lock);
1169 1420
1170 1421 return (DDI_SUCCESS);
1171 1422
1172 1423 default:
1173 1424 return (DDI_FAILURE);
1174 1425 }
1175 1426 }
1176 1427
1177 1428 int
1178 1429 atge_alloc_buffers(atge_ring_t *r, size_t rcnt, size_t buflen, int f)
1179 1430 {
1180 1431 atge_dma_t *dma;
1181 1432 atge_dma_t **tbl;
1182 1433 int err = DDI_SUCCESS;
1183 1434 int i;
1184 1435
1185 1436 tbl = kmem_zalloc(rcnt * sizeof (atge_dma_t *), KM_SLEEP);
1186 1437 r->r_buf_tbl = tbl;
1187 1438
1188 1439 for (i = 0; i < rcnt; i++) {
1189 1440 dma = atge_buf_alloc(r->r_atge, buflen, f);
1190 1441 if (dma == NULL) {
1191 1442 err = DDI_FAILURE;
1192 1443 break;
1193 1444 }
1194 1445
1195 1446 tbl[i] = dma;
1196 1447 }
1197 1448
1198 1449 return (err);
1199 1450 }
1200 1451
1201 1452 void
1202 1453 atge_free_buffers(atge_ring_t *r, size_t rcnt)
1203 1454 {
1204 1455 atge_dma_t **tbl;
1205 1456 int i;
1206 1457
1207 1458 if (r == NULL || r->r_buf_tbl == NULL)
1208 1459 return;
1209 1460
1210 1461 tbl = r->r_buf_tbl;
1211 1462 for (i = 0; i < rcnt; i++) {
1212 1463 if (tbl[i] != NULL) {
1213 1464 atge_buf_free(tbl[i]);
1214 1465 }
1215 1466 }
1216 1467
1217 1468 kmem_free(tbl, rcnt * sizeof (atge_dma_t *));
1218 1469 }
1219 1470
1220 1471 atge_dma_t *
1221 1472 atge_alloc_a_dma_blk(atge_t *atgep, ddi_dma_attr_t *attr, int size, int d)
1222 1473 {
1223 1474 int err;
1224 1475 atge_dma_t *dma;
1225 1476
1226 1477 dma = kmem_zalloc(sizeof (atge_dma_t), KM_SLEEP);
1227 1478
1228 1479 err = ddi_dma_alloc_handle(atgep->atge_dip, attr,
1229 1480 DDI_DMA_SLEEP, NULL, &dma->hdl);
1230 1481
1231 1482 if (err != DDI_SUCCESS) {
1232 1483 atge_error(atgep->atge_dip, "%s() : failed"
1233 1484 " in ddi_dma_alloc_handle() : %d", __func__, err);
1234 1485 goto fail;
1235 1486 }
1236 1487
1237 1488 err = ddi_dma_mem_alloc(dma->hdl,
1238 1489 size, &atge_buf_attr, DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL,
1239 1490 &dma->addr, &dma->len, &dma->acchdl);
1240 1491
1241 1492 if (err != DDI_SUCCESS) {
1242 1493 atge_error(atgep->atge_dip, "%s() : failed"
1243 1494 " in ddi_dma_mem_alloc() : %d", __func__, err);
1244 1495 ddi_dma_free_handle(&dma->hdl);
1245 1496 goto fail;
1246 1497 }
1247 1498
1248 1499 err = ddi_dma_addr_bind_handle(dma->hdl, NULL, dma->addr,
1249 1500 dma->len, d | DDI_DMA_CONSISTENT, DDI_DMA_SLEEP,
1250 1501 NULL, &dma->cookie, &dma->count);
1251 1502
1252 1503 if (err != DDI_SUCCESS) {
1253 1504 atge_error(atgep->atge_dip, "%s() : failed"
1254 1505 " in ddi_dma_addr_bind_handle() : %d", __func__, err);
1255 1506 ddi_dma_mem_free(&dma->acchdl);
1256 1507 ddi_dma_free_handle(&dma->hdl);
1257 1508 goto fail;
1258 1509 }
1259 1510
1260 1511 return (dma);
1261 1512 fail:
1262 1513 kmem_free(dma, sizeof (atge_dma_t));
1263 1514 return (NULL);
1264 1515 }
1265 1516
1266 1517 void
1267 1518 atge_free_a_dma_blk(atge_dma_t *dma)
1268 1519 {
1269 1520 if (dma != NULL) {
1270 1521 (void) ddi_dma_unbind_handle(dma->hdl);
1271 1522 ddi_dma_mem_free(&dma->acchdl);
1272 1523 ddi_dma_free_handle(&dma->hdl);
1273 1524 kmem_free(dma, sizeof (atge_dma_t));
1274 1525 }
1275 1526 }
1276 1527
1277 1528 atge_dma_t *
1278 1529 atge_buf_alloc(atge_t *atgep, size_t len, int f)
1279 1530 {
1280 1531 atge_dma_t *dma = NULL;
1281 1532 int err;
1282 1533
1283 1534 dma = kmem_zalloc(sizeof (atge_dma_t), KM_SLEEP);
1284 1535
1285 1536 err = ddi_dma_alloc_handle(atgep->atge_dip, &atge_dma_attr_buf,
1286 1537 DDI_DMA_SLEEP, NULL, &dma->hdl);
1287 1538
1288 1539 if (err != DDI_SUCCESS) {
1289 1540 atge_error(atgep->atge_dip, "%s() : failed"
1290 1541 " in %s() : %d", __func__, err);
1291 1542 goto fail;
1292 1543 }
1293 1544
1294 1545 err = ddi_dma_mem_alloc(dma->hdl, len, &atge_buf_attr,
1295 1546 DDI_DMA_STREAMING, DDI_DMA_SLEEP, NULL, &dma->addr,
1296 1547 &dma->len, &dma->acchdl);
1297 1548
1298 1549 if (err != DDI_SUCCESS) {
1299 1550 atge_error(atgep->atge_dip, "%s() : failed"
1300 1551 " in %s() : %d", __func__, err);
1301 1552 ddi_dma_free_handle(&dma->hdl);
1302 1553 goto fail;
1303 1554 }
1304 1555
1305 1556 err = ddi_dma_addr_bind_handle(dma->hdl, NULL, dma->addr, dma->len,
1306 1557 (f | DDI_DMA_CONSISTENT), DDI_DMA_SLEEP, NULL, &dma->cookie,
1307 1558 &dma->count);
1308 1559
1309 1560 if (err != DDI_SUCCESS) {
1310 1561 atge_error(atgep->atge_dip, "%s() : failed"
1311 1562 " in %s() : %d", __func__, err);
1312 1563 ddi_dma_mem_free(&dma->acchdl);
1313 1564 ddi_dma_free_handle(&dma->hdl);
1314 1565 goto fail;
1315 1566 }
1316 1567
1317 1568 /*
1318 1569 * Number of return'ed cookie should be one.
1319 1570 */
1320 1571 ASSERT(dma->count == 1);
1321 1572
1322 1573 return (dma);
1323 1574 fail:
1324 1575 kmem_free(dma, sizeof (atge_dma_t));
1325 1576 return (NULL);
1326 1577 }
1327 1578
1328 1579 void
1329 1580 atge_buf_free(atge_dma_t *dma)
1330 1581 {
1331 1582 ASSERT(dma != NULL);
1332 1583
1333 1584 (void) ddi_dma_unbind_handle(dma->hdl);
1334 1585 ddi_dma_mem_free(&dma->acchdl);
1335 1586 ddi_dma_free_handle(&dma->hdl);
1336 1587 kmem_free(dma, sizeof (atge_dma_t));
1337 1588 }
1338 1589
1339 1590 static int
1340 1591 atge_resume(dev_info_t *dip)
1341 1592 {
1342 1593 atge_t *atgep;
1343 1594
1344 1595 if ((atgep = ddi_get_driver_private(dip)) == NULL) {
1345 1596 return (DDI_FAILURE);
1346 1597 }
1347 1598
1348 1599 mutex_enter(&atgep->atge_intr_lock);
1349 1600 mutex_enter(&atgep->atge_tx_lock);
1350 1601
1351 1602 atgep->atge_chip_state &= ~ATGE_CHIP_SUSPENDED;
1352 1603
1353 1604 if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
1354 1605 atge_device_restart(atgep);
|
↓ open down ↓ |
266 lines elided |
↑ open up ↑ |
1355 1606 } else {
1356 1607 atge_device_reset(atgep);
1357 1608 }
1358 1609
1359 1610 mutex_exit(&atgep->atge_tx_lock);
1360 1611 mutex_exit(&atgep->atge_intr_lock);
1361 1612
1362 1613 /*
1363 1614 * Reset the PHY before resuming MII.
1364 1615 */
1365 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1616 + switch (ATGE_MODEL(atgep)) {
1617 + case ATGE_CHIP_L1E:
1366 1618 atge_l1e_mii_reset(atgep);
1619 + break;
1620 + case ATGE_CHIP_L1:
1621 + break;
1622 + case ATGE_CHIP_L1C:
1623 + break;
1367 1624 }
1368 1625
1369 1626 mii_resume(atgep->atge_mii);
1370 1627
1371 1628 /* kick-off downstream */
1372 1629 mac_tx_update(atgep->atge_mh);
1373 1630
1374 1631 return (DDI_SUCCESS);
1375 1632 }
1376 1633
1377 1634 static int
1378 1635 atge_quiesce(dev_info_t *dip)
1379 1636 {
1380 1637 atge_t *atgep;
1381 1638
1382 1639 if ((atgep = ddi_get_driver_private(dip)) == NULL) {
1383 1640 return (DDI_FAILURE);
1384 1641 }
1385 1642
1386 1643 atge_device_stop(atgep);
1387 1644
1388 1645 return (DDI_SUCCESS);
1389 1646 }
1390 1647
1391 1648 void
1392 1649 atge_add_multicst(atge_t *atgep, uint8_t *macaddr)
1393 1650 {
1394 1651 uint32_t crc;
1395 1652 int bit;
1396 1653
1397 1654 ASSERT(MUTEX_HELD(&atgep->atge_intr_lock));
1398 1655 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
1399 1656
1400 1657 ATGE_DB(("%s: %s() %x:%x:%x:%x:%x:%x",
1401 1658 atgep->atge_name, __func__, macaddr[0], macaddr[1], macaddr[2],
1402 1659 macaddr[3], macaddr[4], macaddr[5]));
1403 1660
1404 1661 crc = atge_ether_crc(macaddr, ETHERADDRL);
1405 1662 bit = (crc >> 26);
1406 1663 atgep->atge_mchash_ref_cnt[bit]++;
1407 1664 atgep->atge_mchash |= (1ULL << (crc >> 26));
1408 1665
1409 1666 ATGE_DB(("%s: %s() mchash :%llx, bit : %d,"
1410 1667 " atge_mchash_ref_cnt[bit] :%d",
1411 1668 atgep->atge_name, __func__, atgep->atge_mchash, bit,
1412 1669 atgep->atge_mchash_ref_cnt[bit]));
1413 1670 }
1414 1671
1415 1672 void
1416 1673 atge_remove_multicst(atge_t *atgep, uint8_t *macaddr)
1417 1674 {
1418 1675 uint32_t crc;
1419 1676 int bit;
1420 1677
1421 1678 ASSERT(MUTEX_HELD(&atgep->atge_intr_lock));
1422 1679 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
1423 1680
1424 1681 ATGE_DB(("%s: %s() %x:%x:%x:%x:%x:%x",
1425 1682 atgep->atge_name, __func__, macaddr[0], macaddr[1], macaddr[2],
1426 1683 macaddr[3], macaddr[4], macaddr[5]));
1427 1684
1428 1685 crc = atge_ether_crc(macaddr, ETHERADDRL);
1429 1686 bit = (crc >> 26);
1430 1687 atgep->atge_mchash_ref_cnt[bit]--;
1431 1688 if (atgep->atge_mchash_ref_cnt[bit] == 0)
1432 1689 atgep->atge_mchash &= ~(1ULL << (crc >> 26));
1433 1690
1434 1691 ATGE_DB(("%s: %s() mchash :%llx, bit : %d,"
1435 1692 " atge_mchash_ref_cnt[bit] :%d",
1436 1693 atgep->atge_name, __func__, atgep->atge_mchash, bit,
1437 1694 atgep->atge_mchash_ref_cnt[bit]));
1438 1695 }
1439 1696
1440 1697 int
1441 1698 atge_m_multicst(void *arg, boolean_t add, const uint8_t *macaddr)
1442 1699 {
1443 1700 atge_t *atgep = arg;
1444 1701
1445 1702 mutex_enter(&atgep->atge_intr_lock);
1446 1703 mutex_enter(&atgep->atge_tx_lock);
1447 1704
1448 1705 if (add) {
1449 1706 atge_add_multicst(atgep, (uint8_t *)macaddr);
1450 1707 } else {
1451 1708 atge_remove_multicst(atgep, (uint8_t *)macaddr);
1452 1709 }
1453 1710
1454 1711 atge_rxfilter(atgep);
1455 1712
1456 1713 mutex_exit(&atgep->atge_tx_lock);
1457 1714 mutex_exit(&atgep->atge_intr_lock);
1458 1715
1459 1716 return (0);
1460 1717 }
1461 1718
1462 1719 int
1463 1720 atge_m_promisc(void *arg, boolean_t on)
1464 1721 {
1465 1722 atge_t *atgep = arg;
1466 1723
1467 1724 mutex_enter(&atgep->atge_intr_lock);
1468 1725 mutex_enter(&atgep->atge_tx_lock);
1469 1726
1470 1727 if (on) {
1471 1728 atgep->atge_filter_flags |= ATGE_PROMISC;
1472 1729 } else {
1473 1730 atgep->atge_filter_flags &= ~ATGE_PROMISC;
1474 1731 }
1475 1732
1476 1733 if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
1477 1734 atge_rxfilter(atgep);
1478 1735 }
1479 1736
1480 1737 mutex_exit(&atgep->atge_tx_lock);
1481 1738 mutex_exit(&atgep->atge_intr_lock);
1482 1739
1483 1740 return (0);
1484 1741 }
1485 1742
1486 1743 int
1487 1744 atge_m_unicst(void *arg, const uint8_t *macaddr)
1488 1745 {
1489 1746 atge_t *atgep = arg;
1490 1747
1491 1748 mutex_enter(&atgep->atge_intr_lock);
1492 1749 mutex_enter(&atgep->atge_tx_lock);
1493 1750 bcopy(macaddr, atgep->atge_ether_addr, ETHERADDRL);
1494 1751 atge_program_ether(atgep);
1495 1752 atge_rxfilter(atgep);
1496 1753 mutex_exit(&atgep->atge_tx_lock);
1497 1754 mutex_exit(&atgep->atge_intr_lock);
1498 1755
1499 1756 return (0);
1500 1757 }
1501 1758
1502 1759 mblk_t *
1503 1760 atge_m_tx(void *arg, mblk_t *mp)
1504 1761 {
1505 1762 atge_t *atgep = arg;
1506 1763 mblk_t *nmp;
1507 1764
1508 1765 mutex_enter(&atgep->atge_tx_lock);
1509 1766
1510 1767 /*
1511 1768 * This NIC does not like us to send pkt when link is down.
1512 1769 */
1513 1770 if (!(atgep->atge_link_state & LINK_STATE_UP)) {
1514 1771 atgep->atge_tx_resched = 1;
1515 1772
1516 1773 mutex_exit(&atgep->atge_tx_lock);
1517 1774 return (mp);
1518 1775 }
1519 1776
1520 1777 /*
1521 1778 * Don't send a pkt if chip isn't running or in suspended state.
1522 1779 */
1523 1780 if ((atgep->atge_chip_state & ATGE_CHIP_RUNNING) == 0 ||
1524 1781 atgep->atge_chip_state & ATGE_CHIP_SUSPENDED) {
1525 1782 atgep->atge_carrier_errors++;
1526 1783 atgep->atge_tx_resched = 1;
1527 1784
1528 1785 mutex_exit(&atgep->atge_tx_lock);
1529 1786 return (mp);
1530 1787 }
1531 1788
1532 1789 while (mp != NULL) {
1533 1790 nmp = mp->b_next;
1534 1791 mp->b_next = NULL;
1535 1792
1536 1793 if (atge_send_a_packet(atgep, mp) == DDI_FAILURE) {
1537 1794 mp->b_next = nmp;
1538 1795 break;
1539 1796 }
1540 1797
1541 1798 mp = nmp;
1542 1799 }
1543 1800
1544 1801 mutex_exit(&atgep->atge_tx_lock);
1545 1802 return (mp);
1546 1803 }
1547 1804
1548 1805 int
1549 1806 atge_m_start(void *arg)
1550 1807 {
1551 1808 atge_t *atgep = arg;
1552 1809 int started = 0;
1553 1810
1554 1811 ASSERT(atgep != NULL);
1555 1812
1556 1813
1557 1814 mii_stop(atgep->atge_mii);
1558 1815
1559 1816 mutex_enter(&atgep->atge_intr_lock);
1560 1817 mutex_enter(&atgep->atge_tx_lock);
1561 1818
1562 1819 if (!(atgep->atge_chip_state & ATGE_CHIP_SUSPENDED)) {
1563 1820 atge_device_restart(atgep);
1564 1821 started = 1;
1565 1822 }
1566 1823
1567 1824 mutex_exit(&atgep->atge_tx_lock);
1568 1825 mutex_exit(&atgep->atge_intr_lock);
1569 1826
1570 1827 mii_start(atgep->atge_mii);
1571 1828
1572 1829 /* kick-off downstream */
1573 1830 if (started)
1574 1831 mac_tx_update(atgep->atge_mh);
1575 1832
1576 1833 return (0);
1577 1834 }
1578 1835
1579 1836 void
1580 1837 atge_m_stop(void *arg)
1581 1838 {
1582 1839 atge_t *atgep = arg;
1583 1840
1584 1841 mii_stop(atgep->atge_mii);
1585 1842
1586 1843 /*
1587 1844 * Cancel any pending I/O.
1588 1845 */
1589 1846 mutex_enter(&atgep->atge_intr_lock);
1590 1847 atgep->atge_chip_state &= ~ATGE_CHIP_RUNNING;
1591 1848 if (!(atgep->atge_chip_state & ATGE_CHIP_SUSPENDED))
1592 1849 atge_device_stop(atgep);
1593 1850 mutex_exit(&atgep->atge_intr_lock);
1594 1851 }
1595 1852
1596 1853 int
1597 1854 atge_m_stat(void *arg, uint_t stat, uint64_t *val)
1598 1855 {
1599 1856 atge_t *atgep = arg;
1600 1857
1601 1858 if (mii_m_getstat(atgep->atge_mii, stat, val) == 0) {
1602 1859 return (0);
1603 1860 }
1604 1861
1605 1862 switch (stat) {
1606 1863 case MAC_STAT_MULTIRCV:
1607 1864 *val = atgep->atge_multircv;
1608 1865 break;
1609 1866
1610 1867 case MAC_STAT_BRDCSTRCV:
1611 1868 *val = atgep->atge_brdcstrcv;
1612 1869 break;
1613 1870
1614 1871 case MAC_STAT_MULTIXMT:
1615 1872 *val = atgep->atge_multixmt;
1616 1873 break;
1617 1874
1618 1875 case MAC_STAT_BRDCSTXMT:
1619 1876 *val = atgep->atge_brdcstxmt;
1620 1877 break;
1621 1878
1622 1879 case MAC_STAT_IPACKETS:
1623 1880 *val = atgep->atge_ipackets;
1624 1881 break;
1625 1882
1626 1883 case MAC_STAT_RBYTES:
1627 1884 *val = atgep->atge_rbytes;
1628 1885 break;
1629 1886
1630 1887 case MAC_STAT_OPACKETS:
1631 1888 *val = atgep->atge_opackets;
1632 1889 break;
1633 1890
1634 1891 case MAC_STAT_OBYTES:
1635 1892 *val = atgep->atge_obytes;
1636 1893 break;
1637 1894
1638 1895 case MAC_STAT_NORCVBUF:
1639 1896 *val = atgep->atge_norcvbuf;
1640 1897 break;
1641 1898
1642 1899 case MAC_STAT_NOXMTBUF:
1643 1900 *val = 0;
1644 1901 break;
1645 1902
1646 1903 case MAC_STAT_COLLISIONS:
1647 1904 *val = atgep->atge_collisions;
1648 1905 break;
1649 1906
1650 1907 case MAC_STAT_IERRORS:
1651 1908 *val = atgep->atge_errrcv;
1652 1909 break;
1653 1910
1654 1911 case MAC_STAT_OERRORS:
1655 1912 *val = atgep->atge_errxmt;
1656 1913 break;
1657 1914
1658 1915 case ETHER_STAT_ALIGN_ERRORS:
1659 1916 *val = atgep->atge_align_errors;
1660 1917 break;
1661 1918
1662 1919 case ETHER_STAT_FCS_ERRORS:
1663 1920 *val = atgep->atge_fcs_errors;
1664 1921 break;
1665 1922
1666 1923 case ETHER_STAT_SQE_ERRORS:
1667 1924 *val = atgep->atge_sqe_errors;
1668 1925 break;
1669 1926
1670 1927 case ETHER_STAT_DEFER_XMTS:
1671 1928 *val = atgep->atge_defer_xmts;
1672 1929 break;
1673 1930
1674 1931 case ETHER_STAT_FIRST_COLLISIONS:
1675 1932 *val = atgep->atge_first_collisions;
1676 1933 break;
1677 1934
1678 1935 case ETHER_STAT_MULTI_COLLISIONS:
1679 1936 *val = atgep->atge_multi_collisions;
1680 1937 break;
1681 1938
1682 1939 case ETHER_STAT_TX_LATE_COLLISIONS:
1683 1940 *val = atgep->atge_tx_late_collisions;
1684 1941 break;
1685 1942
1686 1943 case ETHER_STAT_EX_COLLISIONS:
1687 1944 *val = atgep->atge_ex_collisions;
1688 1945 break;
1689 1946
1690 1947 case ETHER_STAT_MACXMT_ERRORS:
1691 1948 *val = atgep->atge_macxmt_errors;
1692 1949 break;
1693 1950
1694 1951 case ETHER_STAT_CARRIER_ERRORS:
1695 1952 *val = atgep->atge_carrier_errors;
1696 1953 break;
1697 1954
1698 1955 case ETHER_STAT_TOOLONG_ERRORS:
1699 1956 *val = atgep->atge_toolong_errors;
1700 1957 break;
1701 1958
1702 1959 case ETHER_STAT_MACRCV_ERRORS:
1703 1960 *val = atgep->atge_macrcv_errors;
1704 1961 break;
1705 1962
1706 1963 case MAC_STAT_OVERFLOWS:
1707 1964 *val = atgep->atge_overflow;
1708 1965 break;
1709 1966
1710 1967 case MAC_STAT_UNDERFLOWS:
1711 1968 *val = atgep->atge_underflow;
1712 1969 break;
1713 1970
1714 1971 case ETHER_STAT_TOOSHORT_ERRORS:
1715 1972 *val = atgep->atge_runt;
1716 1973 break;
1717 1974
1718 1975 case ETHER_STAT_JABBER_ERRORS:
1719 1976 *val = atgep->atge_jabber;
1720 1977 break;
1721 1978
1722 1979 default:
1723 1980 return (ENOTSUP);
1724 1981 }
1725 1982
1726 1983 return (0);
1727 1984 }
1728 1985
1729 1986 int
1730 1987 atge_m_getprop(void *arg, const char *name, mac_prop_id_t num, uint_t sz,
1731 1988 void *val)
1732 1989 {
1733 1990 atge_t *atgep = arg;
1734 1991
1735 1992 return (mii_m_getprop(atgep->atge_mii, name, num, sz, val));
1736 1993 }
1737 1994
1738 1995 int
1739 1996 atge_m_setprop(void *arg, const char *name, mac_prop_id_t num, uint_t sz,
1740 1997 const void *val)
1741 1998 {
1742 1999 atge_t *atgep = arg;
1743 2000 int r;
1744 2001
1745 2002 r = mii_m_setprop(atgep->atge_mii, name, num, sz, val);
1746 2003
1747 2004 if (r == 0) {
1748 2005 mutex_enter(&atgep->atge_intr_lock);
1749 2006 mutex_enter(&atgep->atge_tx_lock);
1750 2007
1751 2008 if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
1752 2009 atge_device_restart(atgep);
1753 2010 }
1754 2011
1755 2012 mutex_exit(&atgep->atge_tx_lock);
1756 2013 mutex_exit(&atgep->atge_intr_lock);
1757 2014 }
1758 2015
1759 2016 return (r);
1760 2017 }
1761 2018
1762 2019 static void
1763 2020 atge_m_propinfo(void *arg, const char *name, mac_prop_id_t num,
1764 2021 mac_prop_info_handle_t prh)
1765 2022 {
1766 2023 atge_t *atgep = arg;
1767 2024
1768 2025 mii_m_propinfo(atgep->atge_mii, name, num, prh);
1769 2026 }
1770 2027
1771 2028 void
1772 2029 atge_program_ether(atge_t *atgep)
1773 2030 {
1774 2031 ether_addr_t e;
1775 2032
1776 2033 /*
1777 2034 * Reprogram the Station address.
1778 2035 */
1779 2036 bcopy(atgep->atge_ether_addr, e, ETHERADDRL);
1780 2037 OUTL(atgep, ATGE_PAR0,
1781 2038 ((e[2] << 24) | (e[3] << 16) | (e[4] << 8) | e[5]));
1782 2039 OUTL(atgep, ATGE_PAR1, (e[0] << 8) | e[1]);
1783 2040 }
1784 2041
1785 2042 /*
1786 2043 * Device specific operations.
1787 2044 */
1788 2045 void
1789 2046 atge_device_start(atge_t *atgep)
|
↓ open down ↓ |
413 lines elided |
↑ open up ↑ |
1790 2047 {
1791 2048 uint32_t rxf_hi, rxf_lo, rrd_hi, rrd_lo;
1792 2049 uint32_t reg;
1793 2050 uint32_t fsize;
1794 2051
1795 2052 /*
1796 2053 * Reprogram the Station address.
1797 2054 */
1798 2055 atge_program_ether(atgep);
1799 2056
1800 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2057 + switch (ATGE_MODEL(atgep)) {
2058 + case ATGE_CHIP_L1E:
1801 2059 atge_l1e_program_dma(atgep);
1802 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2060 + break;
2061 + case ATGE_CHIP_L1:
1803 2062 atge_l1_program_dma(atgep);
2063 + break;
2064 + case ATGE_CHIP_L1C:
2065 + atge_l1c_program_dma(atgep);
2066 + break;
1804 2067 }
1805 2068
1806 2069 ATGE_DB(("%s: %s() dma, counters programmed ", atgep->atge_name,
1807 2070 __func__));
1808 2071
1809 - OUTW(atgep, ATGE_INTR_CLR_TIMER, 1*1000/2);
2072 + switch (ATGE_MODEL(atgep)) {
2073 + case ATGE_CHIP_L1E:
2074 + case ATGE_CHIP_L1:
2075 + OUTW(atgep, ATGE_INTR_CLR_TIMER, 1*1000/2);
2076 + break;
2077 + case ATGE_CHIP_L1C:
2078 + /*
2079 + * Disable interrupt re-trigger timer. We don't want automatic
2080 + * re-triggering of un-ACKed interrupts.
2081 + */
2082 + OUTL(atgep, ATGE_INTR_RETRIG_TIMER, ATGE_USECS(0));
2083 + /* Configure CMB. */
2084 + OUTL(atgep, ATGE_CMB_TX_TIMER, ATGE_USECS(0));
2085 + /*
2086 + * Hardware can be configured to issue SMB interrupt based
2087 + * on programmed interval. Since there is a callout that is
2088 + * invoked for every hz in driver we use that instead of
2089 + * relying on periodic SMB interrupt.
2090 + */
2091 + OUTL(atgep, ATGE_SMB_STAT_TIMER, ATGE_USECS(0));
2092 + /* Clear MAC statistics. */
2093 + atge_l1c_clear_stats(atgep);
2094 + break;
2095 + }
1810 2096
1811 2097 /*
1812 2098 * Set Maximum frame size but don't let MTU be less than ETHER_MTU.
1813 2099 */
1814 2100 if (atgep->atge_mtu < ETHERMTU)
1815 2101 atgep->atge_max_frame_size = ETHERMTU;
1816 2102 else
1817 2103 atgep->atge_max_frame_size = atgep->atge_mtu;
1818 2104
1819 2105 atgep->atge_max_frame_size += sizeof (struct ether_header) +
1820 2106 VLAN_TAGSZ + ETHERFCSL;
1821 2107 OUTL(atgep, ATGE_FRAME_SIZE, atgep->atge_max_frame_size);
1822 2108
2109 + switch (ATGE_MODEL(atgep)) {
2110 + case ATGE_CHIP_L1E:
2111 + break;
2112 + case ATGE_CHIP_L1:
2113 + break;
2114 + case ATGE_CHIP_L1C:
2115 + /* Disable header split(?) */
2116 + OUTL(atgep, ATGE_HDS_CFG, 0);
2117 + break;
2118 + }
1823 2119
1824 2120 /*
1825 2121 * Configure IPG/IFG parameters.
1826 2122 */
1827 2123 OUTL(atgep, ATGE_IPG_IFG_CFG,
1828 2124 ((IPG_IFG_IPG2_DEFAULT << IPG_IFG_IPG2_SHIFT) & IPG_IFG_IPG2_MASK) |
1829 2125 ((IPG_IFG_IPG1_DEFAULT << IPG_IFG_IPG1_SHIFT) & IPG_IFG_IPG1_MASK) |
1830 2126 ((IPG_IFG_MIFG_DEFAULT << IPG_IFG_MIFG_SHIFT) & IPG_IFG_MIFG_MASK) |
1831 2127 ((IPG_IFG_IPGT_DEFAULT << IPG_IFG_IPGT_SHIFT) & IPG_IFG_IPGT_MASK));
1832 2128
1833 2129 /*
1834 2130 * Set parameters for half-duplex media.
1835 2131 */
1836 2132 OUTL(atgep, ATGE_HDPX_CFG,
1837 2133 ((HDPX_CFG_LCOL_DEFAULT << HDPX_CFG_LCOL_SHIFT) &
1838 2134 HDPX_CFG_LCOL_MASK) |
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
1839 2135 ((HDPX_CFG_RETRY_DEFAULT << HDPX_CFG_RETRY_SHIFT) &
1840 2136 HDPX_CFG_RETRY_MASK) | HDPX_CFG_EXC_DEF_EN |
1841 2137 ((HDPX_CFG_ABEBT_DEFAULT << HDPX_CFG_ABEBT_SHIFT) &
1842 2138 HDPX_CFG_ABEBT_MASK) |
1843 2139 ((HDPX_CFG_JAMIPG_DEFAULT << HDPX_CFG_JAMIPG_SHIFT) &
1844 2140 HDPX_CFG_JAMIPG_MASK));
1845 2141
1846 2142 /*
1847 2143 * Configure jumbo frame.
1848 2144 */
1849 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2145 + switch (ATGE_MODEL(atgep)) {
2146 + case ATGE_CHIP_L1E:
2147 + if (atgep->atge_flags & ATGE_FLAG_JUMBO) {
2148 +
2149 + if (atgep->atge_mtu < ETHERMTU)
2150 + reg = atgep->atge_max_frame_size;
2151 + else if (atgep->atge_mtu < 6 * 1024)
2152 + reg = (atgep->atge_max_frame_size * 2) / 3;
2153 + else
2154 + reg = atgep->atge_max_frame_size / 2;
2155 +
2156 + OUTL(atgep, L1E_TX_JUMBO_THRESH,
2157 + ROUNDUP(reg, TX_JUMBO_THRESH_UNIT) >>
2158 + TX_JUMBO_THRESH_UNIT_SHIFT);
2159 + }
2160 + break;
2161 + case ATGE_CHIP_L1:
1850 2162 fsize = ROUNDUP(atgep->atge_max_frame_size, sizeof (uint64_t));
1851 2163 OUTL(atgep, ATGE_RXQ_JUMBO_CFG,
1852 2164 (((fsize / sizeof (uint64_t)) <<
1853 2165 RXQ_JUMBO_CFG_SZ_THRESH_SHIFT) &
1854 2166 RXQ_JUMBO_CFG_SZ_THRESH_MASK) |
1855 2167 ((RXQ_JUMBO_CFG_LKAH_DEFAULT <<
1856 2168 RXQ_JUMBO_CFG_LKAH_SHIFT) & RXQ_JUMBO_CFG_LKAH_MASK) |
1857 2169 ((ATGE_USECS(8) << RXQ_JUMBO_CFG_RRD_TIMER_SHIFT) &
1858 2170 RXQ_JUMBO_CFG_RRD_TIMER_MASK));
1859 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E &&
1860 - atgep->atge_flags & ATGE_FLAG_JUMBO) {
1861 -
1862 - if (atgep->atge_mtu < ETHERMTU)
1863 - reg = atgep->atge_max_frame_size;
1864 - else if (atgep->atge_mtu < 6 * 1024)
1865 - reg = (atgep->atge_max_frame_size * 2) / 3;
1866 - else
1867 - reg = atgep->atge_max_frame_size / 2;
1868 -
1869 - OUTL(atgep, L1E_TX_JUMBO_THRESH,
1870 - ROUNDUP(reg, TX_JUMBO_THRESH_UNIT) >>
1871 - TX_JUMBO_THRESH_UNIT_SHIFT);
2171 + break;
2172 + case ATGE_CHIP_L1C:
2173 + break;
1872 2174 }
1873 2175
1874 2176 /*
1875 2177 * Configure flow-control parameters.
1876 2178 */
1877 - if ((atgep->atge_flags & ATGE_FLAG_PCIE) != 0) {
2179 + switch (ATGE_MODEL(atgep)) {
2180 + case ATGE_CHIP_L1E:
2181 + case ATGE_CHIP_L1:
2182 + if ((atgep->atge_flags & ATGE_FLAG_PCIE) != 0) {
1878 2183 /*
1879 2184 * Some hardware version require this magic.
1880 2185 */
1881 - OUTL(atgep, 0x12FC, 0x6500);
2186 + OUTL(atgep, ATGE_LTSSM_ID_CFG, 0x6500);
1882 2187 reg = INL(atgep, 0x1008);
1883 2188 OUTL(atgep, 0x1008, reg | 0x8000);
2189 + }
2190 + break;
2191 + case ATGE_CHIP_L1C:
2192 + break;
1884 2193 }
1885 2194
1886 2195 /*
1887 2196 * These are all magic parameters which came from FreeBSD.
1888 2197 */
1889 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2198 + switch (ATGE_MODEL(atgep)) {
2199 + case ATGE_CHIP_L1E:
2200 + reg = INL(atgep, L1E_SRAM_RX_FIFO_LEN);
2201 + rxf_hi = (reg * 4) / 5;
2202 + rxf_lo = reg/ 5;
2203 +
2204 + OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
2205 + ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
2206 + RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
2207 + ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
2208 + RXQ_FIFO_PAUSE_THRESH_HI_MASK));
2209 + break;
2210 + case ATGE_CHIP_L1:
1890 2211 switch (atgep->atge_chip_rev) {
1891 2212 case 0x8001:
1892 2213 case 0x9001:
1893 2214 case 0x9002:
1894 2215 case 0x9003:
1895 2216 rxf_hi = L1_RX_RING_CNT / 16;
1896 2217 rxf_lo = (L1_RX_RING_CNT * 7) / 8;
1897 2218 rrd_hi = (L1_RR_RING_CNT * 7) / 8;
1898 2219 rrd_lo = L1_RR_RING_CNT / 16;
1899 2220 break;
1900 2221 default:
1901 2222 reg = INL(atgep, L1_SRAM_RX_FIFO_LEN);
1902 2223 rxf_lo = reg / 16;
1903 2224 if (rxf_lo > 192)
1904 2225 rxf_lo = 192;
1905 2226 rxf_hi = (reg * 7) / 8;
1906 2227 if (rxf_hi < rxf_lo)
1907 2228 rxf_hi = rxf_lo + 16;
1908 2229 reg = INL(atgep, L1_SRAM_RRD_LEN);
1909 2230 rrd_lo = reg / 8;
1910 2231 rrd_hi = (reg * 7) / 8;
1911 2232 if (rrd_lo > 2)
1912 2233 rrd_lo = 2;
1913 2234 if (rrd_hi < rrd_lo)
1914 2235 rrd_hi = rrd_lo + 3;
1915 2236 break;
1916 2237 }
1917 2238
1918 2239 OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
|
↓ open down ↓ |
19 lines elided |
↑ open up ↑ |
1919 2240 ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
1920 2241 RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
1921 2242 ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
1922 2243 RXQ_FIFO_PAUSE_THRESH_HI_MASK));
1923 2244
1924 2245 OUTL(atgep, L1_RXQ_RRD_PAUSE_THRESH,
1925 2246 ((rrd_lo << RXQ_RRD_PAUSE_THRESH_LO_SHIFT) &
1926 2247 RXQ_RRD_PAUSE_THRESH_LO_MASK) |
1927 2248 ((rrd_hi << RXQ_RRD_PAUSE_THRESH_HI_SHIFT) &
1928 2249 RXQ_RRD_PAUSE_THRESH_HI_MASK));
1929 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1930 - reg = INL(atgep, L1E_SRAM_RX_FIFO_LEN);
1931 - rxf_hi = (reg * 4) / 5;
1932 - rxf_lo = reg/ 5;
2250 + break;
2251 + case ATGE_CHIP_L1C:
2252 + switch (ATGE_DID(atgep)) {
2253 + case ATGE_CHIP_AR8151V2_DEV_ID:
2254 + case ATGE_CHIP_AR8152V1_DEV_ID:
2255 + OUTL(atgep, ATGE_SERDES_LOCK,
2256 + INL(atgep, ATGE_SERDES_LOCK) |
2257 + SERDES_MAC_CLK_SLOWDOWN |
2258 + SERDES_PHY_CLK_SLOWDOWN);
2259 + break;
2260 + case ATGE_CHIP_L1CG_DEV_ID:
2261 + case ATGE_CHIP_L1CF_DEV_ID:
2262 + /*
2263 + * Configure flow control parameters.
2264 + * XON : 80% of Rx FIFO
2265 + * XOFF : 30% of Rx FIFO
2266 + */
2267 + reg = INL(atgep, L1C_SRAM_RX_FIFO_LEN);
2268 + rxf_hi = (reg * 8) / 10;
2269 + rxf_lo = (reg * 3) / 10;
1933 2270
1934 - OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
1935 - ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
1936 - RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
1937 - ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
1938 - RXQ_FIFO_PAUSE_THRESH_HI_MASK));
2271 + OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
2272 + ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
2273 + RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
2274 + ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
2275 + RXQ_FIFO_PAUSE_THRESH_HI_MASK));
2276 + break;
2277 + }
2278 + break;
1939 2279 }
1940 2280
1941 - /* Configure RxQ. */
1942 - reg = 0;
1943 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2281 + switch (ATGE_MODEL(atgep)) {
2282 + case ATGE_CHIP_L1E:
2283 + /* Configure RxQ. */
2284 + reg = RXQ_CFG_ALIGN_32 | RXQ_CFG_CUT_THROUGH_ENB |
2285 + RXQ_CFG_IPV6_CSUM_VERIFY | RXQ_CFG_ENB;
2286 + OUTL(atgep, ATGE_RXQ_CFG, reg);
2287 + /*
2288 + * Configure TxQ.
2289 + */
2290 + reg = (128 <<
2291 + (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) <<
2292 + TXQ_CFG_TX_FIFO_BURST_SHIFT;
2293 +
2294 + reg |= (TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) &
2295 + TXQ_CFG_TPD_BURST_MASK;
2296 +
2297 + reg |= TXQ_CFG_ENHANCED_MODE | TXQ_CFG_ENB;
2298 +
2299 + OUTL(atgep, ATGE_TXQ_CFG, reg);
2300 + /* Disable RSS. */
2301 + OUTL(atgep, L1E_RSS_IDT_TABLE0, 0);
2302 + OUTL(atgep, L1E_RSS_CPU, 0);
2303 + /*
2304 + * Configure DMA parameters.
2305 + */
2306 + /*
2307 + * Don't use Tx CMB. It is known to cause RRS update failure
2308 + * under certain circumstances. Typical phenomenon of the
2309 + * issue would be unexpected sequence number encountered in
2310 + * Rx handler. Hence we don't set DMA_CFG_TXCMB_ENB.
2311 + */
2312 + OUTL(atgep, ATGE_DMA_CFG,
2313 + DMA_CFG_OUT_ORDER | DMA_CFG_RD_REQ_PRI | DMA_CFG_RCB_64 |
2314 + atgep->atge_dma_rd_burst | atgep->atge_dma_wr_burst |
2315 + DMA_CFG_RXCMB_ENB |
2316 + ((DMA_CFG_RD_DELAY_CNT_DEFAULT <<
2317 + DMA_CFG_RD_DELAY_CNT_SHIFT) & DMA_CFG_RD_DELAY_CNT_MASK) |
2318 + ((DMA_CFG_WR_DELAY_CNT_DEFAULT <<
2319 + DMA_CFG_WR_DELAY_CNT_SHIFT) & DMA_CFG_WR_DELAY_CNT_MASK));
2320 + /*
2321 + * Enable CMB/SMB timer.
2322 + */
2323 + OUTL(atgep, L1E_SMB_STAT_TIMER, 100000);
2324 + atge_l1e_clear_stats(atgep);
2325 + break;
2326 + case ATGE_CHIP_L1:
2327 + /* Configure RxQ. */
1944 2328 reg =
1945 2329 ((RXQ_CFG_RD_BURST_DEFAULT << RXQ_CFG_RD_BURST_SHIFT) &
1946 2330 RXQ_CFG_RD_BURST_MASK) |
1947 2331 ((RXQ_CFG_RRD_BURST_THRESH_DEFAULT <<
1948 2332 RXQ_CFG_RRD_BURST_THRESH_SHIFT) &
1949 2333 RXQ_CFG_RRD_BURST_THRESH_MASK) |
1950 2334 ((RXQ_CFG_RD_PREF_MIN_IPG_DEFAULT <<
1951 2335 RXQ_CFG_RD_PREF_MIN_IPG_SHIFT) &
1952 2336 RXQ_CFG_RD_PREF_MIN_IPG_MASK) |
1953 2337 RXQ_CFG_CUT_THROUGH_ENB | RXQ_CFG_ENB;
1954 2338 OUTL(atgep, ATGE_RXQ_CFG, reg);
1955 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1956 - reg = RXQ_CFG_ALIGN_32 | RXQ_CFG_CUT_THROUGH_ENB |
1957 - RXQ_CFG_IPV6_CSUM_VERIFY | RXQ_CFG_ENB;
1958 - OUTL(atgep, ATGE_RXQ_CFG, reg);
1959 - }
1960 -
1961 - /*
1962 - * Configure TxQ.
1963 - */
1964 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2339 + /*
2340 + * Configure TxQ.
2341 + */
1965 2342 reg =
1966 2343 (((TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) &
1967 2344 TXQ_CFG_TPD_BURST_MASK) |
1968 2345 ((TXQ_CFG_TX_FIFO_BURST_DEFAULT <<
1969 2346 TXQ_CFG_TX_FIFO_BURST_SHIFT) &
1970 2347 TXQ_CFG_TX_FIFO_BURST_MASK) |
1971 2348 ((TXQ_CFG_TPD_FETCH_DEFAULT <<
1972 2349 TXQ_CFG_TPD_FETCH_THRESH_SHIFT) &
1973 2350 TXQ_CFG_TPD_FETCH_THRESH_MASK) |
1974 2351 TXQ_CFG_ENB);
1975 2352 OUTL(atgep, ATGE_TXQ_CFG, reg);
1976 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1977 - reg = (128 <<
1978 - (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) <<
1979 - TXQ_CFG_TX_FIFO_BURST_SHIFT;
1980 -
1981 - reg |= (TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) &
1982 - TXQ_CFG_TPD_BURST_MASK;
1983 -
1984 - reg |= TXQ_CFG_ENHANCED_MODE | TXQ_CFG_ENB;
1985 -
1986 - OUTL(atgep, ATGE_TXQ_CFG, reg);
1987 - }
1988 -
1989 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2353 + /* Jumbo frames */
1990 2354 OUTL(atgep, L1_TX_JUMBO_TPD_TH_IPG,
1991 2355 (((fsize / sizeof (uint64_t) << TX_JUMBO_TPD_TH_SHIFT)) &
1992 2356 TX_JUMBO_TPD_TH_MASK) |
1993 2357 ((TX_JUMBO_TPD_IPG_DEFAULT << TX_JUMBO_TPD_IPG_SHIFT) &
1994 2358 TX_JUMBO_TPD_IPG_MASK));
1995 - }
1996 -
1997 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
1998 - /* Disable RSS. */
1999 - OUTL(atgep, L1E_RSS_IDT_TABLE0, 0);
2000 - OUTL(atgep, L1E_RSS_CPU, 0);
2001 - }
2002 -
2003 - /*
2004 - * Configure DMA parameters.
2005 - */
2006 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2359 + /*
2360 + * Configure DMA parameters.
2361 + */
2007 2362 OUTL(atgep, ATGE_DMA_CFG,
2008 2363 DMA_CFG_ENH_ORDER | DMA_CFG_RCB_64 |
2009 2364 atgep->atge_dma_rd_burst | DMA_CFG_RD_ENB |
2010 2365 atgep->atge_dma_wr_burst | DMA_CFG_WR_ENB);
2011 2366
2012 2367 /* Configure CMB DMA write threshold. */
2013 2368 OUTL(atgep, L1_CMB_WR_THRESH,
2014 2369 ((CMB_WR_THRESH_RRD_DEFAULT << CMB_WR_THRESH_RRD_SHIFT) &
2015 2370 CMB_WR_THRESH_RRD_MASK) |
2016 2371 ((CMB_WR_THRESH_TPD_DEFAULT << CMB_WR_THRESH_TPD_SHIFT) &
2017 2372 CMB_WR_THRESH_TPD_MASK));
2018 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2019 2373 /*
2020 - * Don't use Tx CMB. It is known to cause RRS update failure
2021 - * under certain circumstances. Typical phenomenon of the
2022 - * issue would be unexpected sequence number encountered in
2023 - * Rx handler. Hence we don't set DMA_CFG_TXCMB_ENB.
2374 + * Enable CMB/SMB timer.
2024 2375 */
2025 - OUTL(atgep, ATGE_DMA_CFG,
2026 - DMA_CFG_OUT_ORDER | DMA_CFG_RD_REQ_PRI | DMA_CFG_RCB_64 |
2027 - atgep->atge_dma_rd_burst | atgep->atge_dma_wr_burst |
2028 - DMA_CFG_RXCMB_ENB |
2029 - ((DMA_CFG_RD_DELAY_CNT_DEFAULT <<
2030 - DMA_CFG_RD_DELAY_CNT_SHIFT) & DMA_CFG_RD_DELAY_CNT_MASK) |
2031 - ((DMA_CFG_WR_DELAY_CNT_DEFAULT <<
2032 - DMA_CFG_WR_DELAY_CNT_SHIFT) & DMA_CFG_WR_DELAY_CNT_MASK));
2033 - }
2034 -
2035 - /*
2036 - * Enable CMB/SMB timer.
2037 - */
2038 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2039 2376 /* Set CMB/SMB timer and enable them. */
2040 2377 OUTL(atgep, L1_CMB_WR_TIMER,
2041 2378 ((ATGE_USECS(2) << CMB_WR_TIMER_TX_SHIFT) &
2042 2379 CMB_WR_TIMER_TX_MASK) |
2043 2380 ((ATGE_USECS(2) << CMB_WR_TIMER_RX_SHIFT) &
2044 2381 CMB_WR_TIMER_RX_MASK));
2045 2382
2046 2383 /* Request SMB updates for every seconds. */
2047 2384 OUTL(atgep, L1_SMB_TIMER, ATGE_USECS(1000 * 1000));
2048 2385 OUTL(atgep, L1_CSMB_CTRL,
2049 2386 CSMB_CTRL_SMB_ENB | CSMB_CTRL_CMB_ENB);
2050 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2051 - OUTL(atgep, L1E_SMB_STAT_TIMER, 100000);
2052 - atge_l1e_clear_stats(atgep);
2053 - }
2387 + break;
2388 + case ATGE_CHIP_L1C:
2389 + /* Configure RxQ. */
2390 + reg =
2391 + RXQ_CFG_RD_BURST_DEFAULT << L1C_RXQ_CFG_RD_BURST_SHIFT |
2392 + RXQ_CFG_IPV6_CSUM_VERIFY | RXQ_CFG_ENB;
2393 + if ((atgep->atge_flags & ATGE_FLAG_ASPM_MON) != 0)
2394 + reg |= RXQ_CFG_ASPM_THROUGHPUT_LIMIT_1M;
2395 + OUTL(atgep, ATGE_RXQ_CFG, reg);
2396 + /*
2397 + * Configure TxQ.
2398 + */
2399 + reg = (128 <<
2400 + (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) <<
2401 + TXQ_CFG_TX_FIFO_BURST_SHIFT;
2054 2402
2403 + switch (ATGE_DID(atgep)) {
2404 + case ATGE_CHIP_AR8152V2_DEV_ID:
2405 + case ATGE_CHIP_AR8152V1_DEV_ID:
2406 + reg >>= 1;
2407 + break;
2408 + }
2055 2409
2410 + reg |= (L1C_TXQ_CFG_TPD_BURST_DEFAULT <<
2411 + TXQ_CFG_TPD_BURST_SHIFT) & TXQ_CFG_TPD_BURST_MASK;
2412 +
2413 + reg |= TXQ_CFG_ENHANCED_MODE | TXQ_CFG_ENB;
2414 +
2415 + OUTL(atgep, L1C_TXQ_CFG, reg);
2416 + /* Disable RSS until I understand L1C/L2C's RSS logic. */
2417 + OUTL(atgep, L1C_RSS_IDT_TABLE0, 0xe4e4e4e4);
2418 + OUTL(atgep, L1C_RSS_CPU, 0);
2419 + /*
2420 + * Configure DMA parameters.
2421 + */
2422 + OUTL(atgep, ATGE_DMA_CFG,
2423 + DMA_CFG_SMB_DIS |
2424 + DMA_CFG_OUT_ORDER | DMA_CFG_RD_REQ_PRI | DMA_CFG_RCB_64 |
2425 + DMA_CFG_RD_DELAY_CNT_DEFAULT << DMA_CFG_RD_DELAY_CNT_SHIFT |
2426 + DMA_CFG_WR_DELAY_CNT_DEFAULT << DMA_CFG_WR_DELAY_CNT_SHIFT |
2427 +
2428 + atgep->atge_dma_rd_burst | DMA_CFG_RD_ENB |
2429 + atgep->atge_dma_wr_burst | DMA_CFG_WR_ENB);
2430 + /* Configure CMB DMA write threshold not required. */
2431 + /* Set CMB/SMB timer and enable them not required. */
2432 + break;
2433 + }
2434 +
2056 2435 /*
2057 2436 * Disable all WOL bits as WOL can interfere normal Rx
2058 2437 * operation.
2059 2438 */
2060 2439 OUTL(atgep, ATGE_WOL_CFG, 0);
2061 2440
2062 2441 /*
2063 2442 * Configure Tx/Rx MACs.
2064 2443 * - Auto-padding for short frames.
2065 2444 * - Enable CRC generation.
2066 2445 *
2067 2446 * Start with full-duplex/1000Mbps media. Actual reconfiguration
2068 2447 * of MAC is followed after link establishment.
2069 2448 */
2070 2449 reg = (ATGE_CFG_TX_CRC_ENB | ATGE_CFG_TX_AUTO_PAD |
2071 2450 ATGE_CFG_FULL_DUPLEX |
2072 2451 ((ATGE_CFG_PREAMBLE_DEFAULT << ATGE_CFG_PREAMBLE_SHIFT) &
2073 2452 ATGE_CFG_PREAMBLE_MASK));
2074 2453
2454 + /*
2455 + * AR813x/AR815x always does checksum computation regardless
2456 + * of MAC_CFG_RXCSUM_ENB bit. Also the controller is known to
2457 + * have bug in protocol field in Rx return structure so
2458 + * these controllers can't handle fragmented frames. Disable
2459 + * Rx checksum offloading until there is a newer controller
2460 + * that has sane implementation.
2461 + */
2462 + switch (ATGE_DID(atgep)) {
2463 + case ATGE_CHIP_AR8151V2_DEV_ID:
2464 + case ATGE_CHIP_AR8151V1_DEV_ID:
2465 + case ATGE_CHIP_AR8152V2_DEV_ID:
2466 + reg |= ATGE_CFG_HASH_ALG_CRC32 | ATGE_CFG_SPEED_MODE_SW;
2467 + break;
2468 + }
2469 +
2075 2470 if ((atgep->atge_flags & ATGE_FLAG_FASTETHER) != 0) {
2076 2471 reg |= ATGE_CFG_SPEED_10_100;
2077 2472 ATGE_DB(("%s: %s() Fast Ethernet", atgep->atge_name, __func__));
2078 2473 } else {
2079 2474 reg |= ATGE_CFG_SPEED_1000;
2080 2475 ATGE_DB(("%s: %s() 1G speed", atgep->atge_name, __func__));
2081 2476 }
2477 + switch (ATGE_MODEL(atgep)) {
2478 + case ATGE_CHIP_L1C:
2479 + reg |= L1C_CFG_SINGLE_PAUSE_ENB;
2480 + break;
2481 + }
2082 2482
2083 2483 OUTL(atgep, ATGE_MAC_CFG, reg);
2084 2484
2085 2485 atgep->atge_chip_state |= ATGE_CHIP_RUNNING;
2086 2486
2087 2487 /*
2088 2488 * Set up the receive filter.
2089 2489 */
2090 2490 atge_rxfilter(atgep);
2091 2491
2092 2492 /*
2093 2493 * Acknowledge all pending interrupts and clear it.
2094 2494 */
2095 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2096 - OUTL(atgep, ATGE_INTR_STATUS, 0);
2097 - OUTL(atgep, ATGE_INTR_MASK, atgep->atge_intrs);
2098 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2495 + switch (ATGE_MODEL(atgep)) {
2496 + case ATGE_CHIP_L1E:
2099 2497 OUTL(atgep, ATGE_INTR_MASK, L1E_INTRS);
2100 2498 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2101 2499 OUTL(atgep, ATGE_INTR_STATUS, 0);
2500 + break;
2501 + case ATGE_CHIP_L1:
2502 + case ATGE_CHIP_L1C:
2503 + OUTL(atgep, ATGE_INTR_STATUS, 0);
2504 + OUTL(atgep, ATGE_INTR_MASK, atgep->atge_intrs);
2505 + break;
2102 2506 }
2103 2507
2104 2508 atge_mac_config(atgep);
2105 2509
2106 2510 ATGE_DB(("%s: %s() device started", atgep->atge_name, __func__));
2107 2511 }
2108 2512
2109 2513 /*
2110 2514 * Generic functions.
2111 2515 */
2112 2516
2113 2517 #define CRC32_POLY_BE 0x04c11db7
2114 2518 uint32_t
2115 2519 atge_ether_crc(const uint8_t *addr, int len)
2116 2520 {
2117 2521 int idx;
2118 2522 int bit;
2119 2523 uint_t data;
2120 2524 uint32_t crc;
2121 2525
2122 2526 crc = 0xffffffff;
2123 2527 for (idx = 0; idx < len; idx++) {
2124 2528 for (data = *addr++, bit = 0; bit < 8; bit++, data >>= 1) {
2125 2529 crc = (crc << 1)
2126 2530 ^ ((((crc >> 31) ^ data) & 1) ? CRC32_POLY_BE : 0);
2127 2531 }
2128 2532 }
2129 2533
2130 2534 return (crc);
2131 2535 }
2132 2536
2133 2537
2134 2538 /*
2135 2539 * Programs RX filter. We use a link-list to keep track of all multicast
2136 2540 * addressess.
2137 2541 */
2138 2542 void
2139 2543 atge_rxfilter(atge_t *atgep)
2140 2544 {
2141 2545 uint32_t rxcfg;
2142 2546 uint64_t mchash;
2143 2547
2144 2548 rxcfg = INL(atgep, ATGE_MAC_CFG);
2145 2549 rxcfg &= ~(ATGE_CFG_ALLMULTI | ATGE_CFG_PROMISC);
2146 2550
2147 2551 /*
2148 2552 * Accept broadcast frames.
2149 2553 */
2150 2554 rxcfg |= ATGE_CFG_BCAST;
2151 2555
2152 2556 /*
2153 2557 * We don't use Hardware VLAN tagging.
2154 2558 */
2155 2559 rxcfg &= ~ATGE_CFG_VLAN_TAG_STRIP;
2156 2560
2157 2561 if (atgep->atge_filter_flags & (ATGE_PROMISC | ATGE_ALL_MULTICST)) {
2158 2562 mchash = ~0ULL;
2159 2563
2160 2564 if (atgep->atge_filter_flags & ATGE_PROMISC)
2161 2565 rxcfg |= ATGE_CFG_PROMISC;
2162 2566
2163 2567 if (atgep->atge_filter_flags & ATGE_ALL_MULTICST)
2164 2568 rxcfg |= ATGE_CFG_ALLMULTI;
2165 2569 } else {
2166 2570 mchash = atgep->atge_mchash;
2167 2571 }
2168 2572
2169 2573 atge_program_ether(atgep);
2170 2574
2171 2575 OUTL(atgep, ATGE_MAR0, (uint32_t)mchash);
2172 2576 OUTL(atgep, ATGE_MAR1, (uint32_t)(mchash >> 32));
2173 2577 OUTL(atgep, ATGE_MAC_CFG, rxcfg);
2174 2578
2175 2579 ATGE_DB(("%s: %s() mac_cfg is : %x, mchash : %llx",
2176 2580 atgep->atge_name, __func__, rxcfg, mchash));
2177 2581 }
2178 2582
2179 2583 void
2180 2584 atge_device_stop(atge_t *atgep)
2181 2585 {
2182 2586 uint32_t reg;
2183 2587 int t;
2184 2588
2185 2589 /*
2186 2590 * If the chip is being suspended, then don't touch the state. Caller
|
↓ open down ↓ |
75 lines elided |
↑ open up ↑ |
2187 2591 * will take care of setting the correct state.
2188 2592 */
2189 2593 if (!(atgep->atge_chip_state & ATGE_CHIP_SUSPENDED)) {
2190 2594 atgep->atge_chip_state |= ATGE_CHIP_STOPPED;
2191 2595 atgep->atge_chip_state &= ~ATGE_CHIP_RUNNING;
2192 2596 }
2193 2597
2194 2598 /*
2195 2599 * Collect stats for L1E. L1 chip's stats are collected by interrupt.
2196 2600 */
2197 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2601 + switch (ATGE_MODEL(atgep)) {
2602 + case ATGE_CHIP_L1E:
2198 2603 atge_l1e_gather_stats(atgep);
2604 + break;
2605 + case ATGE_CHIP_L1:
2606 + case ATGE_CHIP_L1C:
2607 + break;
2199 2608 }
2200 2609
2201 2610 /*
2202 2611 * Disable interrupts.
2203 2612 */
2204 2613 atge_disable_intrs(atgep);
2205 2614
2206 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1)
2615 + switch (ATGE_MODEL(atgep)) {
2616 + case ATGE_CHIP_L1E:
2617 + /* Clear CTRL not required. */
2618 + /* Stop DMA Engine not required. */
2619 + /*
2620 + * Disable queue processing.
2621 + */
2622 + /* Stop TxQ */
2623 + reg = INL(atgep, ATGE_TXQ_CFG);
2624 + reg = reg & ~TXQ_CFG_ENB;
2625 + OUTL(atgep, ATGE_TXQ_CFG, reg);
2626 + /* Stop RxQ */
2627 + reg = INL(atgep, ATGE_RXQ_CFG);
2628 + reg = reg & ~RXQ_CFG_ENB;
2629 + OUTL(atgep, ATGE_RXQ_CFG, reg);
2630 + /* Stop DMA */
2631 + reg = INL(atgep, ATGE_DMA_CFG);
2632 + reg = reg & ~(DMA_CFG_TXCMB_ENB | DMA_CFG_RXCMB_ENB);
2633 + OUTL(atgep, ATGE_DMA_CFG, reg);
2634 + drv_usecwait(1000);
2635 + atge_l1e_stop_mac(atgep);
2636 + OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2637 + break;
2638 + case ATGE_CHIP_L1:
2639 + /* Clear CTRL. */
2207 2640 OUTL(atgep, L1_CSMB_CTRL, 0);
2208 -
2209 - /* Stop DMA Engine */
2210 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2641 + /* Stop DMA Engine */
2211 2642 atge_l1_stop_tx_mac(atgep);
2212 2643 atge_l1_stop_rx_mac(atgep);
2213 -
2214 2644 reg = INL(atgep, ATGE_DMA_CFG);
2215 2645 reg &= ~(DMA_CFG_RD_ENB | DMA_CFG_WR_ENB);
2216 2646 OUTL(atgep, ATGE_DMA_CFG, reg);
2217 -
2218 - }
2219 -
2220 - /*
2221 - * Disable queue processing.
2222 - */
2223 - /* Stop TxQ */
2224 - reg = INL(atgep, ATGE_TXQ_CFG);
2225 - reg = reg & ~TXQ_CFG_ENB;
2226 - OUTL(atgep, ATGE_TXQ_CFG, reg);
2227 -
2228 - /* Stop RxQ */
2229 - reg = INL(atgep, ATGE_RXQ_CFG);
2230 - reg = reg & ~RXQ_CFG_ENB;
2231 - OUTL(atgep, ATGE_RXQ_CFG, reg);
2232 -
2233 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2647 + /*
2648 + * Disable queue processing.
2649 + */
2650 + /* Stop TxQ */
2651 + reg = INL(atgep, ATGE_TXQ_CFG);
2652 + reg = reg & ~TXQ_CFG_ENB;
2653 + OUTL(atgep, ATGE_TXQ_CFG, reg);
2654 + /* Stop RxQ */
2655 + reg = INL(atgep, ATGE_RXQ_CFG);
2656 + reg = reg & ~RXQ_CFG_ENB;
2657 + OUTL(atgep, ATGE_RXQ_CFG, reg);
2658 + break;
2659 + case ATGE_CHIP_L1C:
2660 + /* Clear CTRL not required. */
2661 + /* Stop DMA Engine */
2662 + atge_l1c_stop_tx_mac(atgep);
2663 + atge_l1c_stop_rx_mac(atgep);
2234 2664 reg = INL(atgep, ATGE_DMA_CFG);
2235 - reg = reg & ~(DMA_CFG_TXCMB_ENB | DMA_CFG_RXCMB_ENB);
2665 + reg &= ~(DMA_CFG_RD_ENB | DMA_CFG_WR_ENB);
2236 2666 OUTL(atgep, ATGE_DMA_CFG, reg);
2237 - drv_usecwait(1000);
2238 - atge_l1e_stop_mac(atgep);
2239 - OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2667 + /*
2668 + * Disable queue processing.
2669 + */
2670 + /* Stop TxQ */
2671 + reg = INL(atgep, L1C_TXQ_CFG);
2672 + reg = reg & ~TXQ_CFG_ENB;
2673 + OUTL(atgep, L1C_TXQ_CFG, reg);
2674 + /* Stop RxQ */
2675 + reg = INL(atgep, ATGE_RXQ_CFG);
2676 + reg = reg & ~RXQ_CFG_ENB;
2677 + OUTL(atgep, ATGE_RXQ_CFG, reg);
2678 + break;
2240 2679 }
2241 2680
2242 2681 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
2243 2682 if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0)
2244 2683 break;
2245 2684 drv_usecwait(10);
2246 2685 }
2247 2686
2248 2687 if (t == 0) {
2249 2688 atge_error(atgep->atge_dip, "%s() stopping TX/RX MAC timeout",
2250 2689 __func__);
2251 2690 }
2252 2691 }
2253 2692
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
2254 2693 void
2255 2694 atge_disable_intrs(atge_t *atgep)
2256 2695 {
2257 2696 OUTL(atgep, ATGE_INTR_MASK, 0);
2258 2697 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2259 2698 }
2260 2699
2261 2700 void
2262 2701 atge_device_init(atge_t *atgep)
2263 2702 {
2264 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2703 + switch (ATGE_MODEL(atgep)) {
2704 + case ATGE_CHIP_L1E:
2265 2705 atgep->atge_intrs = L1E_INTRS;
2266 2706 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2267 2707
2268 2708 atge_l1e_init_tx_ring(atgep);
2269 2709 atge_l1e_init_rx_pages(atgep);
2270 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2710 + break;
2711 + case ATGE_CHIP_L1:
2271 2712 atgep->atge_intrs = L1_INTRS | INTR_GPHY | INTR_PHY_LINK_DOWN |
2272 2713 INTR_LINK_CHG;
2273 2714 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2274 2715
2275 2716 atge_l1_init_tx_ring(atgep);
2276 2717 atge_l1_init_rx_ring(atgep);
2277 2718 atge_l1_init_rr_ring(atgep);
2278 2719 atge_l1_init_cmb(atgep);
2279 2720 atge_l1_init_smb(atgep);
2721 + break;
2722 + case ATGE_CHIP_L1C:
2723 + atgep->atge_intrs = L1C_INTRS | L1C_INTR_GPHY |
2724 + L1C_INTR_PHY_LINK_DOWN;
2725 + atgep->atge_int_rx_mod = 400/2;
2726 + atgep->atge_int_tx_mod = 2000/1;
2727 +
2728 + atge_l1c_init_tx_ring(atgep);
2729 + atge_l1c_init_rx_ring(atgep);
2730 + atge_l1c_init_rr_ring(atgep);
2731 + atge_l1c_init_cmb(atgep);
2732 + atge_l1c_init_smb(atgep);
2733 +
2734 + /* Enable all clocks. */
2735 + OUTL(atgep, ATGE_CLK_GATING_CFG, 0);
2736 + break;
2280 2737 }
2281 2738 }
2282 2739
2283 2740 void
2284 2741 atge_device_restart(atge_t *atgep)
2285 2742 {
2286 2743 ASSERT(MUTEX_HELD(&atgep->atge_intr_lock));
2287 2744 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
2288 2745
2289 2746 /*
2290 2747 * Cancel any pending I/O.
2291 2748 */
2292 2749 atge_device_stop(atgep);
2293 2750
2294 2751 /*
2295 2752 * Reset the chip to a known state.
2296 2753 */
2297 2754 atge_device_reset(atgep);
2298 2755
2299 2756 /*
2300 2757 * Initialize the ring and other descriptor like CMB/SMB/Rx return.
2301 2758 */
2302 2759 atge_device_init(atgep);
2303 2760
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
2304 2761 /*
2305 2762 * Start the chip.
2306 2763 */
2307 2764 atge_device_start(atgep);
2308 2765
2309 2766 }
2310 2767
2311 2768 static int
2312 2769 atge_send_a_packet(atge_t *atgep, mblk_t *mp)
2313 2770 {
2314 - atge_tx_desc_t *txd;
2315 2771 uchar_t *c;
2316 2772 uint32_t cflags = 0;
2317 2773 atge_ring_t *r;
2318 2774 size_t pktlen;
2319 2775 uchar_t *buf;
2320 2776 int start;
2321 2777
2322 2778 ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
2323 2779 ASSERT(mp != NULL);
2324 2780
2325 2781 pktlen = msgsize(mp);
2326 2782 if (pktlen > atgep->atge_tx_buf_len) {
2327 2783 atgep->atge_macxmt_errors++;
2328 2784
2329 2785 ATGE_DB(("%s: %s() pktlen (%d) > rx_buf_len (%d)",
2330 2786 atgep->atge_name, __func__,
2331 2787 pktlen, atgep->atge_rx_buf_len));
2332 2788
2333 2789 freemsg(mp);
2334 2790 return (DDI_SUCCESS);
2335 2791 }
2336 2792
2337 2793 r = atgep->atge_tx_ring;
2338 2794
2339 2795 if (r->r_avail_desc <= 1) {
2340 2796 atgep->atge_noxmtbuf++;
2341 2797 atgep->atge_tx_resched = 1;
2342 2798
2343 2799 ATGE_DB(("%s: %s() No transmit buf",
2344 2800 atgep->atge_name, __func__));
2345 2801
2346 2802 return (DDI_FAILURE);
2347 2803 }
2348 2804
2349 2805 start = r->r_producer;
2350 2806
2351 2807 /*
2352 2808 * Get the DMA buffer to hold a packet.
2353 2809 */
|
↓ open down ↓ |
29 lines elided |
↑ open up ↑ |
2354 2810 buf = (uchar_t *)r->r_buf_tbl[start]->addr;
2355 2811
2356 2812 /*
2357 2813 * Copy the msg and free mp
2358 2814 */
2359 2815 mcopymsg(mp, buf);
2360 2816
2361 2817 r->r_avail_desc--;
2362 2818
2363 2819 c = (uchar_t *)r->r_desc_ring->addr;
2364 - c += (sizeof (atge_tx_desc_t) * start);
2365 - txd = (atge_tx_desc_t *)c;
2820 + switch (ATGE_MODEL(atgep)) {
2821 + case ATGE_CHIP_L1C:
2822 + {
2823 + l1c_tx_desc_t *txd;
2366 2824
2367 - ATGE_PUT64(r->r_desc_ring, &txd->addr,
2368 - r->r_buf_tbl[start]->cookie.dmac_laddress);
2825 + c += (sizeof (l1c_tx_desc_t) * start);
2826 + txd = (l1c_tx_desc_t *)c;
2369 2827
2370 - ATGE_PUT32(r->r_desc_ring, &txd->len, ATGE_TX_BYTES(pktlen));
2828 + ATGE_PUT64(r->r_desc_ring, &txd->addr,
2829 + r->r_buf_tbl[start]->cookie.dmac_laddress);
2371 2830
2372 - cflags |= ATGE_TD_EOP;
2373 - ATGE_PUT32(r->r_desc_ring, &txd->flags, cflags);
2831 + ATGE_PUT32(r->r_desc_ring, &txd->len, L1C_TX_BYTES(pktlen));
2374 2832
2833 + cflags |= L1C_TD_EOP;
2834 + ATGE_PUT32(r->r_desc_ring, &txd->flags, cflags);
2835 + break;
2836 + }
2837 + default:
2838 + {
2839 + atge_tx_desc_t *txd;
2840 +
2841 + c += (sizeof (atge_tx_desc_t) * start);
2842 + txd = (atge_tx_desc_t *)c;
2843 +
2844 + ATGE_PUT64(r->r_desc_ring, &txd->addr,
2845 + r->r_buf_tbl[start]->cookie.dmac_laddress);
2846 +
2847 + ATGE_PUT32(r->r_desc_ring, &txd->len, ATGE_TX_BYTES(pktlen));
2848 +
2849 + cflags |= ATGE_TD_EOP;
2850 + ATGE_PUT32(r->r_desc_ring, &txd->flags, cflags);
2851 + break;
2852 + }
2853 + }
2375 2854 /*
2376 2855 * Sync buffer first.
2377 2856 */
2378 2857 DMA_SYNC(r->r_buf_tbl[start], 0, pktlen, DDI_DMA_SYNC_FORDEV);
2379 2858
2380 2859 /*
2381 2860 * Increment TX producer count by one.
2382 2861 */
2383 2862 ATGE_INC_SLOT(r->r_producer, ATGE_TX_RING_CNT);
2384 2863
2385 2864 /*
2386 2865 * Sync descriptor table.
2387 2866 */
2388 2867 DMA_SYNC(r->r_desc_ring, 0, ATGE_TX_RING_SZ, DDI_DMA_SYNC_FORDEV);
2389 2868
2390 2869 /*
2391 2870 * Program TX descriptor to send a packet.
2392 2871 */
2393 - if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) {
2872 + switch (ATGE_MODEL(atgep)) {
2873 + case ATGE_CHIP_L1E:
2394 2874 atge_l1e_send_packet(r);
2395 - } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) {
2875 + break;
2876 + case ATGE_CHIP_L1:
2396 2877 atge_l1_send_packet(r);
2878 + break;
2879 + case ATGE_CHIP_L1C:
2880 + atge_l1c_send_packet(r);
2881 + break;
2397 2882 }
2398 2883
2399 2884 r->r_atge->atge_opackets++;
2400 2885 r->r_atge->atge_obytes += pktlen;
2401 2886
2402 2887 ATGE_DB(("%s: %s() pktlen : %d, avail_desc : %d, producer :%d, "
2403 2888 "consumer : %d", atgep->atge_name, __func__, pktlen,
2404 2889 r->r_avail_desc, r->r_producer, r->r_consumer));
2405 2890
2406 2891 return (DDI_SUCCESS);
2407 2892 }
2408 2893
2409 2894 /*
2410 2895 * Stream Information.
2411 2896 */
2412 2897 DDI_DEFINE_STREAM_OPS(atge_devops, nulldev, nulldev, atge_attach, atge_detach,
2413 2898 nodev, NULL, D_MP, NULL, atge_quiesce);
2414 2899
2415 2900 /*
2416 2901 * Module linkage information.
2417 2902 */
2418 2903 static struct modldrv atge_modldrv = {
2419 2904 &mod_driverops, /* Type of Module */
2420 2905 "Atheros/Attansic Gb Ethernet", /* Description */
2421 2906 &atge_devops /* drv_dev_ops */
2422 2907 };
2423 2908
2424 2909 static struct modlinkage atge_modlinkage = {
2425 2910 MODREV_1, /* ml_rev */
2426 2911 (void *)&atge_modldrv,
2427 2912 NULL
2428 2913 };
2429 2914
2430 2915 /*
2431 2916 * DDI Entry points.
2432 2917 */
2433 2918 int
2434 2919 _init(void)
2435 2920 {
2436 2921 int r;
2437 2922 mac_init_ops(&atge_devops, "atge");
2438 2923 if ((r = mod_install(&atge_modlinkage)) != DDI_SUCCESS) {
2439 2924 mac_fini_ops(&atge_devops);
2440 2925 }
2441 2926
2442 2927 return (r);
2443 2928 }
2444 2929
2445 2930 int
2446 2931 _fini(void)
2447 2932 {
2448 2933 int r;
2449 2934
2450 2935 if ((r = mod_remove(&atge_modlinkage)) == DDI_SUCCESS) {
2451 2936 mac_fini_ops(&atge_devops);
2452 2937 }
2453 2938
2454 2939 return (r);
2455 2940 }
2456 2941
2457 2942 int
2458 2943 _info(struct modinfo *modinfop)
2459 2944 {
2460 2945 return (mod_info(&atge_modlinkage, modinfop));
2461 2946 }
|
↓ open down ↓ |
55 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX