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