Print this page
XXXX introduce drv_sectohz
Split |
Close |
Expand all |
Collapse all |
--- old/usr/src/uts/common/io/igb/igb_main.c
+++ new/usr/src/uts/common/io/igb/igb_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) 2007-2012 Intel Corporation. All rights reserved.
24 24 */
25 25
26 26 /*
27 27 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
28 28 * Copyright 2013, Nexenta Systems, Inc. All rights reserved.
29 29 */
30 30
31 31 #include "igb_sw.h"
32 32
33 33 static char ident[] = "Intel 1Gb Ethernet";
34 34 static char igb_version[] = "igb 2.3.8-ish";
35 35
36 36 /*
37 37 * Local function protoypes
38 38 */
39 39 static int igb_register_mac(igb_t *);
40 40 static int igb_identify_hardware(igb_t *);
41 41 static int igb_regs_map(igb_t *);
42 42 static void igb_init_properties(igb_t *);
43 43 static int igb_init_driver_settings(igb_t *);
44 44 static void igb_init_locks(igb_t *);
45 45 static void igb_destroy_locks(igb_t *);
46 46 static int igb_init_mac_address(igb_t *);
47 47 static int igb_init(igb_t *);
48 48 static int igb_init_adapter(igb_t *);
49 49 static void igb_stop_adapter(igb_t *);
50 50 static int igb_reset(igb_t *);
51 51 static void igb_tx_clean(igb_t *);
52 52 static boolean_t igb_tx_drain(igb_t *);
53 53 static boolean_t igb_rx_drain(igb_t *);
54 54 static int igb_alloc_rings(igb_t *);
55 55 static int igb_alloc_rx_data(igb_t *);
56 56 static void igb_free_rx_data(igb_t *);
57 57 static void igb_free_rings(igb_t *);
58 58 static void igb_setup_rings(igb_t *);
59 59 static void igb_setup_rx(igb_t *);
60 60 static void igb_setup_tx(igb_t *);
61 61 static void igb_setup_rx_ring(igb_rx_ring_t *);
62 62 static void igb_setup_tx_ring(igb_tx_ring_t *);
63 63 static void igb_setup_rss(igb_t *);
64 64 static void igb_setup_mac_rss_classify(igb_t *);
65 65 static void igb_setup_mac_classify(igb_t *);
66 66 static void igb_init_unicst(igb_t *);
67 67 static void igb_setup_multicst(igb_t *);
68 68 static void igb_get_phy_state(igb_t *);
69 69 static void igb_param_sync(igb_t *);
70 70 static void igb_get_conf(igb_t *);
71 71 static int igb_get_prop(igb_t *, char *, int, int, int);
72 72 static boolean_t igb_is_link_up(igb_t *);
73 73 static boolean_t igb_link_check(igb_t *);
74 74 static void igb_local_timer(void *);
75 75 static void igb_link_timer(void *);
76 76 static void igb_arm_watchdog_timer(igb_t *);
77 77 static void igb_start_watchdog_timer(igb_t *);
78 78 static void igb_restart_watchdog_timer(igb_t *);
79 79 static void igb_stop_watchdog_timer(igb_t *);
80 80 static void igb_start_link_timer(igb_t *);
81 81 static void igb_stop_link_timer(igb_t *);
82 82 static void igb_disable_adapter_interrupts(igb_t *);
83 83 static void igb_enable_adapter_interrupts_82575(igb_t *);
84 84 static void igb_enable_adapter_interrupts_82576(igb_t *);
85 85 static void igb_enable_adapter_interrupts_82580(igb_t *);
86 86 static boolean_t is_valid_mac_addr(uint8_t *);
87 87 static boolean_t igb_stall_check(igb_t *);
88 88 static boolean_t igb_set_loopback_mode(igb_t *, uint32_t);
89 89 static void igb_set_external_loopback(igb_t *);
90 90 static void igb_set_internal_phy_loopback(igb_t *);
91 91 static void igb_set_internal_serdes_loopback(igb_t *);
92 92 static boolean_t igb_find_mac_address(igb_t *);
93 93 static int igb_alloc_intrs(igb_t *);
94 94 static int igb_alloc_intr_handles(igb_t *, int);
95 95 static int igb_add_intr_handlers(igb_t *);
96 96 static void igb_rem_intr_handlers(igb_t *);
97 97 static void igb_rem_intrs(igb_t *);
98 98 static int igb_enable_intrs(igb_t *);
99 99 static int igb_disable_intrs(igb_t *);
100 100 static void igb_setup_msix_82575(igb_t *);
101 101 static void igb_setup_msix_82576(igb_t *);
102 102 static void igb_setup_msix_82580(igb_t *);
103 103 static uint_t igb_intr_legacy(void *, void *);
104 104 static uint_t igb_intr_msi(void *, void *);
105 105 static uint_t igb_intr_rx(void *, void *);
106 106 static uint_t igb_intr_tx(void *, void *);
107 107 static uint_t igb_intr_tx_other(void *, void *);
108 108 static void igb_intr_rx_work(igb_rx_ring_t *);
109 109 static void igb_intr_tx_work(igb_tx_ring_t *);
110 110 static void igb_intr_link_work(igb_t *);
111 111 static void igb_get_driver_control(struct e1000_hw *);
112 112 static void igb_release_driver_control(struct e1000_hw *);
113 113
114 114 static int igb_attach(dev_info_t *, ddi_attach_cmd_t);
115 115 static int igb_detach(dev_info_t *, ddi_detach_cmd_t);
116 116 static int igb_resume(dev_info_t *);
117 117 static int igb_suspend(dev_info_t *);
118 118 static int igb_quiesce(dev_info_t *);
119 119 static void igb_unconfigure(dev_info_t *, igb_t *);
120 120 static int igb_fm_error_cb(dev_info_t *, ddi_fm_error_t *,
121 121 const void *);
122 122 static void igb_fm_init(igb_t *);
123 123 static void igb_fm_fini(igb_t *);
124 124 static void igb_release_multicast(igb_t *);
125 125
126 126 char *igb_priv_props[] = {
127 127 "_eee_support",
128 128 "_tx_copy_thresh",
129 129 "_tx_recycle_thresh",
130 130 "_tx_overload_thresh",
131 131 "_tx_resched_thresh",
132 132 "_rx_copy_thresh",
133 133 "_rx_limit_per_intr",
134 134 "_intr_throttling",
135 135 "_adv_pause_cap",
136 136 "_adv_asym_pause_cap",
137 137 NULL
138 138 };
139 139
140 140 static struct cb_ops igb_cb_ops = {
141 141 nulldev, /* cb_open */
142 142 nulldev, /* cb_close */
143 143 nodev, /* cb_strategy */
144 144 nodev, /* cb_print */
145 145 nodev, /* cb_dump */
146 146 nodev, /* cb_read */
147 147 nodev, /* cb_write */
148 148 nodev, /* cb_ioctl */
149 149 nodev, /* cb_devmap */
150 150 nodev, /* cb_mmap */
151 151 nodev, /* cb_segmap */
152 152 nochpoll, /* cb_chpoll */
153 153 ddi_prop_op, /* cb_prop_op */
154 154 NULL, /* cb_stream */
155 155 D_MP | D_HOTPLUG, /* cb_flag */
156 156 CB_REV, /* cb_rev */
157 157 nodev, /* cb_aread */
158 158 nodev /* cb_awrite */
159 159 };
160 160
161 161 static struct dev_ops igb_dev_ops = {
162 162 DEVO_REV, /* devo_rev */
163 163 0, /* devo_refcnt */
164 164 NULL, /* devo_getinfo */
165 165 nulldev, /* devo_identify */
166 166 nulldev, /* devo_probe */
167 167 igb_attach, /* devo_attach */
168 168 igb_detach, /* devo_detach */
169 169 nodev, /* devo_reset */
170 170 &igb_cb_ops, /* devo_cb_ops */
171 171 NULL, /* devo_bus_ops */
172 172 ddi_power, /* devo_power */
173 173 igb_quiesce, /* devo_quiesce */
174 174 };
175 175
176 176 static struct modldrv igb_modldrv = {
177 177 &mod_driverops, /* Type of module. This one is a driver */
178 178 ident, /* Discription string */
179 179 &igb_dev_ops, /* driver ops */
180 180 };
181 181
182 182 static struct modlinkage igb_modlinkage = {
183 183 MODREV_1, &igb_modldrv, NULL
184 184 };
185 185
186 186 /* Access attributes for register mapping */
187 187 ddi_device_acc_attr_t igb_regs_acc_attr = {
188 188 DDI_DEVICE_ATTR_V1,
189 189 DDI_STRUCTURE_LE_ACC,
190 190 DDI_STRICTORDER_ACC,
191 191 DDI_FLAGERR_ACC
192 192 };
193 193
194 194 #define IGB_M_CALLBACK_FLAGS \
195 195 (MC_IOCTL | MC_GETCAPAB | MC_SETPROP | MC_GETPROP | MC_PROPINFO)
196 196
197 197 static mac_callbacks_t igb_m_callbacks = {
198 198 IGB_M_CALLBACK_FLAGS,
199 199 igb_m_stat,
200 200 igb_m_start,
201 201 igb_m_stop,
202 202 igb_m_promisc,
203 203 igb_m_multicst,
204 204 NULL,
205 205 NULL,
206 206 NULL,
207 207 igb_m_ioctl,
208 208 igb_m_getcapab,
209 209 NULL,
210 210 NULL,
211 211 igb_m_setprop,
212 212 igb_m_getprop,
213 213 igb_m_propinfo
214 214 };
215 215
216 216 /*
217 217 * Initialize capabilities of each supported adapter type
218 218 */
219 219 static adapter_info_t igb_82575_cap = {
220 220 /* limits */
221 221 4, /* maximum number of rx queues */
222 222 1, /* minimum number of rx queues */
223 223 4, /* default number of rx queues */
224 224 4, /* maximum number of tx queues */
225 225 1, /* minimum number of tx queues */
226 226 4, /* default number of tx queues */
227 227 65535, /* maximum interrupt throttle rate */
228 228 0, /* minimum interrupt throttle rate */
229 229 200, /* default interrupt throttle rate */
230 230
231 231 /* function pointers */
232 232 igb_enable_adapter_interrupts_82575,
233 233 igb_setup_msix_82575,
234 234
235 235 /* capabilities */
236 236 (IGB_FLAG_HAS_DCA | /* capability flags */
237 237 IGB_FLAG_VMDQ_POOL),
238 238
239 239 0xffc00000 /* mask for RXDCTL register */
240 240 };
241 241
242 242 static adapter_info_t igb_82576_cap = {
243 243 /* limits */
244 244 16, /* maximum number of rx queues */
245 245 1, /* minimum number of rx queues */
246 246 4, /* default number of rx queues */
247 247 16, /* maximum number of tx queues */
248 248 1, /* minimum number of tx queues */
249 249 4, /* default number of tx queues */
250 250 65535, /* maximum interrupt throttle rate */
251 251 0, /* minimum interrupt throttle rate */
252 252 200, /* default interrupt throttle rate */
253 253
254 254 /* function pointers */
255 255 igb_enable_adapter_interrupts_82576,
256 256 igb_setup_msix_82576,
257 257
258 258 /* capabilities */
259 259 (IGB_FLAG_HAS_DCA | /* capability flags */
260 260 IGB_FLAG_VMDQ_POOL |
261 261 IGB_FLAG_NEED_CTX_IDX),
262 262
263 263 0xffe00000 /* mask for RXDCTL register */
264 264 };
265 265
266 266 static adapter_info_t igb_82580_cap = {
267 267 /* limits */
268 268 8, /* maximum number of rx queues */
269 269 1, /* minimum number of rx queues */
270 270 4, /* default number of rx queues */
271 271 8, /* maximum number of tx queues */
272 272 1, /* minimum number of tx queues */
273 273 4, /* default number of tx queues */
274 274 65535, /* maximum interrupt throttle rate */
275 275 0, /* minimum interrupt throttle rate */
276 276 200, /* default interrupt throttle rate */
277 277
278 278 /* function pointers */
279 279 igb_enable_adapter_interrupts_82580,
280 280 igb_setup_msix_82580,
281 281
282 282 /* capabilities */
283 283 (IGB_FLAG_HAS_DCA | /* capability flags */
284 284 IGB_FLAG_VMDQ_POOL |
285 285 IGB_FLAG_NEED_CTX_IDX),
286 286
287 287 0xffe00000 /* mask for RXDCTL register */
288 288 };
289 289
290 290 static adapter_info_t igb_i350_cap = {
291 291 /* limits */
292 292 8, /* maximum number of rx queues */
293 293 1, /* minimum number of rx queues */
294 294 4, /* default number of rx queues */
295 295 8, /* maximum number of tx queues */
296 296 1, /* minimum number of tx queues */
297 297 4, /* default number of tx queues */
298 298 65535, /* maximum interrupt throttle rate */
299 299 0, /* minimum interrupt throttle rate */
300 300 200, /* default interrupt throttle rate */
301 301
302 302 /* function pointers */
303 303 igb_enable_adapter_interrupts_82580,
304 304 igb_setup_msix_82580,
305 305
306 306 /* capabilities */
307 307 (IGB_FLAG_HAS_DCA | /* capability flags */
308 308 IGB_FLAG_VMDQ_POOL |
309 309 IGB_FLAG_NEED_CTX_IDX),
310 310
311 311 0xffe00000 /* mask for RXDCTL register */
312 312 };
313 313
314 314 static adapter_info_t igb_i210_cap = {
315 315 /* limits */
316 316 4, /* maximum number of rx queues */
317 317 1, /* minimum number of rx queues */
318 318 4, /* default number of rx queues */
319 319 4, /* maximum number of tx queues */
320 320 1, /* minimum number of tx queues */
321 321 4, /* default number of tx queues */
322 322 65535, /* maximum interrupt throttle rate */
323 323 0, /* minimum interrupt throttle rate */
324 324 200, /* default interrupt throttle rate */
325 325
326 326 /* function pointers */
327 327 igb_enable_adapter_interrupts_82580,
328 328 igb_setup_msix_82580,
329 329
330 330 /* capabilities */
331 331 (IGB_FLAG_HAS_DCA | /* capability flags */
332 332 IGB_FLAG_VMDQ_POOL |
333 333 IGB_FLAG_NEED_CTX_IDX),
334 334
335 335 0xfff00000 /* mask for RXDCTL register */
336 336 };
337 337
338 338 static adapter_info_t igb_i354_cap = {
339 339 /* limits */
340 340 8, /* maximum number of rx queues */
341 341 1, /* minimum number of rx queues */
342 342 4, /* default number of rx queues */
343 343 8, /* maximum number of tx queues */
344 344 1, /* minimum number of tx queues */
345 345 4, /* default number of tx queues */
346 346 65535, /* maximum interrupt throttle rate */
347 347 0, /* minimum interrupt throttle rate */
348 348 200, /* default interrupt throttle rate */
349 349
350 350 /* function pointers */
351 351 igb_enable_adapter_interrupts_82580,
352 352 igb_setup_msix_82580,
353 353
354 354 /* capabilities */
355 355 (IGB_FLAG_HAS_DCA | /* capability flags */
356 356 IGB_FLAG_VMDQ_POOL |
357 357 IGB_FLAG_NEED_CTX_IDX),
358 358
359 359 0xfff00000 /* mask for RXDCTL register */
360 360 };
361 361
362 362 /*
363 363 * Module Initialization Functions
364 364 */
365 365
366 366 int
367 367 _init(void)
368 368 {
369 369 int status;
370 370
371 371 mac_init_ops(&igb_dev_ops, MODULE_NAME);
372 372
373 373 status = mod_install(&igb_modlinkage);
374 374
375 375 if (status != DDI_SUCCESS) {
376 376 mac_fini_ops(&igb_dev_ops);
377 377 }
378 378
379 379 return (status);
380 380 }
381 381
382 382 int
383 383 _fini(void)
384 384 {
385 385 int status;
386 386
387 387 status = mod_remove(&igb_modlinkage);
388 388
389 389 if (status == DDI_SUCCESS) {
390 390 mac_fini_ops(&igb_dev_ops);
391 391 }
392 392
393 393 return (status);
394 394
395 395 }
396 396
397 397 int
398 398 _info(struct modinfo *modinfop)
399 399 {
400 400 int status;
401 401
402 402 status = mod_info(&igb_modlinkage, modinfop);
403 403
404 404 return (status);
405 405 }
406 406
407 407 /*
408 408 * igb_attach - driver attach
409 409 *
410 410 * This function is the device specific initialization entry
411 411 * point. This entry point is required and must be written.
412 412 * The DDI_ATTACH command must be provided in the attach entry
413 413 * point. When attach() is called with cmd set to DDI_ATTACH,
414 414 * all normal kernel services (such as kmem_alloc(9F)) are
415 415 * available for use by the driver.
416 416 *
417 417 * The attach() function will be called once for each instance
418 418 * of the device on the system with cmd set to DDI_ATTACH.
419 419 * Until attach() succeeds, the only driver entry points which
420 420 * may be called are open(9E) and getinfo(9E).
421 421 */
422 422 static int
423 423 igb_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd)
424 424 {
425 425 igb_t *igb;
426 426 struct igb_osdep *osdep;
427 427 struct e1000_hw *hw;
428 428 int instance;
429 429
430 430 /*
431 431 * Check the command and perform corresponding operations
432 432 */
433 433 switch (cmd) {
434 434 default:
435 435 return (DDI_FAILURE);
436 436
437 437 case DDI_RESUME:
438 438 return (igb_resume(devinfo));
439 439
440 440 case DDI_ATTACH:
441 441 break;
442 442 }
443 443
444 444 /* Get the device instance */
445 445 instance = ddi_get_instance(devinfo);
446 446
447 447 /* Allocate memory for the instance data structure */
448 448 igb = kmem_zalloc(sizeof (igb_t), KM_SLEEP);
449 449
450 450 igb->dip = devinfo;
451 451 igb->instance = instance;
452 452
453 453 hw = &igb->hw;
454 454 osdep = &igb->osdep;
455 455 hw->back = osdep;
456 456 osdep->igb = igb;
457 457
458 458 /* Attach the instance pointer to the dev_info data structure */
459 459 ddi_set_driver_private(devinfo, igb);
460 460
461 461
462 462 /* Initialize for fma support */
463 463 igb->fm_capabilities = igb_get_prop(igb, "fm-capable",
464 464 0, 0x0f,
465 465 DDI_FM_EREPORT_CAPABLE | DDI_FM_ACCCHK_CAPABLE |
466 466 DDI_FM_DMACHK_CAPABLE | DDI_FM_ERRCB_CAPABLE);
467 467 igb_fm_init(igb);
468 468 igb->attach_progress |= ATTACH_PROGRESS_FMINIT;
469 469
470 470 /*
471 471 * Map PCI config space registers
472 472 */
473 473 if (pci_config_setup(devinfo, &osdep->cfg_handle) != DDI_SUCCESS) {
474 474 igb_error(igb, "Failed to map PCI configurations");
475 475 goto attach_fail;
476 476 }
477 477 igb->attach_progress |= ATTACH_PROGRESS_PCI_CONFIG;
478 478
479 479 /*
480 480 * Identify the chipset family
481 481 */
482 482 if (igb_identify_hardware(igb) != IGB_SUCCESS) {
483 483 igb_error(igb, "Failed to identify hardware");
484 484 goto attach_fail;
485 485 }
486 486
487 487 /*
488 488 * Map device registers
489 489 */
490 490 if (igb_regs_map(igb) != IGB_SUCCESS) {
491 491 igb_error(igb, "Failed to map device registers");
492 492 goto attach_fail;
493 493 }
494 494 igb->attach_progress |= ATTACH_PROGRESS_REGS_MAP;
495 495
496 496 /*
497 497 * Initialize driver parameters
498 498 */
499 499 igb_init_properties(igb);
500 500 igb->attach_progress |= ATTACH_PROGRESS_PROPS;
501 501
502 502 /*
503 503 * Allocate interrupts
504 504 */
505 505 if (igb_alloc_intrs(igb) != IGB_SUCCESS) {
506 506 igb_error(igb, "Failed to allocate interrupts");
507 507 goto attach_fail;
508 508 }
509 509 igb->attach_progress |= ATTACH_PROGRESS_ALLOC_INTR;
510 510
511 511 /*
512 512 * Allocate rx/tx rings based on the ring numbers.
513 513 * The actual numbers of rx/tx rings are decided by the number of
514 514 * allocated interrupt vectors, so we should allocate the rings after
515 515 * interrupts are allocated.
516 516 */
517 517 if (igb_alloc_rings(igb) != IGB_SUCCESS) {
518 518 igb_error(igb, "Failed to allocate rx/tx rings or groups");
519 519 goto attach_fail;
520 520 }
521 521 igb->attach_progress |= ATTACH_PROGRESS_ALLOC_RINGS;
522 522
523 523 /*
524 524 * Add interrupt handlers
525 525 */
526 526 if (igb_add_intr_handlers(igb) != IGB_SUCCESS) {
527 527 igb_error(igb, "Failed to add interrupt handlers");
528 528 goto attach_fail;
529 529 }
530 530 igb->attach_progress |= ATTACH_PROGRESS_ADD_INTR;
531 531
532 532 /*
533 533 * Initialize driver parameters
534 534 */
535 535 if (igb_init_driver_settings(igb) != IGB_SUCCESS) {
536 536 igb_error(igb, "Failed to initialize driver settings");
537 537 goto attach_fail;
538 538 }
539 539
540 540 if (igb_check_acc_handle(igb->osdep.cfg_handle) != DDI_FM_OK) {
541 541 ddi_fm_service_impact(igb->dip, DDI_SERVICE_LOST);
542 542 goto attach_fail;
543 543 }
544 544
545 545 /*
546 546 * Initialize mutexes for this device.
547 547 * Do this before enabling the interrupt handler and
548 548 * register the softint to avoid the condition where
549 549 * interrupt handler can try using uninitialized mutex
550 550 */
551 551 igb_init_locks(igb);
552 552 igb->attach_progress |= ATTACH_PROGRESS_LOCKS;
553 553
554 554 /*
555 555 * Initialize the adapter
556 556 */
557 557 if (igb_init(igb) != IGB_SUCCESS) {
558 558 igb_error(igb, "Failed to initialize adapter");
559 559 goto attach_fail;
560 560 }
561 561 igb->attach_progress |= ATTACH_PROGRESS_INIT_ADAPTER;
562 562
563 563 /*
564 564 * Initialize statistics
565 565 */
566 566 if (igb_init_stats(igb) != IGB_SUCCESS) {
567 567 igb_error(igb, "Failed to initialize statistics");
568 568 goto attach_fail;
569 569 }
570 570 igb->attach_progress |= ATTACH_PROGRESS_STATS;
571 571
572 572 /*
573 573 * Register the driver to the MAC
574 574 */
575 575 if (igb_register_mac(igb) != IGB_SUCCESS) {
576 576 igb_error(igb, "Failed to register MAC");
577 577 goto attach_fail;
578 578 }
579 579 igb->attach_progress |= ATTACH_PROGRESS_MAC;
580 580
581 581 /*
582 582 * Now that mutex locks are initialized, and the chip is also
583 583 * initialized, enable interrupts.
584 584 */
585 585 if (igb_enable_intrs(igb) != IGB_SUCCESS) {
586 586 igb_error(igb, "Failed to enable DDI interrupts");
587 587 goto attach_fail;
588 588 }
589 589 igb->attach_progress |= ATTACH_PROGRESS_ENABLE_INTR;
590 590
591 591 igb_log(igb, "%s", igb_version);
592 592 atomic_or_32(&igb->igb_state, IGB_INITIALIZED);
593 593
594 594 /*
595 595 * Newer models have Energy Efficient Ethernet, let's disable this by
596 596 * default.
597 597 */
598 598 if (igb->hw.mac.type == e1000_i350)
599 599 (void) e1000_set_eee_i350(&igb->hw);
600 600 else if (igb->hw.mac.type == e1000_i354)
601 601 (void) e1000_set_eee_i354(&igb->hw);
602 602
603 603 return (DDI_SUCCESS);
604 604
605 605 attach_fail:
606 606 igb_unconfigure(devinfo, igb);
607 607 return (DDI_FAILURE);
608 608 }
609 609
610 610 /*
611 611 * igb_detach - driver detach
612 612 *
613 613 * The detach() function is the complement of the attach routine.
614 614 * If cmd is set to DDI_DETACH, detach() is used to remove the
615 615 * state associated with a given instance of a device node
616 616 * prior to the removal of that instance from the system.
617 617 *
618 618 * The detach() function will be called once for each instance
619 619 * of the device for which there has been a successful attach()
620 620 * once there are no longer any opens on the device.
621 621 *
622 622 * Interrupts routine are disabled, All memory allocated by this
623 623 * driver are freed.
624 624 */
625 625 static int
626 626 igb_detach(dev_info_t *devinfo, ddi_detach_cmd_t cmd)
627 627 {
628 628 igb_t *igb;
629 629
630 630 /*
631 631 * Check detach command
632 632 */
633 633 switch (cmd) {
634 634 default:
635 635 return (DDI_FAILURE);
636 636
637 637 case DDI_SUSPEND:
638 638 return (igb_suspend(devinfo));
639 639
640 640 case DDI_DETACH:
641 641 break;
642 642 }
643 643
644 644
645 645 /*
646 646 * Get the pointer to the driver private data structure
647 647 */
648 648 igb = (igb_t *)ddi_get_driver_private(devinfo);
649 649 if (igb == NULL)
650 650 return (DDI_FAILURE);
651 651
652 652 /*
653 653 * Unregister MAC. If failed, we have to fail the detach
654 654 */
655 655 if (mac_unregister(igb->mac_hdl) != 0) {
656 656 igb_error(igb, "Failed to unregister MAC");
657 657 return (DDI_FAILURE);
658 658 }
659 659 igb->attach_progress &= ~ATTACH_PROGRESS_MAC;
660 660
661 661 /*
662 662 * If the device is still running, it needs to be stopped first.
663 663 * This check is necessary because under some specific circumstances,
664 664 * the detach routine can be called without stopping the interface
665 665 * first.
666 666 */
667 667 mutex_enter(&igb->gen_lock);
668 668 if (igb->igb_state & IGB_STARTED) {
669 669 atomic_and_32(&igb->igb_state, ~IGB_STARTED);
670 670 igb_stop(igb, B_TRUE);
671 671 mutex_exit(&igb->gen_lock);
672 672 /* Disable and stop the watchdog timer */
673 673 igb_disable_watchdog_timer(igb);
674 674 } else
675 675 mutex_exit(&igb->gen_lock);
676 676
677 677 /*
678 678 * Check if there are still rx buffers held by the upper layer.
679 679 * If so, fail the detach.
680 680 */
681 681 if (!igb_rx_drain(igb))
682 682 return (DDI_FAILURE);
683 683
684 684 /*
685 685 * Do the remaining unconfigure routines
686 686 */
687 687 igb_unconfigure(devinfo, igb);
688 688
689 689 return (DDI_SUCCESS);
690 690 }
691 691
692 692 /*
693 693 * quiesce(9E) entry point.
694 694 *
695 695 * This function is called when the system is single-threaded at high
696 696 * PIL with preemption disabled. Therefore, this function must not be
697 697 * blocked.
698 698 *
699 699 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
700 700 * DDI_FAILURE indicates an error condition and should almost never happen.
701 701 */
702 702 static int
703 703 igb_quiesce(dev_info_t *devinfo)
704 704 {
705 705 igb_t *igb;
706 706 struct e1000_hw *hw;
707 707
708 708 igb = (igb_t *)ddi_get_driver_private(devinfo);
709 709
710 710 if (igb == NULL)
711 711 return (DDI_FAILURE);
712 712
713 713 hw = &igb->hw;
714 714
715 715 /*
716 716 * Disable the adapter interrupts
717 717 */
718 718 igb_disable_adapter_interrupts(igb);
719 719
720 720 /* Tell firmware driver is no longer in control */
721 721 igb_release_driver_control(hw);
722 722
723 723 /*
724 724 * Reset the chipset
725 725 */
726 726 (void) e1000_reset_hw(hw);
727 727
728 728 /*
729 729 * Reset PHY if possible
730 730 */
731 731 if (e1000_check_reset_block(hw) == E1000_SUCCESS)
732 732 (void) e1000_phy_hw_reset(hw);
733 733
734 734 return (DDI_SUCCESS);
735 735 }
736 736
737 737 /*
738 738 * igb_unconfigure - release all resources held by this instance
739 739 */
740 740 static void
741 741 igb_unconfigure(dev_info_t *devinfo, igb_t *igb)
742 742 {
743 743 /*
744 744 * Disable interrupt
745 745 */
746 746 if (igb->attach_progress & ATTACH_PROGRESS_ENABLE_INTR) {
747 747 (void) igb_disable_intrs(igb);
748 748 }
749 749
750 750 /*
751 751 * Unregister MAC
752 752 */
753 753 if (igb->attach_progress & ATTACH_PROGRESS_MAC) {
754 754 (void) mac_unregister(igb->mac_hdl);
755 755 }
756 756
757 757 /*
758 758 * Free statistics
759 759 */
760 760 if (igb->attach_progress & ATTACH_PROGRESS_STATS) {
761 761 kstat_delete((kstat_t *)igb->igb_ks);
762 762 }
763 763
764 764 /*
765 765 * Remove interrupt handlers
766 766 */
767 767 if (igb->attach_progress & ATTACH_PROGRESS_ADD_INTR) {
768 768 igb_rem_intr_handlers(igb);
769 769 }
770 770
771 771 /*
772 772 * Remove interrupts
773 773 */
774 774 if (igb->attach_progress & ATTACH_PROGRESS_ALLOC_INTR) {
775 775 igb_rem_intrs(igb);
776 776 }
777 777
778 778 /*
779 779 * Remove driver properties
780 780 */
781 781 if (igb->attach_progress & ATTACH_PROGRESS_PROPS) {
782 782 (void) ddi_prop_remove_all(devinfo);
783 783 }
784 784
785 785 /*
786 786 * Stop the adapter
787 787 */
788 788 if (igb->attach_progress & ATTACH_PROGRESS_INIT_ADAPTER) {
789 789 mutex_enter(&igb->gen_lock);
790 790 igb_stop_adapter(igb);
791 791 mutex_exit(&igb->gen_lock);
792 792 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK)
793 793 ddi_fm_service_impact(igb->dip, DDI_SERVICE_UNAFFECTED);
794 794 }
795 795
796 796 /*
797 797 * Free multicast table
798 798 */
799 799 igb_release_multicast(igb);
800 800
801 801 /*
802 802 * Free register handle
803 803 */
804 804 if (igb->attach_progress & ATTACH_PROGRESS_REGS_MAP) {
805 805 if (igb->osdep.reg_handle != NULL)
806 806 ddi_regs_map_free(&igb->osdep.reg_handle);
807 807 }
808 808
809 809 /*
810 810 * Free PCI config handle
811 811 */
812 812 if (igb->attach_progress & ATTACH_PROGRESS_PCI_CONFIG) {
813 813 if (igb->osdep.cfg_handle != NULL)
814 814 pci_config_teardown(&igb->osdep.cfg_handle);
815 815 }
816 816
817 817 /*
818 818 * Free locks
819 819 */
820 820 if (igb->attach_progress & ATTACH_PROGRESS_LOCKS) {
821 821 igb_destroy_locks(igb);
822 822 }
823 823
824 824 /*
825 825 * Free the rx/tx rings
826 826 */
827 827 if (igb->attach_progress & ATTACH_PROGRESS_ALLOC_RINGS) {
828 828 igb_free_rings(igb);
829 829 }
830 830
831 831 /*
832 832 * Remove FMA
833 833 */
834 834 if (igb->attach_progress & ATTACH_PROGRESS_FMINIT) {
835 835 igb_fm_fini(igb);
836 836 }
837 837
838 838 /*
839 839 * Free the driver data structure
840 840 */
841 841 kmem_free(igb, sizeof (igb_t));
842 842
843 843 ddi_set_driver_private(devinfo, NULL);
844 844 }
845 845
846 846 /*
847 847 * igb_register_mac - Register the driver and its function pointers with
848 848 * the GLD interface
849 849 */
850 850 static int
851 851 igb_register_mac(igb_t *igb)
852 852 {
853 853 struct e1000_hw *hw = &igb->hw;
854 854 mac_register_t *mac;
855 855 int status;
856 856
857 857 if ((mac = mac_alloc(MAC_VERSION)) == NULL)
858 858 return (IGB_FAILURE);
859 859
860 860 mac->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
861 861 mac->m_driver = igb;
862 862 mac->m_dip = igb->dip;
863 863 mac->m_src_addr = hw->mac.addr;
864 864 mac->m_callbacks = &igb_m_callbacks;
865 865 mac->m_min_sdu = 0;
866 866 mac->m_max_sdu = igb->max_frame_size -
867 867 sizeof (struct ether_vlan_header) - ETHERFCSL;
868 868 mac->m_margin = VLAN_TAGSZ;
869 869 mac->m_priv_props = igb_priv_props;
870 870 mac->m_v12n = MAC_VIRT_LEVEL1;
871 871
872 872 status = mac_register(mac, &igb->mac_hdl);
873 873
874 874 mac_free(mac);
875 875
876 876 return ((status == 0) ? IGB_SUCCESS : IGB_FAILURE);
877 877 }
878 878
879 879 /*
880 880 * igb_identify_hardware - Identify the type of the chipset
881 881 */
882 882 static int
883 883 igb_identify_hardware(igb_t *igb)
884 884 {
885 885 struct e1000_hw *hw = &igb->hw;
886 886 struct igb_osdep *osdep = &igb->osdep;
887 887
888 888 /*
889 889 * Get the device id
890 890 */
891 891 hw->vendor_id =
892 892 pci_config_get16(osdep->cfg_handle, PCI_CONF_VENID);
893 893 hw->device_id =
894 894 pci_config_get16(osdep->cfg_handle, PCI_CONF_DEVID);
895 895 hw->revision_id =
896 896 pci_config_get8(osdep->cfg_handle, PCI_CONF_REVID);
897 897 hw->subsystem_device_id =
898 898 pci_config_get16(osdep->cfg_handle, PCI_CONF_SUBSYSID);
899 899 hw->subsystem_vendor_id =
900 900 pci_config_get16(osdep->cfg_handle, PCI_CONF_SUBVENID);
901 901
902 902 /*
903 903 * Set the mac type of the adapter based on the device id
904 904 */
905 905 if (e1000_set_mac_type(hw) != E1000_SUCCESS) {
906 906 return (IGB_FAILURE);
907 907 }
908 908
909 909 /*
910 910 * Install adapter capabilities based on mac type
911 911 */
912 912 switch (hw->mac.type) {
913 913 case e1000_82575:
914 914 igb->capab = &igb_82575_cap;
915 915 break;
916 916 case e1000_82576:
917 917 igb->capab = &igb_82576_cap;
918 918 break;
919 919 case e1000_82580:
920 920 igb->capab = &igb_82580_cap;
921 921 break;
922 922 case e1000_i350:
923 923 igb->capab = &igb_i350_cap;
924 924 break;
925 925 case e1000_i210:
926 926 case e1000_i211:
927 927 igb->capab = &igb_i210_cap;
928 928 break;
929 929 case e1000_i354:
930 930 igb->capab = &igb_i354_cap;
931 931 break;
932 932 default:
933 933 return (IGB_FAILURE);
934 934 }
935 935
936 936 return (IGB_SUCCESS);
937 937 }
938 938
939 939 /*
940 940 * igb_regs_map - Map the device registers
941 941 */
942 942 static int
943 943 igb_regs_map(igb_t *igb)
944 944 {
945 945 dev_info_t *devinfo = igb->dip;
946 946 struct e1000_hw *hw = &igb->hw;
947 947 struct igb_osdep *osdep = &igb->osdep;
948 948 off_t mem_size;
949 949
950 950 /*
951 951 * First get the size of device registers to be mapped.
952 952 */
953 953 if (ddi_dev_regsize(devinfo, IGB_ADAPTER_REGSET, &mem_size) !=
954 954 DDI_SUCCESS) {
955 955 return (IGB_FAILURE);
956 956 }
957 957
958 958 /*
959 959 * Call ddi_regs_map_setup() to map registers
960 960 */
961 961 if ((ddi_regs_map_setup(devinfo, IGB_ADAPTER_REGSET,
962 962 (caddr_t *)&hw->hw_addr, 0,
963 963 mem_size, &igb_regs_acc_attr,
964 964 &osdep->reg_handle)) != DDI_SUCCESS) {
965 965 return (IGB_FAILURE);
966 966 }
967 967
968 968 return (IGB_SUCCESS);
969 969 }
970 970
971 971 /*
972 972 * igb_init_properties - Initialize driver properties
973 973 */
974 974 static void
975 975 igb_init_properties(igb_t *igb)
976 976 {
977 977 /*
978 978 * Get conf file properties, including link settings
979 979 * jumbo frames, ring number, descriptor number, etc.
980 980 */
981 981 igb_get_conf(igb);
982 982 }
983 983
984 984 /*
985 985 * igb_init_driver_settings - Initialize driver settings
986 986 *
987 987 * The settings include hardware function pointers, bus information,
988 988 * rx/tx rings settings, link state, and any other parameters that
989 989 * need to be setup during driver initialization.
990 990 */
991 991 static int
992 992 igb_init_driver_settings(igb_t *igb)
993 993 {
994 994 struct e1000_hw *hw = &igb->hw;
995 995 igb_rx_ring_t *rx_ring;
996 996 igb_tx_ring_t *tx_ring;
997 997 uint32_t rx_size;
998 998 uint32_t tx_size;
999 999 int i;
1000 1000
1001 1001 /*
1002 1002 * Initialize chipset specific hardware function pointers
1003 1003 */
1004 1004 if (e1000_setup_init_funcs(hw, B_TRUE) != E1000_SUCCESS) {
1005 1005 return (IGB_FAILURE);
1006 1006 }
1007 1007
1008 1008 /*
1009 1009 * Get bus information
1010 1010 */
1011 1011 if (e1000_get_bus_info(hw) != E1000_SUCCESS) {
1012 1012 return (IGB_FAILURE);
1013 1013 }
1014 1014
1015 1015 /*
1016 1016 * Get the system page size
1017 1017 */
1018 1018 igb->page_size = ddi_ptob(igb->dip, (ulong_t)1);
1019 1019
1020 1020 /*
1021 1021 * Set rx buffer size
1022 1022 * The IP header alignment room is counted in the calculation.
1023 1023 * The rx buffer size is in unit of 1K that is required by the
1024 1024 * chipset hardware.
1025 1025 */
1026 1026 rx_size = igb->max_frame_size + IPHDR_ALIGN_ROOM;
1027 1027 igb->rx_buf_size = ((rx_size >> 10) +
1028 1028 ((rx_size & (((uint32_t)1 << 10) - 1)) > 0 ? 1 : 0)) << 10;
1029 1029
1030 1030 /*
1031 1031 * Set tx buffer size
1032 1032 */
1033 1033 tx_size = igb->max_frame_size;
1034 1034 igb->tx_buf_size = ((tx_size >> 10) +
1035 1035 ((tx_size & (((uint32_t)1 << 10) - 1)) > 0 ? 1 : 0)) << 10;
1036 1036
1037 1037 /*
1038 1038 * Initialize rx/tx rings parameters
1039 1039 */
1040 1040 for (i = 0; i < igb->num_rx_rings; i++) {
1041 1041 rx_ring = &igb->rx_rings[i];
1042 1042 rx_ring->index = i;
1043 1043 rx_ring->igb = igb;
1044 1044 }
1045 1045
1046 1046 for (i = 0; i < igb->num_tx_rings; i++) {
1047 1047 tx_ring = &igb->tx_rings[i];
1048 1048 tx_ring->index = i;
1049 1049 tx_ring->igb = igb;
1050 1050 if (igb->tx_head_wb_enable)
1051 1051 tx_ring->tx_recycle = igb_tx_recycle_head_wb;
1052 1052 else
1053 1053 tx_ring->tx_recycle = igb_tx_recycle_legacy;
1054 1054
1055 1055 tx_ring->ring_size = igb->tx_ring_size;
1056 1056 tx_ring->free_list_size = igb->tx_ring_size +
1057 1057 (igb->tx_ring_size >> 1);
1058 1058 }
1059 1059
1060 1060 /*
1061 1061 * Initialize values of interrupt throttling rates
1062 1062 */
1063 1063 for (i = 1; i < MAX_NUM_EITR; i++)
1064 1064 igb->intr_throttling[i] = igb->intr_throttling[0];
1065 1065
1066 1066 /*
1067 1067 * The initial link state should be "unknown"
1068 1068 */
1069 1069 igb->link_state = LINK_STATE_UNKNOWN;
1070 1070
1071 1071 return (IGB_SUCCESS);
1072 1072 }
1073 1073
1074 1074 /*
1075 1075 * igb_init_locks - Initialize locks
1076 1076 */
1077 1077 static void
1078 1078 igb_init_locks(igb_t *igb)
1079 1079 {
1080 1080 igb_rx_ring_t *rx_ring;
1081 1081 igb_tx_ring_t *tx_ring;
1082 1082 int i;
1083 1083
1084 1084 for (i = 0; i < igb->num_rx_rings; i++) {
1085 1085 rx_ring = &igb->rx_rings[i];
1086 1086 mutex_init(&rx_ring->rx_lock, NULL,
1087 1087 MUTEX_DRIVER, DDI_INTR_PRI(igb->intr_pri));
1088 1088 }
1089 1089
1090 1090 for (i = 0; i < igb->num_tx_rings; i++) {
1091 1091 tx_ring = &igb->tx_rings[i];
1092 1092 mutex_init(&tx_ring->tx_lock, NULL,
1093 1093 MUTEX_DRIVER, DDI_INTR_PRI(igb->intr_pri));
1094 1094 mutex_init(&tx_ring->recycle_lock, NULL,
1095 1095 MUTEX_DRIVER, DDI_INTR_PRI(igb->intr_pri));
1096 1096 mutex_init(&tx_ring->tcb_head_lock, NULL,
1097 1097 MUTEX_DRIVER, DDI_INTR_PRI(igb->intr_pri));
1098 1098 mutex_init(&tx_ring->tcb_tail_lock, NULL,
1099 1099 MUTEX_DRIVER, DDI_INTR_PRI(igb->intr_pri));
1100 1100 }
1101 1101
1102 1102 mutex_init(&igb->gen_lock, NULL,
1103 1103 MUTEX_DRIVER, DDI_INTR_PRI(igb->intr_pri));
1104 1104
1105 1105 mutex_init(&igb->watchdog_lock, NULL,
1106 1106 MUTEX_DRIVER, DDI_INTR_PRI(igb->intr_pri));
1107 1107
1108 1108 mutex_init(&igb->link_lock, NULL,
1109 1109 MUTEX_DRIVER, DDI_INTR_PRI(igb->intr_pri));
1110 1110 }
1111 1111
1112 1112 /*
1113 1113 * igb_destroy_locks - Destroy locks
1114 1114 */
1115 1115 static void
1116 1116 igb_destroy_locks(igb_t *igb)
1117 1117 {
1118 1118 igb_rx_ring_t *rx_ring;
1119 1119 igb_tx_ring_t *tx_ring;
1120 1120 int i;
1121 1121
1122 1122 for (i = 0; i < igb->num_rx_rings; i++) {
1123 1123 rx_ring = &igb->rx_rings[i];
1124 1124 mutex_destroy(&rx_ring->rx_lock);
1125 1125 }
1126 1126
1127 1127 for (i = 0; i < igb->num_tx_rings; i++) {
1128 1128 tx_ring = &igb->tx_rings[i];
1129 1129 mutex_destroy(&tx_ring->tx_lock);
1130 1130 mutex_destroy(&tx_ring->recycle_lock);
1131 1131 mutex_destroy(&tx_ring->tcb_head_lock);
1132 1132 mutex_destroy(&tx_ring->tcb_tail_lock);
1133 1133 }
1134 1134
1135 1135 mutex_destroy(&igb->gen_lock);
1136 1136 mutex_destroy(&igb->watchdog_lock);
1137 1137 mutex_destroy(&igb->link_lock);
1138 1138 }
1139 1139
1140 1140 static int
1141 1141 igb_resume(dev_info_t *devinfo)
1142 1142 {
1143 1143 igb_t *igb;
1144 1144
1145 1145 igb = (igb_t *)ddi_get_driver_private(devinfo);
1146 1146 if (igb == NULL)
1147 1147 return (DDI_FAILURE);
1148 1148
1149 1149 mutex_enter(&igb->gen_lock);
1150 1150
1151 1151 /*
1152 1152 * Enable interrupts
1153 1153 */
1154 1154 if (igb->attach_progress & ATTACH_PROGRESS_ENABLE_INTR) {
1155 1155 if (igb_enable_intrs(igb) != IGB_SUCCESS) {
1156 1156 igb_error(igb, "Failed to enable DDI interrupts");
1157 1157 mutex_exit(&igb->gen_lock);
1158 1158 return (DDI_FAILURE);
1159 1159 }
1160 1160 }
1161 1161
1162 1162 if (igb->igb_state & IGB_STARTED) {
1163 1163 if (igb_start(igb, B_FALSE) != IGB_SUCCESS) {
1164 1164 mutex_exit(&igb->gen_lock);
1165 1165 return (DDI_FAILURE);
1166 1166 }
1167 1167
1168 1168 /*
1169 1169 * Enable and start the watchdog timer
1170 1170 */
1171 1171 igb_enable_watchdog_timer(igb);
1172 1172 }
1173 1173
1174 1174 atomic_and_32(&igb->igb_state, ~IGB_SUSPENDED);
1175 1175
1176 1176 mutex_exit(&igb->gen_lock);
1177 1177
1178 1178 return (DDI_SUCCESS);
1179 1179 }
1180 1180
1181 1181 static int
1182 1182 igb_suspend(dev_info_t *devinfo)
1183 1183 {
1184 1184 igb_t *igb;
1185 1185
1186 1186 igb = (igb_t *)ddi_get_driver_private(devinfo);
1187 1187 if (igb == NULL)
1188 1188 return (DDI_FAILURE);
1189 1189
1190 1190 mutex_enter(&igb->gen_lock);
1191 1191
1192 1192 atomic_or_32(&igb->igb_state, IGB_SUSPENDED);
1193 1193
1194 1194 /*
1195 1195 * Disable interrupts
1196 1196 */
1197 1197 if (igb->attach_progress & ATTACH_PROGRESS_ENABLE_INTR) {
1198 1198 (void) igb_disable_intrs(igb);
1199 1199 }
1200 1200
1201 1201 if (!(igb->igb_state & IGB_STARTED)) {
1202 1202 mutex_exit(&igb->gen_lock);
1203 1203 return (DDI_SUCCESS);
1204 1204 }
1205 1205
1206 1206 igb_stop(igb, B_FALSE);
1207 1207
1208 1208 mutex_exit(&igb->gen_lock);
1209 1209
1210 1210 /*
1211 1211 * Disable and stop the watchdog timer
1212 1212 */
1213 1213 igb_disable_watchdog_timer(igb);
1214 1214
1215 1215 return (DDI_SUCCESS);
1216 1216 }
1217 1217
1218 1218 static int
1219 1219 igb_init(igb_t *igb)
1220 1220 {
1221 1221 mutex_enter(&igb->gen_lock);
1222 1222
1223 1223 /*
1224 1224 * Initilize the adapter
1225 1225 */
1226 1226 if (igb_init_adapter(igb) != IGB_SUCCESS) {
1227 1227 mutex_exit(&igb->gen_lock);
1228 1228 igb_fm_ereport(igb, DDI_FM_DEVICE_INVAL_STATE);
1229 1229 ddi_fm_service_impact(igb->dip, DDI_SERVICE_LOST);
1230 1230 return (IGB_FAILURE);
1231 1231 }
1232 1232
1233 1233 mutex_exit(&igb->gen_lock);
1234 1234
1235 1235 return (IGB_SUCCESS);
1236 1236 }
1237 1237
1238 1238 /*
1239 1239 * igb_init_mac_address - Initialize the default MAC address
1240 1240 *
1241 1241 * On success, the MAC address is entered in the igb->hw.mac.addr
1242 1242 * and hw->mac.perm_addr fields and the adapter's RAR(0) receive
1243 1243 * address register.
1244 1244 *
1245 1245 * Important side effects:
1246 1246 * 1. adapter is reset - this is required to put it in a known state.
1247 1247 * 2. all of non-volatile memory (NVM) is read & checksummed - NVM is where
1248 1248 * MAC address and all default settings are stored, so a valid checksum
1249 1249 * is required.
1250 1250 */
1251 1251 static int
1252 1252 igb_init_mac_address(igb_t *igb)
1253 1253 {
1254 1254 struct e1000_hw *hw = &igb->hw;
1255 1255
1256 1256 ASSERT(mutex_owned(&igb->gen_lock));
1257 1257
1258 1258 /*
1259 1259 * Reset chipset to put the hardware in a known state
1260 1260 * before we try to get MAC address from NVM.
1261 1261 */
1262 1262 if (e1000_reset_hw(hw) != E1000_SUCCESS) {
1263 1263 igb_error(igb, "Adapter reset failed.");
1264 1264 goto init_mac_fail;
1265 1265 }
1266 1266
1267 1267 /*
1268 1268 * NVM validation
1269 1269 */
1270 1270 if (((igb->hw.mac.type != e1000_i210) &&
1271 1271 (igb->hw.mac.type != e1000_i211)) &&
1272 1272 (e1000_validate_nvm_checksum(hw) < 0)) {
1273 1273 /*
1274 1274 * Some PCI-E parts fail the first check due to
1275 1275 * the link being in sleep state. Call it again,
1276 1276 * if it fails a second time its a real issue.
1277 1277 */
1278 1278 if (e1000_validate_nvm_checksum(hw) < 0) {
1279 1279 igb_error(igb,
1280 1280 "Invalid NVM checksum. Please contact "
1281 1281 "the vendor to update the NVM.");
1282 1282 goto init_mac_fail;
1283 1283 }
1284 1284 }
1285 1285
1286 1286 /*
1287 1287 * Get the mac address
1288 1288 * This function should handle SPARC case correctly.
1289 1289 */
1290 1290 if (!igb_find_mac_address(igb)) {
1291 1291 igb_error(igb, "Failed to get the mac address");
1292 1292 goto init_mac_fail;
1293 1293 }
1294 1294
1295 1295 /* Validate mac address */
1296 1296 if (!is_valid_mac_addr(hw->mac.addr)) {
1297 1297 igb_error(igb, "Invalid mac address");
1298 1298 goto init_mac_fail;
1299 1299 }
1300 1300
1301 1301 return (IGB_SUCCESS);
1302 1302
1303 1303 init_mac_fail:
1304 1304 return (IGB_FAILURE);
1305 1305 }
1306 1306
1307 1307 /*
1308 1308 * igb_init_adapter - Initialize the adapter
1309 1309 */
1310 1310 static int
1311 1311 igb_init_adapter(igb_t *igb)
1312 1312 {
1313 1313 struct e1000_hw *hw = &igb->hw;
1314 1314 uint32_t pba;
1315 1315 int oemid[2];
1316 1316 uint16_t nvmword;
1317 1317 uint32_t hwm;
1318 1318 uint32_t default_mtu;
1319 1319 u8 pbanum[E1000_PBANUM_LENGTH];
1320 1320 char eepromver[5]; /* f.ff */
1321 1321 int i;
1322 1322
1323 1323 ASSERT(mutex_owned(&igb->gen_lock));
1324 1324
1325 1325 /*
1326 1326 * In order to obtain the default MAC address, this will reset the
1327 1327 * adapter and validate the NVM that the address and many other
1328 1328 * default settings come from.
1329 1329 */
1330 1330 if (igb_init_mac_address(igb) != IGB_SUCCESS) {
1331 1331 igb_error(igb, "Failed to initialize MAC address");
1332 1332 goto init_adapter_fail;
1333 1333 }
1334 1334
1335 1335 /*
1336 1336 * Packet Buffer Allocation (PBA)
1337 1337 * Writing PBA sets the receive portion of the buffer
1338 1338 * the remainder is used for the transmit buffer.
1339 1339 */
1340 1340 switch (hw->mac.type) {
1341 1341 case e1000_82575:
1342 1342 pba = E1000_PBA_32K;
1343 1343 break;
1344 1344 case e1000_82576:
1345 1345 pba = E1000_READ_REG(hw, E1000_RXPBS);
1346 1346 pba &= E1000_RXPBS_SIZE_MASK_82576;
1347 1347 break;
1348 1348 case e1000_82580:
1349 1349 case e1000_i350:
1350 1350 case e1000_i354:
1351 1351 pba = E1000_READ_REG(hw, E1000_RXPBS);
1352 1352 pba = e1000_rxpbs_adjust_82580(pba);
1353 1353 break;
1354 1354 case e1000_i210:
1355 1355 case e1000_i211:
1356 1356 pba = E1000_PBA_34K;
1357 1357 default:
1358 1358 break;
1359 1359 }
1360 1360
1361 1361 /* Special needs in case of Jumbo frames */
1362 1362 default_mtu = igb_get_prop(igb, PROP_DEFAULT_MTU,
1363 1363 MIN_MTU, MAX_MTU, DEFAULT_MTU);
1364 1364 if ((hw->mac.type == e1000_82575) && (default_mtu > ETHERMTU)) {
1365 1365 u32 tx_space, min_tx, min_rx;
1366 1366 pba = E1000_READ_REG(hw, E1000_PBA);
1367 1367 tx_space = pba >> 16;
1368 1368 pba &= 0xffff;
1369 1369 min_tx = (igb->max_frame_size +
1370 1370 sizeof (struct e1000_tx_desc) - ETHERNET_FCS_SIZE) * 2;
1371 1371 min_tx = roundup(min_tx, 1024);
1372 1372 min_tx >>= 10;
1373 1373 min_rx = igb->max_frame_size;
1374 1374 min_rx = roundup(min_rx, 1024);
1375 1375 min_rx >>= 10;
1376 1376 if (tx_space < min_tx &&
1377 1377 ((min_tx - tx_space) < pba)) {
1378 1378 pba = pba - (min_tx - tx_space);
1379 1379 /*
1380 1380 * if short on rx space, rx wins
1381 1381 * and must trump tx adjustment
1382 1382 */
1383 1383 if (pba < min_rx)
1384 1384 pba = min_rx;
1385 1385 }
1386 1386 E1000_WRITE_REG(hw, E1000_PBA, pba);
1387 1387 }
1388 1388
1389 1389 DEBUGOUT1("igb_init: pba=%dK", pba);
1390 1390
1391 1391 /*
1392 1392 * These parameters control the automatic generation (Tx) and
1393 1393 * response (Rx) to Ethernet PAUSE frames.
1394 1394 * - High water mark should allow for at least two frames to be
1395 1395 * received after sending an XOFF.
1396 1396 * - Low water mark works best when it is very near the high water mark.
1397 1397 * This allows the receiver to restart by sending XON when it has
1398 1398 * drained a bit.
1399 1399 */
1400 1400 hwm = min(((pba << 10) * 9 / 10),
1401 1401 ((pba << 10) - 2 * igb->max_frame_size));
1402 1402
1403 1403 if (hw->mac.type < e1000_82576) {
1404 1404 hw->fc.high_water = hwm & 0xFFF8; /* 8-byte granularity */
1405 1405 hw->fc.low_water = hw->fc.high_water - 8;
1406 1406 } else {
1407 1407 hw->fc.high_water = hwm & 0xFFF0; /* 16-byte granularity */
1408 1408 hw->fc.low_water = hw->fc.high_water - 16;
1409 1409 }
1410 1410
1411 1411 hw->fc.pause_time = E1000_FC_PAUSE_TIME;
1412 1412 hw->fc.send_xon = B_TRUE;
1413 1413
1414 1414 (void) e1000_validate_mdi_setting(hw);
1415 1415
1416 1416 /*
1417 1417 * Reset the chipset hardware the second time to put PBA settings
1418 1418 * into effect.
1419 1419 */
1420 1420 if (e1000_reset_hw(hw) != E1000_SUCCESS) {
1421 1421 igb_error(igb, "Second reset failed");
1422 1422 goto init_adapter_fail;
1423 1423 }
1424 1424
1425 1425 /*
1426 1426 * Don't wait for auto-negotiation to complete
1427 1427 */
1428 1428 hw->phy.autoneg_wait_to_complete = B_FALSE;
1429 1429
1430 1430 /*
1431 1431 * Copper options
1432 1432 */
1433 1433 if (hw->phy.media_type == e1000_media_type_copper) {
1434 1434 hw->phy.mdix = 0; /* AUTO_ALL_MODES */
1435 1435 hw->phy.disable_polarity_correction = B_FALSE;
1436 1436 hw->phy.ms_type = e1000_ms_hw_default; /* E1000_MASTER_SLAVE */
1437 1437 }
1438 1438
1439 1439 /*
1440 1440 * Initialize link settings
1441 1441 */
1442 1442 (void) igb_setup_link(igb, B_FALSE);
1443 1443
1444 1444 /*
1445 1445 * Configure/Initialize hardware
1446 1446 */
1447 1447 if (e1000_init_hw(hw) != E1000_SUCCESS) {
1448 1448 igb_error(igb, "Failed to initialize hardware");
1449 1449 goto init_adapter_fail;
1450 1450 }
1451 1451
1452 1452 /*
1453 1453 * Start the link setup timer
1454 1454 */
1455 1455 igb_start_link_timer(igb);
1456 1456
1457 1457 /*
1458 1458 * Disable wakeup control by default
1459 1459 */
1460 1460 E1000_WRITE_REG(hw, E1000_WUC, 0);
1461 1461
1462 1462 /*
1463 1463 * Record phy info in hw struct
1464 1464 */
1465 1465 (void) e1000_get_phy_info(hw);
1466 1466
1467 1467 /*
1468 1468 * Make sure driver has control
1469 1469 */
1470 1470 igb_get_driver_control(hw);
1471 1471
1472 1472 /*
1473 1473 * Restore LED settings to the default from EEPROM
1474 1474 * to meet the standard for Sun platforms.
1475 1475 */
1476 1476 (void) e1000_cleanup_led(hw);
1477 1477
1478 1478 /*
1479 1479 * Setup MSI-X interrupts
1480 1480 */
1481 1481 if (igb->intr_type == DDI_INTR_TYPE_MSIX)
1482 1482 igb->capab->setup_msix(igb);
1483 1483
1484 1484 /*
1485 1485 * Initialize unicast addresses.
1486 1486 */
1487 1487 igb_init_unicst(igb);
1488 1488
1489 1489 /*
1490 1490 * Setup and initialize the mctable structures.
1491 1491 */
1492 1492 igb_setup_multicst(igb);
1493 1493
1494 1494 /*
1495 1495 * Set interrupt throttling rate
1496 1496 */
1497 1497 for (i = 0; i < igb->intr_cnt; i++)
1498 1498 E1000_WRITE_REG(hw, E1000_EITR(i), igb->intr_throttling[i]);
1499 1499
1500 1500 /*
1501 1501 * Read identifying information and place in devinfo.
1502 1502 */
1503 1503 nvmword = 0xffff;
1504 1504 (void) e1000_read_nvm(&igb->hw, NVM_OEM_OFFSET_0, 1, &nvmword);
1505 1505 oemid[0] = (int)nvmword;
1506 1506 (void) e1000_read_nvm(&igb->hw, NVM_OEM_OFFSET_1, 1, &nvmword);
1507 1507 oemid[1] = (int)nvmword;
1508 1508 (void) ddi_prop_update_int_array(DDI_DEV_T_NONE, igb->dip,
1509 1509 "oem-identifier", oemid, 2);
1510 1510
1511 1511 pbanum[0] = '\0';
1512 1512 (void) e1000_read_pba_string(&igb->hw, pbanum, sizeof (pbanum));
1513 1513 if (*pbanum != '\0') {
1514 1514 (void) ddi_prop_update_string(DDI_DEV_T_NONE, igb->dip,
1515 1515 "printed-board-assembly", (char *)pbanum);
1516 1516 }
1517 1517
1518 1518 nvmword = 0xffff;
1519 1519 (void) e1000_read_nvm(&igb->hw, NVM_VERSION, 1, &nvmword);
1520 1520 if ((nvmword & 0xf00) == 0) {
1521 1521 (void) snprintf(eepromver, sizeof (eepromver), "%x.%x",
1522 1522 (nvmword & 0xf000) >> 12, (nvmword & 0xff));
1523 1523 (void) ddi_prop_update_string(DDI_DEV_T_NONE, igb->dip,
1524 1524 "nvm-version", eepromver);
1525 1525 }
1526 1526
1527 1527 /*
1528 1528 * Save the state of the phy
1529 1529 */
1530 1530 igb_get_phy_state(igb);
1531 1531
1532 1532 igb_param_sync(igb);
1533 1533
1534 1534 return (IGB_SUCCESS);
1535 1535
1536 1536 init_adapter_fail:
1537 1537 /*
1538 1538 * Reset PHY if possible
1539 1539 */
1540 1540 if (e1000_check_reset_block(hw) == E1000_SUCCESS)
1541 1541 (void) e1000_phy_hw_reset(hw);
1542 1542
1543 1543 return (IGB_FAILURE);
1544 1544 }
1545 1545
1546 1546 /*
1547 1547 * igb_stop_adapter - Stop the adapter
1548 1548 */
1549 1549 static void
1550 1550 igb_stop_adapter(igb_t *igb)
1551 1551 {
1552 1552 struct e1000_hw *hw = &igb->hw;
1553 1553
1554 1554 ASSERT(mutex_owned(&igb->gen_lock));
1555 1555
1556 1556 /* Stop the link setup timer */
1557 1557 igb_stop_link_timer(igb);
1558 1558
1559 1559 /* Tell firmware driver is no longer in control */
1560 1560 igb_release_driver_control(hw);
1561 1561
1562 1562 /*
1563 1563 * Reset the chipset
1564 1564 */
1565 1565 if (e1000_reset_hw(hw) != E1000_SUCCESS) {
1566 1566 igb_fm_ereport(igb, DDI_FM_DEVICE_INVAL_STATE);
1567 1567 ddi_fm_service_impact(igb->dip, DDI_SERVICE_LOST);
1568 1568 }
1569 1569
1570 1570 /*
1571 1571 * e1000_phy_hw_reset is not needed here, MAC reset above is sufficient
1572 1572 */
1573 1573 }
1574 1574
1575 1575 /*
1576 1576 * igb_reset - Reset the chipset and restart the driver.
1577 1577 *
1578 1578 * It involves stopping and re-starting the chipset,
1579 1579 * and re-configuring the rx/tx rings.
1580 1580 */
1581 1581 static int
1582 1582 igb_reset(igb_t *igb)
1583 1583 {
1584 1584 int i;
1585 1585
1586 1586 mutex_enter(&igb->gen_lock);
1587 1587
1588 1588 ASSERT(igb->igb_state & IGB_STARTED);
1589 1589 atomic_and_32(&igb->igb_state, ~IGB_STARTED);
1590 1590
1591 1591 /*
1592 1592 * Disable the adapter interrupts to stop any rx/tx activities
1593 1593 * before draining pending data and resetting hardware.
1594 1594 */
1595 1595 igb_disable_adapter_interrupts(igb);
1596 1596
1597 1597 /*
1598 1598 * Drain the pending transmit packets
1599 1599 */
1600 1600 (void) igb_tx_drain(igb);
1601 1601
1602 1602 for (i = 0; i < igb->num_rx_rings; i++)
1603 1603 mutex_enter(&igb->rx_rings[i].rx_lock);
1604 1604 for (i = 0; i < igb->num_tx_rings; i++)
1605 1605 mutex_enter(&igb->tx_rings[i].tx_lock);
1606 1606
1607 1607 /*
1608 1608 * Stop the adapter
1609 1609 */
1610 1610 igb_stop_adapter(igb);
1611 1611
1612 1612 /*
1613 1613 * Clean the pending tx data/resources
1614 1614 */
1615 1615 igb_tx_clean(igb);
1616 1616
1617 1617 /*
1618 1618 * Start the adapter
1619 1619 */
1620 1620 if (igb_init_adapter(igb) != IGB_SUCCESS) {
1621 1621 igb_fm_ereport(igb, DDI_FM_DEVICE_INVAL_STATE);
1622 1622 goto reset_failure;
1623 1623 }
1624 1624
1625 1625 /*
1626 1626 * Setup the rx/tx rings
1627 1627 */
1628 1628 igb->tx_ring_init = B_FALSE;
1629 1629 igb_setup_rings(igb);
1630 1630
1631 1631 atomic_and_32(&igb->igb_state, ~(IGB_ERROR | IGB_STALL));
1632 1632
1633 1633 /*
1634 1634 * Enable adapter interrupts
1635 1635 * The interrupts must be enabled after the driver state is START
1636 1636 */
1637 1637 igb->capab->enable_intr(igb);
1638 1638
1639 1639 if (igb_check_acc_handle(igb->osdep.cfg_handle) != DDI_FM_OK)
1640 1640 goto reset_failure;
1641 1641
1642 1642 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK)
1643 1643 goto reset_failure;
1644 1644
1645 1645 for (i = igb->num_tx_rings - 1; i >= 0; i--)
1646 1646 mutex_exit(&igb->tx_rings[i].tx_lock);
1647 1647 for (i = igb->num_rx_rings - 1; i >= 0; i--)
1648 1648 mutex_exit(&igb->rx_rings[i].rx_lock);
1649 1649
1650 1650 atomic_or_32(&igb->igb_state, IGB_STARTED);
1651 1651
1652 1652 mutex_exit(&igb->gen_lock);
1653 1653
1654 1654 return (IGB_SUCCESS);
1655 1655
1656 1656 reset_failure:
1657 1657 for (i = igb->num_tx_rings - 1; i >= 0; i--)
1658 1658 mutex_exit(&igb->tx_rings[i].tx_lock);
1659 1659 for (i = igb->num_rx_rings - 1; i >= 0; i--)
1660 1660 mutex_exit(&igb->rx_rings[i].rx_lock);
1661 1661
1662 1662 mutex_exit(&igb->gen_lock);
1663 1663
1664 1664 ddi_fm_service_impact(igb->dip, DDI_SERVICE_LOST);
1665 1665
1666 1666 return (IGB_FAILURE);
1667 1667 }
1668 1668
1669 1669 /*
1670 1670 * igb_tx_clean - Clean the pending transmit packets and DMA resources
1671 1671 */
1672 1672 static void
1673 1673 igb_tx_clean(igb_t *igb)
1674 1674 {
1675 1675 igb_tx_ring_t *tx_ring;
1676 1676 tx_control_block_t *tcb;
1677 1677 link_list_t pending_list;
1678 1678 uint32_t desc_num;
1679 1679 int i, j;
1680 1680
1681 1681 LINK_LIST_INIT(&pending_list);
1682 1682
1683 1683 for (i = 0; i < igb->num_tx_rings; i++) {
1684 1684 tx_ring = &igb->tx_rings[i];
1685 1685
1686 1686 mutex_enter(&tx_ring->recycle_lock);
1687 1687
1688 1688 /*
1689 1689 * Clean the pending tx data - the pending packets in the
1690 1690 * work_list that have no chances to be transmitted again.
1691 1691 *
1692 1692 * We must ensure the chipset is stopped or the link is down
1693 1693 * before cleaning the transmit packets.
1694 1694 */
1695 1695 desc_num = 0;
1696 1696 for (j = 0; j < tx_ring->ring_size; j++) {
1697 1697 tcb = tx_ring->work_list[j];
1698 1698 if (tcb != NULL) {
1699 1699 desc_num += tcb->desc_num;
1700 1700
1701 1701 tx_ring->work_list[j] = NULL;
1702 1702
1703 1703 igb_free_tcb(tcb);
1704 1704
1705 1705 LIST_PUSH_TAIL(&pending_list, &tcb->link);
1706 1706 }
1707 1707 }
1708 1708
1709 1709 if (desc_num > 0) {
1710 1710 atomic_add_32(&tx_ring->tbd_free, desc_num);
1711 1711 ASSERT(tx_ring->tbd_free == tx_ring->ring_size);
1712 1712
1713 1713 /*
1714 1714 * Reset the head and tail pointers of the tbd ring;
1715 1715 * Reset the head write-back if it is enabled.
1716 1716 */
1717 1717 tx_ring->tbd_head = 0;
1718 1718 tx_ring->tbd_tail = 0;
1719 1719 if (igb->tx_head_wb_enable)
1720 1720 *tx_ring->tbd_head_wb = 0;
1721 1721
1722 1722 E1000_WRITE_REG(&igb->hw, E1000_TDH(tx_ring->index), 0);
1723 1723 E1000_WRITE_REG(&igb->hw, E1000_TDT(tx_ring->index), 0);
1724 1724 }
1725 1725
1726 1726 mutex_exit(&tx_ring->recycle_lock);
1727 1727
1728 1728 /*
1729 1729 * Add the tx control blocks in the pending list to
1730 1730 * the free list.
1731 1731 */
1732 1732 igb_put_free_list(tx_ring, &pending_list);
1733 1733 }
1734 1734 }
1735 1735
1736 1736 /*
1737 1737 * igb_tx_drain - Drain the tx rings to allow pending packets to be transmitted
1738 1738 */
1739 1739 static boolean_t
1740 1740 igb_tx_drain(igb_t *igb)
1741 1741 {
1742 1742 igb_tx_ring_t *tx_ring;
1743 1743 boolean_t done;
1744 1744 int i, j;
1745 1745
1746 1746 /*
1747 1747 * Wait for a specific time to allow pending tx packets
1748 1748 * to be transmitted.
1749 1749 *
1750 1750 * Check the counter tbd_free to see if transmission is done.
1751 1751 * No lock protection is needed here.
1752 1752 *
1753 1753 * Return B_TRUE if all pending packets have been transmitted;
1754 1754 * Otherwise return B_FALSE;
1755 1755 */
1756 1756 for (i = 0; i < TX_DRAIN_TIME; i++) {
1757 1757
1758 1758 done = B_TRUE;
1759 1759 for (j = 0; j < igb->num_tx_rings; j++) {
1760 1760 tx_ring = &igb->tx_rings[j];
1761 1761 done = done &&
1762 1762 (tx_ring->tbd_free == tx_ring->ring_size);
1763 1763 }
1764 1764
1765 1765 if (done)
1766 1766 break;
1767 1767
1768 1768 msec_delay(1);
1769 1769 }
1770 1770
1771 1771 return (done);
1772 1772 }
1773 1773
1774 1774 /*
1775 1775 * igb_rx_drain - Wait for all rx buffers to be released by upper layer
1776 1776 */
1777 1777 static boolean_t
1778 1778 igb_rx_drain(igb_t *igb)
1779 1779 {
1780 1780 boolean_t done;
1781 1781 int i;
1782 1782
1783 1783 /*
1784 1784 * Polling the rx free list to check if those rx buffers held by
1785 1785 * the upper layer are released.
1786 1786 *
1787 1787 * Check the counter rcb_free to see if all pending buffers are
1788 1788 * released. No lock protection is needed here.
1789 1789 *
1790 1790 * Return B_TRUE if all pending buffers have been released;
1791 1791 * Otherwise return B_FALSE;
1792 1792 */
1793 1793 for (i = 0; i < RX_DRAIN_TIME; i++) {
1794 1794 done = (igb->rcb_pending == 0);
1795 1795
1796 1796 if (done)
1797 1797 break;
1798 1798
1799 1799 msec_delay(1);
1800 1800 }
1801 1801
1802 1802 return (done);
1803 1803 }
1804 1804
1805 1805 /*
1806 1806 * igb_start - Start the driver/chipset
1807 1807 */
1808 1808 int
1809 1809 igb_start(igb_t *igb, boolean_t alloc_buffer)
1810 1810 {
1811 1811 int i;
1812 1812
1813 1813 ASSERT(mutex_owned(&igb->gen_lock));
1814 1814
1815 1815 if (alloc_buffer) {
1816 1816 if (igb_alloc_rx_data(igb) != IGB_SUCCESS) {
1817 1817 igb_error(igb,
1818 1818 "Failed to allocate software receive rings");
1819 1819 return (IGB_FAILURE);
1820 1820 }
1821 1821
1822 1822 /* Allocate buffers for all the rx/tx rings */
1823 1823 if (igb_alloc_dma(igb) != IGB_SUCCESS) {
1824 1824 igb_error(igb, "Failed to allocate DMA resource");
1825 1825 return (IGB_FAILURE);
1826 1826 }
1827 1827
1828 1828 igb->tx_ring_init = B_TRUE;
1829 1829 } else {
1830 1830 igb->tx_ring_init = B_FALSE;
1831 1831 }
1832 1832
1833 1833 for (i = 0; i < igb->num_rx_rings; i++)
1834 1834 mutex_enter(&igb->rx_rings[i].rx_lock);
1835 1835 for (i = 0; i < igb->num_tx_rings; i++)
1836 1836 mutex_enter(&igb->tx_rings[i].tx_lock);
1837 1837
1838 1838 /*
1839 1839 * Start the adapter
1840 1840 */
1841 1841 if ((igb->attach_progress & ATTACH_PROGRESS_INIT_ADAPTER) == 0) {
1842 1842 if (igb_init_adapter(igb) != IGB_SUCCESS) {
1843 1843 igb_fm_ereport(igb, DDI_FM_DEVICE_INVAL_STATE);
1844 1844 goto start_failure;
1845 1845 }
1846 1846 igb->attach_progress |= ATTACH_PROGRESS_INIT_ADAPTER;
1847 1847 }
1848 1848
1849 1849 /*
1850 1850 * Setup the rx/tx rings
1851 1851 */
1852 1852 igb_setup_rings(igb);
1853 1853
1854 1854 /*
1855 1855 * Enable adapter interrupts
1856 1856 * The interrupts must be enabled after the driver state is START
1857 1857 */
1858 1858 igb->capab->enable_intr(igb);
1859 1859
1860 1860 if (igb_check_acc_handle(igb->osdep.cfg_handle) != DDI_FM_OK)
1861 1861 goto start_failure;
1862 1862
1863 1863 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK)
1864 1864 goto start_failure;
1865 1865
1866 1866 if (igb->hw.mac.type == e1000_i350)
1867 1867 (void) e1000_set_eee_i350(&igb->hw);
1868 1868 else if (igb->hw.mac.type == e1000_i354)
1869 1869 (void) e1000_set_eee_i354(&igb->hw);
1870 1870
1871 1871 for (i = igb->num_tx_rings - 1; i >= 0; i--)
1872 1872 mutex_exit(&igb->tx_rings[i].tx_lock);
1873 1873 for (i = igb->num_rx_rings - 1; i >= 0; i--)
1874 1874 mutex_exit(&igb->rx_rings[i].rx_lock);
1875 1875
1876 1876 return (IGB_SUCCESS);
1877 1877
1878 1878 start_failure:
1879 1879 for (i = igb->num_tx_rings - 1; i >= 0; i--)
1880 1880 mutex_exit(&igb->tx_rings[i].tx_lock);
1881 1881 for (i = igb->num_rx_rings - 1; i >= 0; i--)
1882 1882 mutex_exit(&igb->rx_rings[i].rx_lock);
1883 1883
1884 1884 ddi_fm_service_impact(igb->dip, DDI_SERVICE_LOST);
1885 1885
1886 1886 return (IGB_FAILURE);
1887 1887 }
1888 1888
1889 1889 /*
1890 1890 * igb_stop - Stop the driver/chipset
1891 1891 */
1892 1892 void
1893 1893 igb_stop(igb_t *igb, boolean_t free_buffer)
1894 1894 {
1895 1895 int i;
1896 1896
1897 1897 ASSERT(mutex_owned(&igb->gen_lock));
1898 1898
1899 1899 igb->attach_progress &= ~ATTACH_PROGRESS_INIT_ADAPTER;
1900 1900
1901 1901 /*
1902 1902 * Disable the adapter interrupts
1903 1903 */
1904 1904 igb_disable_adapter_interrupts(igb);
1905 1905
1906 1906 /*
1907 1907 * Drain the pending tx packets
1908 1908 */
1909 1909 (void) igb_tx_drain(igb);
1910 1910
1911 1911 for (i = 0; i < igb->num_rx_rings; i++)
1912 1912 mutex_enter(&igb->rx_rings[i].rx_lock);
1913 1913 for (i = 0; i < igb->num_tx_rings; i++)
1914 1914 mutex_enter(&igb->tx_rings[i].tx_lock);
1915 1915
1916 1916 /*
1917 1917 * Stop the adapter
1918 1918 */
1919 1919 igb_stop_adapter(igb);
1920 1920
1921 1921 /*
1922 1922 * Clean the pending tx data/resources
1923 1923 */
1924 1924 igb_tx_clean(igb);
1925 1925
1926 1926 for (i = igb->num_tx_rings - 1; i >= 0; i--)
1927 1927 mutex_exit(&igb->tx_rings[i].tx_lock);
1928 1928 for (i = igb->num_rx_rings - 1; i >= 0; i--)
1929 1929 mutex_exit(&igb->rx_rings[i].rx_lock);
1930 1930
1931 1931 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK)
1932 1932 ddi_fm_service_impact(igb->dip, DDI_SERVICE_LOST);
1933 1933
1934 1934 if (igb->link_state == LINK_STATE_UP) {
1935 1935 igb->link_state = LINK_STATE_UNKNOWN;
1936 1936 mac_link_update(igb->mac_hdl, igb->link_state);
1937 1937 }
1938 1938
1939 1939 if (free_buffer) {
1940 1940 /*
1941 1941 * Release the DMA/memory resources of rx/tx rings
1942 1942 */
1943 1943 igb_free_dma(igb);
1944 1944 igb_free_rx_data(igb);
1945 1945 }
1946 1946 }
1947 1947
1948 1948 /*
1949 1949 * igb_alloc_rings - Allocate memory space for rx/tx rings
1950 1950 */
1951 1951 static int
1952 1952 igb_alloc_rings(igb_t *igb)
1953 1953 {
1954 1954 /*
1955 1955 * Allocate memory space for rx rings
1956 1956 */
1957 1957 igb->rx_rings = kmem_zalloc(
1958 1958 sizeof (igb_rx_ring_t) * igb->num_rx_rings,
1959 1959 KM_NOSLEEP);
1960 1960
1961 1961 if (igb->rx_rings == NULL) {
1962 1962 return (IGB_FAILURE);
1963 1963 }
1964 1964
1965 1965 /*
1966 1966 * Allocate memory space for tx rings
1967 1967 */
1968 1968 igb->tx_rings = kmem_zalloc(
1969 1969 sizeof (igb_tx_ring_t) * igb->num_tx_rings,
1970 1970 KM_NOSLEEP);
1971 1971
1972 1972 if (igb->tx_rings == NULL) {
1973 1973 kmem_free(igb->rx_rings,
1974 1974 sizeof (igb_rx_ring_t) * igb->num_rx_rings);
1975 1975 igb->rx_rings = NULL;
1976 1976 return (IGB_FAILURE);
1977 1977 }
1978 1978
1979 1979 /*
1980 1980 * Allocate memory space for rx ring groups
1981 1981 */
1982 1982 igb->rx_groups = kmem_zalloc(
1983 1983 sizeof (igb_rx_group_t) * igb->num_rx_groups,
1984 1984 KM_NOSLEEP);
1985 1985
1986 1986 if (igb->rx_groups == NULL) {
1987 1987 kmem_free(igb->rx_rings,
1988 1988 sizeof (igb_rx_ring_t) * igb->num_rx_rings);
1989 1989 kmem_free(igb->tx_rings,
1990 1990 sizeof (igb_tx_ring_t) * igb->num_tx_rings);
1991 1991 igb->rx_rings = NULL;
1992 1992 igb->tx_rings = NULL;
1993 1993 return (IGB_FAILURE);
1994 1994 }
1995 1995
1996 1996 return (IGB_SUCCESS);
1997 1997 }
1998 1998
1999 1999 /*
2000 2000 * igb_free_rings - Free the memory space of rx/tx rings.
2001 2001 */
2002 2002 static void
2003 2003 igb_free_rings(igb_t *igb)
2004 2004 {
2005 2005 if (igb->rx_rings != NULL) {
2006 2006 kmem_free(igb->rx_rings,
2007 2007 sizeof (igb_rx_ring_t) * igb->num_rx_rings);
2008 2008 igb->rx_rings = NULL;
2009 2009 }
2010 2010
2011 2011 if (igb->tx_rings != NULL) {
2012 2012 kmem_free(igb->tx_rings,
2013 2013 sizeof (igb_tx_ring_t) * igb->num_tx_rings);
2014 2014 igb->tx_rings = NULL;
2015 2015 }
2016 2016
2017 2017 if (igb->rx_groups != NULL) {
2018 2018 kmem_free(igb->rx_groups,
2019 2019 sizeof (igb_rx_group_t) * igb->num_rx_groups);
2020 2020 igb->rx_groups = NULL;
2021 2021 }
2022 2022 }
2023 2023
2024 2024 static int
2025 2025 igb_alloc_rx_data(igb_t *igb)
2026 2026 {
2027 2027 igb_rx_ring_t *rx_ring;
2028 2028 int i;
2029 2029
2030 2030 for (i = 0; i < igb->num_rx_rings; i++) {
2031 2031 rx_ring = &igb->rx_rings[i];
2032 2032 if (igb_alloc_rx_ring_data(rx_ring) != IGB_SUCCESS)
2033 2033 goto alloc_rx_rings_failure;
2034 2034 }
2035 2035 return (IGB_SUCCESS);
2036 2036
2037 2037 alloc_rx_rings_failure:
2038 2038 igb_free_rx_data(igb);
2039 2039 return (IGB_FAILURE);
2040 2040 }
2041 2041
2042 2042 static void
2043 2043 igb_free_rx_data(igb_t *igb)
2044 2044 {
2045 2045 igb_rx_ring_t *rx_ring;
2046 2046 igb_rx_data_t *rx_data;
2047 2047 int i;
2048 2048
2049 2049 for (i = 0; i < igb->num_rx_rings; i++) {
2050 2050 rx_ring = &igb->rx_rings[i];
2051 2051
2052 2052 mutex_enter(&igb->rx_pending_lock);
2053 2053 rx_data = rx_ring->rx_data;
2054 2054
2055 2055 if (rx_data != NULL) {
2056 2056 rx_data->flag |= IGB_RX_STOPPED;
2057 2057
2058 2058 if (rx_data->rcb_pending == 0) {
2059 2059 igb_free_rx_ring_data(rx_data);
2060 2060 rx_ring->rx_data = NULL;
2061 2061 }
2062 2062 }
2063 2063
2064 2064 mutex_exit(&igb->rx_pending_lock);
2065 2065 }
2066 2066 }
2067 2067
2068 2068 /*
2069 2069 * igb_setup_rings - Setup rx/tx rings
2070 2070 */
2071 2071 static void
2072 2072 igb_setup_rings(igb_t *igb)
2073 2073 {
2074 2074 /*
2075 2075 * Setup the rx/tx rings, including the following:
2076 2076 *
2077 2077 * 1. Setup the descriptor ring and the control block buffers;
2078 2078 * 2. Initialize necessary registers for receive/transmit;
2079 2079 * 3. Initialize software pointers/parameters for receive/transmit;
2080 2080 */
2081 2081 igb_setup_rx(igb);
2082 2082
2083 2083 igb_setup_tx(igb);
2084 2084 }
2085 2085
2086 2086 static void
2087 2087 igb_setup_rx_ring(igb_rx_ring_t *rx_ring)
2088 2088 {
2089 2089 igb_t *igb = rx_ring->igb;
2090 2090 igb_rx_data_t *rx_data = rx_ring->rx_data;
2091 2091 struct e1000_hw *hw = &igb->hw;
2092 2092 rx_control_block_t *rcb;
2093 2093 union e1000_adv_rx_desc *rbd;
2094 2094 uint32_t size;
2095 2095 uint32_t buf_low;
2096 2096 uint32_t buf_high;
2097 2097 uint32_t rxdctl;
2098 2098 int i;
2099 2099
2100 2100 ASSERT(mutex_owned(&rx_ring->rx_lock));
2101 2101 ASSERT(mutex_owned(&igb->gen_lock));
2102 2102
2103 2103 /*
2104 2104 * Initialize descriptor ring with buffer addresses
2105 2105 */
2106 2106 for (i = 0; i < igb->rx_ring_size; i++) {
2107 2107 rcb = rx_data->work_list[i];
2108 2108 rbd = &rx_data->rbd_ring[i];
2109 2109
2110 2110 rbd->read.pkt_addr = rcb->rx_buf.dma_address;
2111 2111 rbd->read.hdr_addr = NULL;
2112 2112 }
2113 2113
2114 2114 /*
2115 2115 * Initialize the base address registers
2116 2116 */
2117 2117 buf_low = (uint32_t)rx_data->rbd_area.dma_address;
2118 2118 buf_high = (uint32_t)(rx_data->rbd_area.dma_address >> 32);
2119 2119 E1000_WRITE_REG(hw, E1000_RDBAH(rx_ring->index), buf_high);
2120 2120 E1000_WRITE_REG(hw, E1000_RDBAL(rx_ring->index), buf_low);
2121 2121
2122 2122 /*
2123 2123 * Initialize the length register
2124 2124 */
2125 2125 size = rx_data->ring_size * sizeof (union e1000_adv_rx_desc);
2126 2126 E1000_WRITE_REG(hw, E1000_RDLEN(rx_ring->index), size);
2127 2127
2128 2128 /*
2129 2129 * Initialize buffer size & descriptor type
2130 2130 */
2131 2131 E1000_WRITE_REG(hw, E1000_SRRCTL(rx_ring->index),
2132 2132 ((igb->rx_buf_size >> E1000_SRRCTL_BSIZEPKT_SHIFT) |
2133 2133 E1000_SRRCTL_DESCTYPE_ADV_ONEBUF));
2134 2134
2135 2135 /*
2136 2136 * Setup the Receive Descriptor Control Register (RXDCTL)
2137 2137 */
2138 2138 rxdctl = E1000_READ_REG(hw, E1000_RXDCTL(rx_ring->index));
2139 2139 rxdctl &= igb->capab->rxdctl_mask;
2140 2140 rxdctl |= E1000_RXDCTL_QUEUE_ENABLE;
2141 2141 rxdctl |= 16; /* pthresh */
2142 2142 rxdctl |= 8 << 8; /* hthresh */
2143 2143 rxdctl |= 1 << 16; /* wthresh */
2144 2144 E1000_WRITE_REG(hw, E1000_RXDCTL(rx_ring->index), rxdctl);
2145 2145
2146 2146 rx_data->rbd_next = 0;
2147 2147 }
2148 2148
2149 2149 static void
2150 2150 igb_setup_rx(igb_t *igb)
2151 2151 {
2152 2152 igb_rx_ring_t *rx_ring;
2153 2153 igb_rx_data_t *rx_data;
2154 2154 igb_rx_group_t *rx_group;
2155 2155 struct e1000_hw *hw = &igb->hw;
2156 2156 uint32_t rctl, rxcsum;
2157 2157 uint32_t ring_per_group;
2158 2158 int i;
2159 2159
2160 2160 /*
2161 2161 * Setup the Receive Control Register (RCTL), and enable the
2162 2162 * receiver. The initial configuration is to: enable the receiver,
2163 2163 * accept broadcasts, discard bad packets, accept long packets,
2164 2164 * disable VLAN filter checking, and set receive buffer size to
2165 2165 * 2k. For 82575, also set the receive descriptor minimum
2166 2166 * threshold size to 1/2 the ring.
2167 2167 */
2168 2168 rctl = E1000_READ_REG(hw, E1000_RCTL);
2169 2169
2170 2170 /*
2171 2171 * Clear the field used for wakeup control. This driver doesn't do
2172 2172 * wakeup but leave this here for completeness.
2173 2173 */
2174 2174 rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
2175 2175 rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
2176 2176
2177 2177 rctl |= (E1000_RCTL_EN | /* Enable Receive Unit */
2178 2178 E1000_RCTL_BAM | /* Accept Broadcast Packets */
2179 2179 E1000_RCTL_LPE | /* Large Packet Enable */
2180 2180 /* Multicast filter offset */
2181 2181 (hw->mac.mc_filter_type << E1000_RCTL_MO_SHIFT) |
2182 2182 E1000_RCTL_RDMTS_HALF | /* rx descriptor threshold */
2183 2183 E1000_RCTL_SECRC); /* Strip Ethernet CRC */
2184 2184
2185 2185 for (i = 0; i < igb->num_rx_groups; i++) {
2186 2186 rx_group = &igb->rx_groups[i];
2187 2187 rx_group->index = i;
2188 2188 rx_group->igb = igb;
2189 2189 }
2190 2190
2191 2191 /*
2192 2192 * Set up all rx descriptor rings - must be called before receive unit
2193 2193 * enabled.
2194 2194 */
2195 2195 ring_per_group = igb->num_rx_rings / igb->num_rx_groups;
2196 2196 for (i = 0; i < igb->num_rx_rings; i++) {
2197 2197 rx_ring = &igb->rx_rings[i];
2198 2198 igb_setup_rx_ring(rx_ring);
2199 2199
2200 2200 /*
2201 2201 * Map a ring to a group by assigning a group index
2202 2202 */
2203 2203 rx_ring->group_index = i / ring_per_group;
2204 2204 }
2205 2205
2206 2206 /*
2207 2207 * Setup the Rx Long Packet Max Length register
2208 2208 */
2209 2209 E1000_WRITE_REG(hw, E1000_RLPML, igb->max_frame_size);
2210 2210
2211 2211 /*
2212 2212 * Hardware checksum settings
2213 2213 */
2214 2214 if (igb->rx_hcksum_enable) {
2215 2215 rxcsum =
2216 2216 E1000_RXCSUM_TUOFL | /* TCP/UDP checksum */
2217 2217 E1000_RXCSUM_IPOFL; /* IP checksum */
2218 2218
2219 2219 E1000_WRITE_REG(hw, E1000_RXCSUM, rxcsum);
2220 2220 }
2221 2221
2222 2222 /*
2223 2223 * Setup classify and RSS for multiple receive queues
2224 2224 */
2225 2225 switch (igb->vmdq_mode) {
2226 2226 case E1000_VMDQ_OFF:
2227 2227 /*
2228 2228 * One ring group, only RSS is needed when more than
2229 2229 * one ring enabled.
2230 2230 */
2231 2231 if (igb->num_rx_rings > 1)
2232 2232 igb_setup_rss(igb);
2233 2233 break;
2234 2234 case E1000_VMDQ_MAC:
2235 2235 /*
2236 2236 * Multiple groups, each group has one ring,
2237 2237 * only the MAC classification is needed.
2238 2238 */
2239 2239 igb_setup_mac_classify(igb);
2240 2240 break;
2241 2241 case E1000_VMDQ_MAC_RSS:
2242 2242 /*
2243 2243 * Multiple groups and multiple rings, both
2244 2244 * MAC classification and RSS are needed.
2245 2245 */
2246 2246 igb_setup_mac_rss_classify(igb);
2247 2247 break;
2248 2248 }
2249 2249
2250 2250 /*
2251 2251 * Enable the receive unit - must be done after all
2252 2252 * the rx setup above.
2253 2253 */
2254 2254 E1000_WRITE_REG(hw, E1000_RCTL, rctl);
2255 2255
2256 2256 /*
2257 2257 * Initialize all adapter ring head & tail pointers - must
2258 2258 * be done after receive unit is enabled
2259 2259 */
2260 2260 for (i = 0; i < igb->num_rx_rings; i++) {
2261 2261 rx_ring = &igb->rx_rings[i];
2262 2262 rx_data = rx_ring->rx_data;
2263 2263 E1000_WRITE_REG(hw, E1000_RDH(i), 0);
2264 2264 E1000_WRITE_REG(hw, E1000_RDT(i), rx_data->ring_size - 1);
2265 2265 }
2266 2266
2267 2267 /*
2268 2268 * 82575 with manageability enabled needs a special flush to make
2269 2269 * sure the fifos start clean.
2270 2270 */
2271 2271 if ((hw->mac.type == e1000_82575) &&
2272 2272 (E1000_READ_REG(hw, E1000_MANC) & E1000_MANC_RCV_TCO_EN)) {
2273 2273 e1000_rx_fifo_flush_82575(hw);
2274 2274 }
2275 2275 }
2276 2276
2277 2277 static void
2278 2278 igb_setup_tx_ring(igb_tx_ring_t *tx_ring)
2279 2279 {
2280 2280 igb_t *igb = tx_ring->igb;
2281 2281 struct e1000_hw *hw = &igb->hw;
2282 2282 uint32_t size;
2283 2283 uint32_t buf_low;
2284 2284 uint32_t buf_high;
2285 2285 uint32_t reg_val;
2286 2286
2287 2287 ASSERT(mutex_owned(&tx_ring->tx_lock));
2288 2288 ASSERT(mutex_owned(&igb->gen_lock));
2289 2289
2290 2290
2291 2291 /*
2292 2292 * Initialize the length register
2293 2293 */
2294 2294 size = tx_ring->ring_size * sizeof (union e1000_adv_tx_desc);
2295 2295 E1000_WRITE_REG(hw, E1000_TDLEN(tx_ring->index), size);
2296 2296
2297 2297 /*
2298 2298 * Initialize the base address registers
2299 2299 */
2300 2300 buf_low = (uint32_t)tx_ring->tbd_area.dma_address;
2301 2301 buf_high = (uint32_t)(tx_ring->tbd_area.dma_address >> 32);
2302 2302 E1000_WRITE_REG(hw, E1000_TDBAL(tx_ring->index), buf_low);
2303 2303 E1000_WRITE_REG(hw, E1000_TDBAH(tx_ring->index), buf_high);
2304 2304
2305 2305 /*
2306 2306 * Setup head & tail pointers
2307 2307 */
2308 2308 E1000_WRITE_REG(hw, E1000_TDH(tx_ring->index), 0);
2309 2309 E1000_WRITE_REG(hw, E1000_TDT(tx_ring->index), 0);
2310 2310
2311 2311 /*
2312 2312 * Setup head write-back
2313 2313 */
2314 2314 if (igb->tx_head_wb_enable) {
2315 2315 /*
2316 2316 * The memory of the head write-back is allocated using
2317 2317 * the extra tbd beyond the tail of the tbd ring.
2318 2318 */
2319 2319 tx_ring->tbd_head_wb = (uint32_t *)
2320 2320 ((uintptr_t)tx_ring->tbd_area.address + size);
2321 2321 *tx_ring->tbd_head_wb = 0;
2322 2322
2323 2323 buf_low = (uint32_t)
2324 2324 (tx_ring->tbd_area.dma_address + size);
2325 2325 buf_high = (uint32_t)
2326 2326 ((tx_ring->tbd_area.dma_address + size) >> 32);
2327 2327
2328 2328 /* Set the head write-back enable bit */
2329 2329 buf_low |= E1000_TX_HEAD_WB_ENABLE;
2330 2330
2331 2331 E1000_WRITE_REG(hw, E1000_TDWBAL(tx_ring->index), buf_low);
2332 2332 E1000_WRITE_REG(hw, E1000_TDWBAH(tx_ring->index), buf_high);
2333 2333
2334 2334 /*
2335 2335 * Turn off relaxed ordering for head write back or it will
2336 2336 * cause problems with the tx recycling
2337 2337 */
2338 2338 reg_val = E1000_READ_REG(hw,
2339 2339 E1000_DCA_TXCTRL(tx_ring->index));
2340 2340 reg_val &= ~E1000_DCA_TXCTRL_TX_WB_RO_EN;
2341 2341 E1000_WRITE_REG(hw,
2342 2342 E1000_DCA_TXCTRL(tx_ring->index), reg_val);
2343 2343 } else {
2344 2344 tx_ring->tbd_head_wb = NULL;
2345 2345 }
2346 2346
2347 2347 tx_ring->tbd_head = 0;
2348 2348 tx_ring->tbd_tail = 0;
2349 2349 tx_ring->tbd_free = tx_ring->ring_size;
2350 2350
2351 2351 if (igb->tx_ring_init == B_TRUE) {
2352 2352 tx_ring->tcb_head = 0;
2353 2353 tx_ring->tcb_tail = 0;
2354 2354 tx_ring->tcb_free = tx_ring->free_list_size;
2355 2355 }
2356 2356
2357 2357 /*
2358 2358 * Enable TXDCTL per queue
2359 2359 */
2360 2360 reg_val = E1000_READ_REG(hw, E1000_TXDCTL(tx_ring->index));
2361 2361 reg_val |= E1000_TXDCTL_QUEUE_ENABLE;
2362 2362 E1000_WRITE_REG(hw, E1000_TXDCTL(tx_ring->index), reg_val);
2363 2363
2364 2364 /*
2365 2365 * Initialize hardware checksum offload settings
2366 2366 */
2367 2367 bzero(&tx_ring->tx_context, sizeof (tx_context_t));
2368 2368 }
2369 2369
2370 2370 static void
2371 2371 igb_setup_tx(igb_t *igb)
2372 2372 {
2373 2373 igb_tx_ring_t *tx_ring;
2374 2374 struct e1000_hw *hw = &igb->hw;
2375 2375 uint32_t reg_val;
2376 2376 int i;
2377 2377
2378 2378 for (i = 0; i < igb->num_tx_rings; i++) {
2379 2379 tx_ring = &igb->tx_rings[i];
2380 2380 igb_setup_tx_ring(tx_ring);
2381 2381 }
2382 2382
2383 2383 /*
2384 2384 * Setup the Transmit Control Register (TCTL)
2385 2385 */
2386 2386 reg_val = E1000_READ_REG(hw, E1000_TCTL);
2387 2387 reg_val &= ~E1000_TCTL_CT;
2388 2388 reg_val |= E1000_TCTL_PSP | E1000_TCTL_RTLC |
2389 2389 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
2390 2390
2391 2391 /* Enable transmits */
2392 2392 reg_val |= E1000_TCTL_EN;
2393 2393
2394 2394 E1000_WRITE_REG(hw, E1000_TCTL, reg_val);
2395 2395 }
2396 2396
2397 2397 /*
2398 2398 * igb_setup_rss - Setup receive-side scaling feature
2399 2399 */
2400 2400 static void
2401 2401 igb_setup_rss(igb_t *igb)
2402 2402 {
2403 2403 struct e1000_hw *hw = &igb->hw;
2404 2404 uint32_t i, mrqc, rxcsum;
2405 2405 int shift = 0;
2406 2406 uint32_t random;
2407 2407 union e1000_reta {
2408 2408 uint32_t dword;
2409 2409 uint8_t bytes[4];
2410 2410 } reta;
2411 2411
2412 2412 /* Setup the Redirection Table */
2413 2413 if (hw->mac.type == e1000_82576) {
2414 2414 shift = 3;
2415 2415 } else if (hw->mac.type == e1000_82575) {
2416 2416 shift = 6;
2417 2417 }
2418 2418 for (i = 0; i < (32 * 4); i++) {
2419 2419 reta.bytes[i & 3] = (i % igb->num_rx_rings) << shift;
2420 2420 if ((i & 3) == 3) {
2421 2421 E1000_WRITE_REG(hw,
2422 2422 (E1000_RETA(0) + (i & ~3)), reta.dword);
2423 2423 }
2424 2424 }
2425 2425
2426 2426 /* Fill out hash function seeds */
2427 2427 for (i = 0; i < 10; i++) {
2428 2428 (void) random_get_pseudo_bytes((uint8_t *)&random,
2429 2429 sizeof (uint32_t));
2430 2430 E1000_WRITE_REG(hw, E1000_RSSRK(i), random);
2431 2431 }
2432 2432
2433 2433 /* Setup the Multiple Receive Queue Control register */
2434 2434 mrqc = E1000_MRQC_ENABLE_RSS_4Q;
2435 2435 mrqc |= (E1000_MRQC_RSS_FIELD_IPV4 |
2436 2436 E1000_MRQC_RSS_FIELD_IPV4_TCP |
2437 2437 E1000_MRQC_RSS_FIELD_IPV6 |
2438 2438 E1000_MRQC_RSS_FIELD_IPV6_TCP |
2439 2439 E1000_MRQC_RSS_FIELD_IPV4_UDP |
2440 2440 E1000_MRQC_RSS_FIELD_IPV6_UDP |
2441 2441 E1000_MRQC_RSS_FIELD_IPV6_UDP_EX |
2442 2442 E1000_MRQC_RSS_FIELD_IPV6_TCP_EX);
2443 2443
2444 2444 E1000_WRITE_REG(hw, E1000_MRQC, mrqc);
2445 2445
2446 2446 /*
2447 2447 * Disable Packet Checksum to enable RSS for multiple receive queues.
2448 2448 *
2449 2449 * The Packet Checksum is not ethernet CRC. It is another kind of
2450 2450 * checksum offloading provided by the 82575 chipset besides the IP
2451 2451 * header checksum offloading and the TCP/UDP checksum offloading.
2452 2452 * The Packet Checksum is by default computed over the entire packet
2453 2453 * from the first byte of the DA through the last byte of the CRC,
2454 2454 * including the Ethernet and IP headers.
2455 2455 *
2456 2456 * It is a hardware limitation that Packet Checksum is mutually
2457 2457 * exclusive with RSS.
2458 2458 */
2459 2459 rxcsum = E1000_READ_REG(hw, E1000_RXCSUM);
2460 2460 rxcsum |= E1000_RXCSUM_PCSD;
2461 2461 E1000_WRITE_REG(hw, E1000_RXCSUM, rxcsum);
2462 2462 }
2463 2463
2464 2464 /*
2465 2465 * igb_setup_mac_rss_classify - Setup MAC classification and rss
2466 2466 */
2467 2467 static void
2468 2468 igb_setup_mac_rss_classify(igb_t *igb)
2469 2469 {
2470 2470 struct e1000_hw *hw = &igb->hw;
2471 2471 uint32_t i, mrqc, vmdctl, rxcsum;
2472 2472 uint32_t ring_per_group;
2473 2473 int shift_group0, shift_group1;
2474 2474 uint32_t random;
2475 2475 union e1000_reta {
2476 2476 uint32_t dword;
2477 2477 uint8_t bytes[4];
2478 2478 } reta;
2479 2479
2480 2480 ring_per_group = igb->num_rx_rings / igb->num_rx_groups;
2481 2481
2482 2482 /* Setup the Redirection Table, it is shared between two groups */
2483 2483 shift_group0 = 2;
2484 2484 shift_group1 = 6;
2485 2485 for (i = 0; i < (32 * 4); i++) {
2486 2486 reta.bytes[i & 3] = ((i % ring_per_group) << shift_group0) |
2487 2487 ((ring_per_group + (i % ring_per_group)) << shift_group1);
2488 2488 if ((i & 3) == 3) {
2489 2489 E1000_WRITE_REG(hw,
2490 2490 (E1000_RETA(0) + (i & ~3)), reta.dword);
2491 2491 }
2492 2492 }
2493 2493
2494 2494 /* Fill out hash function seeds */
2495 2495 for (i = 0; i < 10; i++) {
2496 2496 (void) random_get_pseudo_bytes((uint8_t *)&random,
2497 2497 sizeof (uint32_t));
2498 2498 E1000_WRITE_REG(hw, E1000_RSSRK(i), random);
2499 2499 }
2500 2500
2501 2501 /*
2502 2502 * Setup the Multiple Receive Queue Control register,
2503 2503 * enable VMDq based on packet destination MAC address and RSS.
2504 2504 */
2505 2505 mrqc = E1000_MRQC_ENABLE_VMDQ_MAC_RSS_GROUP;
2506 2506 mrqc |= (E1000_MRQC_RSS_FIELD_IPV4 |
2507 2507 E1000_MRQC_RSS_FIELD_IPV4_TCP |
2508 2508 E1000_MRQC_RSS_FIELD_IPV6 |
2509 2509 E1000_MRQC_RSS_FIELD_IPV6_TCP |
2510 2510 E1000_MRQC_RSS_FIELD_IPV4_UDP |
2511 2511 E1000_MRQC_RSS_FIELD_IPV6_UDP |
2512 2512 E1000_MRQC_RSS_FIELD_IPV6_UDP_EX |
2513 2513 E1000_MRQC_RSS_FIELD_IPV6_TCP_EX);
2514 2514
2515 2515 E1000_WRITE_REG(hw, E1000_MRQC, mrqc);
2516 2516
2517 2517
2518 2518 /* Define the default group and default queues */
2519 2519 vmdctl = E1000_VMDQ_MAC_GROUP_DEFAULT_QUEUE;
2520 2520 E1000_WRITE_REG(hw, E1000_VT_CTL, vmdctl);
2521 2521
2522 2522 /*
2523 2523 * Disable Packet Checksum to enable RSS for multiple receive queues.
2524 2524 *
2525 2525 * The Packet Checksum is not ethernet CRC. It is another kind of
2526 2526 * checksum offloading provided by the 82575 chipset besides the IP
2527 2527 * header checksum offloading and the TCP/UDP checksum offloading.
2528 2528 * The Packet Checksum is by default computed over the entire packet
2529 2529 * from the first byte of the DA through the last byte of the CRC,
2530 2530 * including the Ethernet and IP headers.
2531 2531 *
2532 2532 * It is a hardware limitation that Packet Checksum is mutually
2533 2533 * exclusive with RSS.
2534 2534 */
2535 2535 rxcsum = E1000_READ_REG(hw, E1000_RXCSUM);
2536 2536 rxcsum |= E1000_RXCSUM_PCSD;
2537 2537 E1000_WRITE_REG(hw, E1000_RXCSUM, rxcsum);
2538 2538 }
2539 2539
2540 2540 /*
2541 2541 * igb_setup_mac_classify - Setup MAC classification feature
2542 2542 */
2543 2543 static void
2544 2544 igb_setup_mac_classify(igb_t *igb)
2545 2545 {
2546 2546 struct e1000_hw *hw = &igb->hw;
2547 2547 uint32_t mrqc, rxcsum;
2548 2548
2549 2549 /*
2550 2550 * Setup the Multiple Receive Queue Control register,
2551 2551 * enable VMDq based on packet destination MAC address.
2552 2552 */
2553 2553 mrqc = E1000_MRQC_ENABLE_VMDQ_MAC_GROUP;
2554 2554 E1000_WRITE_REG(hw, E1000_MRQC, mrqc);
2555 2555
2556 2556 /*
2557 2557 * Disable Packet Checksum to enable RSS for multiple receive queues.
2558 2558 *
2559 2559 * The Packet Checksum is not ethernet CRC. It is another kind of
2560 2560 * checksum offloading provided by the 82575 chipset besides the IP
2561 2561 * header checksum offloading and the TCP/UDP checksum offloading.
2562 2562 * The Packet Checksum is by default computed over the entire packet
2563 2563 * from the first byte of the DA through the last byte of the CRC,
2564 2564 * including the Ethernet and IP headers.
2565 2565 *
2566 2566 * It is a hardware limitation that Packet Checksum is mutually
2567 2567 * exclusive with RSS.
2568 2568 */
2569 2569 rxcsum = E1000_READ_REG(hw, E1000_RXCSUM);
2570 2570 rxcsum |= E1000_RXCSUM_PCSD;
2571 2571 E1000_WRITE_REG(hw, E1000_RXCSUM, rxcsum);
2572 2572
2573 2573 }
2574 2574
2575 2575 /*
2576 2576 * igb_init_unicst - Initialize the unicast addresses
2577 2577 */
2578 2578 static void
2579 2579 igb_init_unicst(igb_t *igb)
2580 2580 {
2581 2581 struct e1000_hw *hw = &igb->hw;
2582 2582 int slot;
2583 2583
2584 2584 /*
2585 2585 * Here we should consider two situations:
2586 2586 *
2587 2587 * 1. Chipset is initialized the first time
2588 2588 * Initialize the multiple unicast addresses, and
2589 2589 * save the default MAC address.
2590 2590 *
2591 2591 * 2. Chipset is reset
2592 2592 * Recover the multiple unicast addresses from the
2593 2593 * software data structure to the RAR registers.
2594 2594 */
2595 2595
2596 2596 /*
2597 2597 * Clear the default MAC address in the RAR0 rgister,
2598 2598 * which is loaded from EEPROM when system boot or chipreset,
2599 2599 * this will cause the conficts with add_mac/rem_mac entry
2600 2600 * points when VMDq is enabled. For this reason, the RAR0
2601 2601 * must be cleared for both cases mentioned above.
2602 2602 */
2603 2603 e1000_rar_clear(hw, 0);
2604 2604
2605 2605 if (!igb->unicst_init) {
2606 2606
2607 2607 /* Initialize the multiple unicast addresses */
2608 2608 igb->unicst_total = MAX_NUM_UNICAST_ADDRESSES;
2609 2609 igb->unicst_avail = igb->unicst_total;
2610 2610
2611 2611 for (slot = 0; slot < igb->unicst_total; slot++)
2612 2612 igb->unicst_addr[slot].mac.set = 0;
2613 2613
2614 2614 igb->unicst_init = B_TRUE;
2615 2615 } else {
2616 2616 /* Re-configure the RAR registers */
2617 2617 for (slot = 0; slot < igb->unicst_total; slot++) {
2618 2618 (void) e1000_rar_set_vmdq(hw,
2619 2619 igb->unicst_addr[slot].mac.addr,
2620 2620 slot, igb->vmdq_mode,
2621 2621 igb->unicst_addr[slot].mac.group_index);
2622 2622 }
2623 2623 }
2624 2624 }
2625 2625
2626 2626 /*
2627 2627 * igb_unicst_find - Find the slot for the specified unicast address
2628 2628 */
2629 2629 int
2630 2630 igb_unicst_find(igb_t *igb, const uint8_t *mac_addr)
2631 2631 {
2632 2632 int slot;
2633 2633
2634 2634 ASSERT(mutex_owned(&igb->gen_lock));
2635 2635
2636 2636 for (slot = 0; slot < igb->unicst_total; slot++) {
2637 2637 if (bcmp(igb->unicst_addr[slot].mac.addr,
2638 2638 mac_addr, ETHERADDRL) == 0)
2639 2639 return (slot);
2640 2640 }
2641 2641
2642 2642 return (-1);
2643 2643 }
2644 2644
2645 2645 /*
2646 2646 * igb_unicst_set - Set the unicast address to the specified slot
2647 2647 */
2648 2648 int
2649 2649 igb_unicst_set(igb_t *igb, const uint8_t *mac_addr,
2650 2650 int slot)
2651 2651 {
2652 2652 struct e1000_hw *hw = &igb->hw;
2653 2653
2654 2654 ASSERT(mutex_owned(&igb->gen_lock));
2655 2655
2656 2656 /*
2657 2657 * Save the unicast address in the software data structure
2658 2658 */
2659 2659 bcopy(mac_addr, igb->unicst_addr[slot].mac.addr, ETHERADDRL);
2660 2660
2661 2661 /*
2662 2662 * Set the unicast address to the RAR register
2663 2663 */
2664 2664 (void) e1000_rar_set(hw, (uint8_t *)mac_addr, slot);
2665 2665
2666 2666 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK) {
2667 2667 ddi_fm_service_impact(igb->dip, DDI_SERVICE_DEGRADED);
2668 2668 return (EIO);
2669 2669 }
2670 2670
2671 2671 return (0);
2672 2672 }
2673 2673
2674 2674 /*
2675 2675 * igb_multicst_add - Add a multicst address
2676 2676 */
2677 2677 int
2678 2678 igb_multicst_add(igb_t *igb, const uint8_t *multiaddr)
2679 2679 {
2680 2680 struct ether_addr *new_table;
2681 2681 size_t new_len;
2682 2682 size_t old_len;
2683 2683
2684 2684 ASSERT(mutex_owned(&igb->gen_lock));
2685 2685
2686 2686 if ((multiaddr[0] & 01) == 0) {
2687 2687 igb_error(igb, "Illegal multicast address");
2688 2688 return (EINVAL);
2689 2689 }
2690 2690
2691 2691 if (igb->mcast_count >= igb->mcast_max_num) {
2692 2692 igb_error(igb, "Adapter requested more than %d mcast addresses",
2693 2693 igb->mcast_max_num);
2694 2694 return (ENOENT);
2695 2695 }
2696 2696
2697 2697 if (igb->mcast_count == igb->mcast_alloc_count) {
2698 2698 old_len = igb->mcast_alloc_count *
2699 2699 sizeof (struct ether_addr);
2700 2700 new_len = (igb->mcast_alloc_count + MCAST_ALLOC_COUNT) *
2701 2701 sizeof (struct ether_addr);
2702 2702
2703 2703 new_table = kmem_alloc(new_len, KM_NOSLEEP);
2704 2704 if (new_table == NULL) {
2705 2705 igb_error(igb,
2706 2706 "Not enough memory to alloc mcast table");
2707 2707 return (ENOMEM);
2708 2708 }
2709 2709
2710 2710 if (igb->mcast_table != NULL) {
2711 2711 bcopy(igb->mcast_table, new_table, old_len);
2712 2712 kmem_free(igb->mcast_table, old_len);
2713 2713 }
2714 2714 igb->mcast_alloc_count += MCAST_ALLOC_COUNT;
2715 2715 igb->mcast_table = new_table;
2716 2716 }
2717 2717
2718 2718 bcopy(multiaddr,
2719 2719 &igb->mcast_table[igb->mcast_count], ETHERADDRL);
2720 2720 igb->mcast_count++;
2721 2721
2722 2722 /*
2723 2723 * Update the multicast table in the hardware
2724 2724 */
2725 2725 igb_setup_multicst(igb);
2726 2726
2727 2727 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK) {
2728 2728 ddi_fm_service_impact(igb->dip, DDI_SERVICE_DEGRADED);
2729 2729 return (EIO);
2730 2730 }
2731 2731
2732 2732 return (0);
2733 2733 }
2734 2734
2735 2735 /*
2736 2736 * igb_multicst_remove - Remove a multicst address
2737 2737 */
2738 2738 int
2739 2739 igb_multicst_remove(igb_t *igb, const uint8_t *multiaddr)
2740 2740 {
2741 2741 struct ether_addr *new_table;
2742 2742 size_t new_len;
2743 2743 size_t old_len;
2744 2744 int i;
2745 2745
2746 2746 ASSERT(mutex_owned(&igb->gen_lock));
2747 2747
2748 2748 for (i = 0; i < igb->mcast_count; i++) {
2749 2749 if (bcmp(multiaddr, &igb->mcast_table[i],
2750 2750 ETHERADDRL) == 0) {
2751 2751 for (i++; i < igb->mcast_count; i++) {
2752 2752 igb->mcast_table[i - 1] =
2753 2753 igb->mcast_table[i];
2754 2754 }
2755 2755 igb->mcast_count--;
2756 2756 break;
2757 2757 }
2758 2758 }
2759 2759
2760 2760 if ((igb->mcast_alloc_count - igb->mcast_count) >
2761 2761 MCAST_ALLOC_COUNT) {
2762 2762 old_len = igb->mcast_alloc_count *
2763 2763 sizeof (struct ether_addr);
2764 2764 new_len = (igb->mcast_alloc_count - MCAST_ALLOC_COUNT) *
2765 2765 sizeof (struct ether_addr);
2766 2766
2767 2767 new_table = kmem_alloc(new_len, KM_NOSLEEP);
2768 2768 if (new_table != NULL) {
2769 2769 bcopy(igb->mcast_table, new_table, new_len);
2770 2770 kmem_free(igb->mcast_table, old_len);
2771 2771 igb->mcast_alloc_count -= MCAST_ALLOC_COUNT;
2772 2772 igb->mcast_table = new_table;
2773 2773 }
2774 2774 }
2775 2775
2776 2776 /*
2777 2777 * Update the multicast table in the hardware
2778 2778 */
2779 2779 igb_setup_multicst(igb);
2780 2780
2781 2781 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK) {
2782 2782 ddi_fm_service_impact(igb->dip, DDI_SERVICE_DEGRADED);
2783 2783 return (EIO);
2784 2784 }
2785 2785
2786 2786 return (0);
2787 2787 }
2788 2788
2789 2789 static void
2790 2790 igb_release_multicast(igb_t *igb)
2791 2791 {
2792 2792 if (igb->mcast_table != NULL) {
2793 2793 kmem_free(igb->mcast_table,
2794 2794 igb->mcast_alloc_count * sizeof (struct ether_addr));
2795 2795 igb->mcast_table = NULL;
2796 2796 }
2797 2797 }
2798 2798
2799 2799 /*
2800 2800 * igb_setup_multicast - setup multicast data structures
2801 2801 *
2802 2802 * This routine initializes all of the multicast related structures
2803 2803 * and save them in the hardware registers.
2804 2804 */
2805 2805 static void
2806 2806 igb_setup_multicst(igb_t *igb)
2807 2807 {
2808 2808 uint8_t *mc_addr_list;
2809 2809 uint32_t mc_addr_count;
2810 2810 struct e1000_hw *hw = &igb->hw;
2811 2811
2812 2812 ASSERT(mutex_owned(&igb->gen_lock));
2813 2813 ASSERT(igb->mcast_count <= igb->mcast_max_num);
2814 2814
2815 2815 mc_addr_list = (uint8_t *)igb->mcast_table;
2816 2816 mc_addr_count = igb->mcast_count;
2817 2817
2818 2818 /*
2819 2819 * Update the multicase addresses to the MTA registers
2820 2820 */
2821 2821 e1000_update_mc_addr_list(hw, mc_addr_list, mc_addr_count);
2822 2822 }
2823 2823
2824 2824 /*
2825 2825 * igb_get_conf - Get driver configurations set in driver.conf
2826 2826 *
2827 2827 * This routine gets user-configured values out of the configuration
2828 2828 * file igb.conf.
2829 2829 *
2830 2830 * For each configurable value, there is a minimum, a maximum, and a
2831 2831 * default.
2832 2832 * If user does not configure a value, use the default.
2833 2833 * If user configures below the minimum, use the minumum.
2834 2834 * If user configures above the maximum, use the maxumum.
2835 2835 */
2836 2836 static void
2837 2837 igb_get_conf(igb_t *igb)
2838 2838 {
2839 2839 struct e1000_hw *hw = &igb->hw;
2840 2840 uint32_t default_mtu;
2841 2841 uint32_t flow_control;
2842 2842 uint32_t ring_per_group;
2843 2843 int i;
2844 2844
2845 2845 /*
2846 2846 * igb driver supports the following user configurations:
2847 2847 *
2848 2848 * Link configurations:
2849 2849 * adv_autoneg_cap
2850 2850 * adv_1000fdx_cap
2851 2851 * adv_100fdx_cap
2852 2852 * adv_100hdx_cap
2853 2853 * adv_10fdx_cap
2854 2854 * adv_10hdx_cap
2855 2855 * Note: 1000hdx is not supported.
2856 2856 *
2857 2857 * Jumbo frame configuration:
2858 2858 * default_mtu
2859 2859 *
2860 2860 * Ethernet flow control configuration:
2861 2861 * flow_control
2862 2862 *
2863 2863 * Multiple rings configurations:
2864 2864 * tx_queue_number
2865 2865 * tx_ring_size
2866 2866 * rx_queue_number
2867 2867 * rx_ring_size
2868 2868 *
2869 2869 * Call igb_get_prop() to get the value for a specific
2870 2870 * configuration parameter.
2871 2871 */
2872 2872
2873 2873 /*
2874 2874 * Link configurations
2875 2875 */
2876 2876 igb->param_adv_autoneg_cap = igb_get_prop(igb,
2877 2877 PROP_ADV_AUTONEG_CAP, 0, 1, 1);
2878 2878 igb->param_adv_1000fdx_cap = igb_get_prop(igb,
2879 2879 PROP_ADV_1000FDX_CAP, 0, 1, 1);
2880 2880 igb->param_adv_100fdx_cap = igb_get_prop(igb,
2881 2881 PROP_ADV_100FDX_CAP, 0, 1, 1);
2882 2882 igb->param_adv_100hdx_cap = igb_get_prop(igb,
2883 2883 PROP_ADV_100HDX_CAP, 0, 1, 1);
2884 2884 igb->param_adv_10fdx_cap = igb_get_prop(igb,
2885 2885 PROP_ADV_10FDX_CAP, 0, 1, 1);
2886 2886 igb->param_adv_10hdx_cap = igb_get_prop(igb,
2887 2887 PROP_ADV_10HDX_CAP, 0, 1, 1);
2888 2888
2889 2889 /*
2890 2890 * Jumbo frame configurations
2891 2891 */
2892 2892 default_mtu = igb_get_prop(igb, PROP_DEFAULT_MTU,
2893 2893 MIN_MTU, MAX_MTU, DEFAULT_MTU);
2894 2894
2895 2895 igb->max_frame_size = default_mtu +
2896 2896 sizeof (struct ether_vlan_header) + ETHERFCSL;
2897 2897
2898 2898 /*
2899 2899 * Ethernet flow control configuration
2900 2900 */
2901 2901 flow_control = igb_get_prop(igb, PROP_FLOW_CONTROL,
2902 2902 e1000_fc_none, 4, e1000_fc_full);
2903 2903 if (flow_control == 4)
2904 2904 flow_control = e1000_fc_default;
2905 2905
2906 2906 hw->fc.requested_mode = flow_control;
2907 2907
2908 2908 /*
2909 2909 * Multiple rings configurations
2910 2910 */
2911 2911 igb->tx_ring_size = igb_get_prop(igb, PROP_TX_RING_SIZE,
2912 2912 MIN_TX_RING_SIZE, MAX_TX_RING_SIZE, DEFAULT_TX_RING_SIZE);
2913 2913 igb->rx_ring_size = igb_get_prop(igb, PROP_RX_RING_SIZE,
2914 2914 MIN_RX_RING_SIZE, MAX_RX_RING_SIZE, DEFAULT_RX_RING_SIZE);
2915 2915
2916 2916 igb->mr_enable = igb_get_prop(igb, PROP_MR_ENABLE, 0, 1, 0);
2917 2917 igb->num_rx_groups = igb_get_prop(igb, PROP_RX_GROUP_NUM,
2918 2918 MIN_RX_GROUP_NUM, MAX_RX_GROUP_NUM, DEFAULT_RX_GROUP_NUM);
2919 2919 /*
2920 2920 * Currently we do not support VMDq for 82576 and 82580.
2921 2921 * If it is e1000_82576, set num_rx_groups to 1.
2922 2922 */
2923 2923 if (hw->mac.type >= e1000_82576)
2924 2924 igb->num_rx_groups = 1;
2925 2925
2926 2926 if (igb->mr_enable) {
2927 2927 igb->num_tx_rings = igb->capab->def_tx_que_num;
2928 2928 igb->num_rx_rings = igb->capab->def_rx_que_num;
2929 2929 } else {
2930 2930 igb->num_tx_rings = 1;
2931 2931 igb->num_rx_rings = 1;
2932 2932
2933 2933 if (igb->num_rx_groups > 1) {
2934 2934 igb_error(igb,
2935 2935 "Invalid rx groups number. Please enable multiple "
2936 2936 "rings first");
2937 2937 igb->num_rx_groups = 1;
2938 2938 }
2939 2939 }
2940 2940
2941 2941 /*
2942 2942 * Check the divisibility between rx rings and rx groups.
2943 2943 */
2944 2944 for (i = igb->num_rx_groups; i > 0; i--) {
2945 2945 if ((igb->num_rx_rings % i) == 0)
2946 2946 break;
2947 2947 }
2948 2948 if (i != igb->num_rx_groups) {
2949 2949 igb_error(igb,
2950 2950 "Invalid rx groups number. Downgrade the rx group "
2951 2951 "number to %d.", i);
2952 2952 igb->num_rx_groups = i;
2953 2953 }
2954 2954
2955 2955 /*
2956 2956 * Get the ring number per group.
2957 2957 */
2958 2958 ring_per_group = igb->num_rx_rings / igb->num_rx_groups;
2959 2959
2960 2960 if (igb->num_rx_groups == 1) {
2961 2961 /*
2962 2962 * One rx ring group, the rx ring number is num_rx_rings.
2963 2963 */
2964 2964 igb->vmdq_mode = E1000_VMDQ_OFF;
2965 2965 } else if (ring_per_group == 1) {
2966 2966 /*
2967 2967 * Multiple rx groups, each group has one rx ring.
2968 2968 */
2969 2969 igb->vmdq_mode = E1000_VMDQ_MAC;
2970 2970 } else {
2971 2971 /*
2972 2972 * Multiple groups and multiple rings.
2973 2973 */
2974 2974 igb->vmdq_mode = E1000_VMDQ_MAC_RSS;
2975 2975 }
2976 2976
2977 2977 /*
2978 2978 * Tunable used to force an interrupt type. The only use is
2979 2979 * for testing of the lesser interrupt types.
2980 2980 * 0 = don't force interrupt type
2981 2981 * 1 = force interrupt type MSIX
2982 2982 * 2 = force interrupt type MSI
2983 2983 * 3 = force interrupt type Legacy
2984 2984 */
2985 2985 igb->intr_force = igb_get_prop(igb, PROP_INTR_FORCE,
2986 2986 IGB_INTR_NONE, IGB_INTR_LEGACY, IGB_INTR_NONE);
2987 2987
2988 2988 igb->tx_hcksum_enable = igb_get_prop(igb, PROP_TX_HCKSUM_ENABLE,
2989 2989 0, 1, 1);
2990 2990 igb->rx_hcksum_enable = igb_get_prop(igb, PROP_RX_HCKSUM_ENABLE,
2991 2991 0, 1, 1);
2992 2992 igb->lso_enable = igb_get_prop(igb, PROP_LSO_ENABLE,
2993 2993 0, 1, 1);
2994 2994 igb->tx_head_wb_enable = igb_get_prop(igb, PROP_TX_HEAD_WB_ENABLE,
2995 2995 0, 1, 1);
2996 2996
2997 2997 /*
2998 2998 * igb LSO needs the tx h/w checksum support.
2999 2999 * Here LSO will be disabled if tx h/w checksum has been disabled.
3000 3000 */
3001 3001 if (igb->tx_hcksum_enable == B_FALSE)
3002 3002 igb->lso_enable = B_FALSE;
3003 3003
3004 3004 igb->tx_copy_thresh = igb_get_prop(igb, PROP_TX_COPY_THRESHOLD,
3005 3005 MIN_TX_COPY_THRESHOLD, MAX_TX_COPY_THRESHOLD,
3006 3006 DEFAULT_TX_COPY_THRESHOLD);
3007 3007 igb->tx_recycle_thresh = igb_get_prop(igb, PROP_TX_RECYCLE_THRESHOLD,
3008 3008 MIN_TX_RECYCLE_THRESHOLD, MAX_TX_RECYCLE_THRESHOLD,
3009 3009 DEFAULT_TX_RECYCLE_THRESHOLD);
3010 3010 igb->tx_overload_thresh = igb_get_prop(igb, PROP_TX_OVERLOAD_THRESHOLD,
3011 3011 MIN_TX_OVERLOAD_THRESHOLD, MAX_TX_OVERLOAD_THRESHOLD,
3012 3012 DEFAULT_TX_OVERLOAD_THRESHOLD);
3013 3013 igb->tx_resched_thresh = igb_get_prop(igb, PROP_TX_RESCHED_THRESHOLD,
3014 3014 MIN_TX_RESCHED_THRESHOLD,
3015 3015 MIN(igb->tx_ring_size, MAX_TX_RESCHED_THRESHOLD),
3016 3016 igb->tx_ring_size > DEFAULT_TX_RESCHED_THRESHOLD ?
3017 3017 DEFAULT_TX_RESCHED_THRESHOLD : DEFAULT_TX_RESCHED_THRESHOLD_LOW);
3018 3018
3019 3019 igb->rx_copy_thresh = igb_get_prop(igb, PROP_RX_COPY_THRESHOLD,
3020 3020 MIN_RX_COPY_THRESHOLD, MAX_RX_COPY_THRESHOLD,
3021 3021 DEFAULT_RX_COPY_THRESHOLD);
3022 3022 igb->rx_limit_per_intr = igb_get_prop(igb, PROP_RX_LIMIT_PER_INTR,
3023 3023 MIN_RX_LIMIT_PER_INTR, MAX_RX_LIMIT_PER_INTR,
3024 3024 DEFAULT_RX_LIMIT_PER_INTR);
3025 3025
3026 3026 igb->intr_throttling[0] = igb_get_prop(igb, PROP_INTR_THROTTLING,
3027 3027 igb->capab->min_intr_throttle,
3028 3028 igb->capab->max_intr_throttle,
3029 3029 igb->capab->def_intr_throttle);
3030 3030
3031 3031 /*
3032 3032 * Max number of multicast addresses
3033 3033 */
3034 3034 igb->mcast_max_num =
3035 3035 igb_get_prop(igb, PROP_MCAST_MAX_NUM,
3036 3036 MIN_MCAST_NUM, MAX_MCAST_NUM, DEFAULT_MCAST_NUM);
3037 3037 }
3038 3038
3039 3039 /*
3040 3040 * igb_get_prop - Get a property value out of the configuration file igb.conf
3041 3041 *
3042 3042 * Caller provides the name of the property, a default value, a minimum
3043 3043 * value, and a maximum value.
3044 3044 *
3045 3045 * Return configured value of the property, with default, minimum and
3046 3046 * maximum properly applied.
3047 3047 */
3048 3048 static int
3049 3049 igb_get_prop(igb_t *igb,
3050 3050 char *propname, /* name of the property */
3051 3051 int minval, /* minimum acceptable value */
3052 3052 int maxval, /* maximim acceptable value */
3053 3053 int defval) /* default value */
3054 3054 {
3055 3055 int value;
3056 3056
3057 3057 /*
3058 3058 * Call ddi_prop_get_int() to read the conf settings
3059 3059 */
3060 3060 value = ddi_prop_get_int(DDI_DEV_T_ANY, igb->dip,
3061 3061 DDI_PROP_DONTPASS, propname, defval);
3062 3062
3063 3063 if (value > maxval)
3064 3064 value = maxval;
3065 3065
3066 3066 if (value < minval)
3067 3067 value = minval;
3068 3068
3069 3069 return (value);
3070 3070 }
3071 3071
3072 3072 /*
3073 3073 * igb_setup_link - Using the link properties to setup the link
3074 3074 */
3075 3075 int
3076 3076 igb_setup_link(igb_t *igb, boolean_t setup_hw)
3077 3077 {
3078 3078 struct e1000_mac_info *mac;
3079 3079 struct e1000_phy_info *phy;
3080 3080 boolean_t invalid;
3081 3081
3082 3082 mac = &igb->hw.mac;
3083 3083 phy = &igb->hw.phy;
3084 3084 invalid = B_FALSE;
3085 3085
3086 3086 if (igb->param_adv_autoneg_cap == 1) {
3087 3087 mac->autoneg = B_TRUE;
3088 3088 phy->autoneg_advertised = 0;
3089 3089
3090 3090 /*
3091 3091 * 1000hdx is not supported for autonegotiation
3092 3092 */
3093 3093 if (igb->param_adv_1000fdx_cap == 1)
3094 3094 phy->autoneg_advertised |= ADVERTISE_1000_FULL;
3095 3095
3096 3096 if (igb->param_adv_100fdx_cap == 1)
3097 3097 phy->autoneg_advertised |= ADVERTISE_100_FULL;
3098 3098
3099 3099 if (igb->param_adv_100hdx_cap == 1)
3100 3100 phy->autoneg_advertised |= ADVERTISE_100_HALF;
3101 3101
3102 3102 if (igb->param_adv_10fdx_cap == 1)
3103 3103 phy->autoneg_advertised |= ADVERTISE_10_FULL;
3104 3104
3105 3105 if (igb->param_adv_10hdx_cap == 1)
3106 3106 phy->autoneg_advertised |= ADVERTISE_10_HALF;
3107 3107
3108 3108 if (phy->autoneg_advertised == 0)
3109 3109 invalid = B_TRUE;
3110 3110 } else {
3111 3111 mac->autoneg = B_FALSE;
3112 3112
3113 3113 /*
3114 3114 * 1000fdx and 1000hdx are not supported for forced link
3115 3115 */
3116 3116 if (igb->param_adv_100fdx_cap == 1)
3117 3117 mac->forced_speed_duplex = ADVERTISE_100_FULL;
3118 3118 else if (igb->param_adv_100hdx_cap == 1)
3119 3119 mac->forced_speed_duplex = ADVERTISE_100_HALF;
3120 3120 else if (igb->param_adv_10fdx_cap == 1)
3121 3121 mac->forced_speed_duplex = ADVERTISE_10_FULL;
3122 3122 else if (igb->param_adv_10hdx_cap == 1)
3123 3123 mac->forced_speed_duplex = ADVERTISE_10_HALF;
3124 3124 else
3125 3125 invalid = B_TRUE;
3126 3126 }
3127 3127
3128 3128 if (invalid) {
3129 3129 igb_notice(igb, "Invalid link settings. Setup link to "
3130 3130 "autonegotiation with full link capabilities.");
3131 3131 mac->autoneg = B_TRUE;
3132 3132 phy->autoneg_advertised = ADVERTISE_1000_FULL |
3133 3133 ADVERTISE_100_FULL | ADVERTISE_100_HALF |
3134 3134 ADVERTISE_10_FULL | ADVERTISE_10_HALF;
3135 3135 }
3136 3136
3137 3137 if (setup_hw) {
3138 3138 if (e1000_setup_link(&igb->hw) != E1000_SUCCESS)
3139 3139 return (IGB_FAILURE);
3140 3140 }
3141 3141
3142 3142 return (IGB_SUCCESS);
3143 3143 }
3144 3144
3145 3145
3146 3146 /*
3147 3147 * igb_is_link_up - Check if the link is up
3148 3148 */
3149 3149 static boolean_t
3150 3150 igb_is_link_up(igb_t *igb)
3151 3151 {
3152 3152 struct e1000_hw *hw = &igb->hw;
3153 3153 boolean_t link_up = B_FALSE;
3154 3154
3155 3155 ASSERT(mutex_owned(&igb->gen_lock));
3156 3156
3157 3157 /*
3158 3158 * get_link_status is set in the interrupt handler on link-status-change
3159 3159 * or rx sequence error interrupt. get_link_status will stay
3160 3160 * false until the e1000_check_for_link establishes link only
3161 3161 * for copper adapters.
3162 3162 */
3163 3163 switch (hw->phy.media_type) {
3164 3164 case e1000_media_type_copper:
3165 3165 if (hw->mac.get_link_status) {
3166 3166 (void) e1000_check_for_link(hw);
3167 3167 link_up = !hw->mac.get_link_status;
3168 3168 } else {
3169 3169 link_up = B_TRUE;
3170 3170 }
3171 3171 break;
3172 3172 case e1000_media_type_fiber:
3173 3173 (void) e1000_check_for_link(hw);
3174 3174 link_up = (E1000_READ_REG(hw, E1000_STATUS) & E1000_STATUS_LU);
3175 3175 break;
3176 3176 case e1000_media_type_internal_serdes:
3177 3177 (void) e1000_check_for_link(hw);
3178 3178 link_up = hw->mac.serdes_has_link;
3179 3179 break;
3180 3180 }
3181 3181
3182 3182 return (link_up);
3183 3183 }
3184 3184
3185 3185 /*
3186 3186 * igb_link_check - Link status processing
3187 3187 */
3188 3188 static boolean_t
3189 3189 igb_link_check(igb_t *igb)
3190 3190 {
3191 3191 struct e1000_hw *hw = &igb->hw;
3192 3192 uint16_t speed = 0, duplex = 0;
3193 3193 boolean_t link_changed = B_FALSE;
3194 3194
3195 3195 ASSERT(mutex_owned(&igb->gen_lock));
3196 3196
3197 3197 if (igb_is_link_up(igb)) {
3198 3198 /*
3199 3199 * The Link is up, check whether it was marked as down earlier
3200 3200 */
3201 3201 if (igb->link_state != LINK_STATE_UP) {
3202 3202 (void) e1000_get_speed_and_duplex(hw, &speed, &duplex);
3203 3203 igb->link_speed = speed;
3204 3204 igb->link_duplex = duplex;
3205 3205 igb->link_state = LINK_STATE_UP;
3206 3206 link_changed = B_TRUE;
3207 3207 if (!igb->link_complete)
3208 3208 igb_stop_link_timer(igb);
3209 3209 }
3210 3210 } else if (igb->link_complete) {
3211 3211 if (igb->link_state != LINK_STATE_DOWN) {
3212 3212 igb->link_speed = 0;
3213 3213 igb->link_duplex = 0;
3214 3214 igb->link_state = LINK_STATE_DOWN;
3215 3215 link_changed = B_TRUE;
3216 3216 }
3217 3217 }
3218 3218
3219 3219 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK) {
3220 3220 ddi_fm_service_impact(igb->dip, DDI_SERVICE_DEGRADED);
3221 3221 return (B_FALSE);
3222 3222 }
3223 3223
3224 3224 return (link_changed);
3225 3225 }
3226 3226
3227 3227 /*
3228 3228 * igb_local_timer - driver watchdog function
3229 3229 *
3230 3230 * This function will handle the hardware stall check, link status
3231 3231 * check and other routines.
3232 3232 */
3233 3233 static void
3234 3234 igb_local_timer(void *arg)
3235 3235 {
3236 3236 igb_t *igb = (igb_t *)arg;
3237 3237 boolean_t link_changed = B_FALSE;
3238 3238
3239 3239 if (igb->igb_state & IGB_ERROR) {
3240 3240 igb->reset_count++;
3241 3241 if (igb_reset(igb) == IGB_SUCCESS)
3242 3242 ddi_fm_service_impact(igb->dip, DDI_SERVICE_RESTORED);
3243 3243
3244 3244 igb_restart_watchdog_timer(igb);
3245 3245 return;
3246 3246 }
3247 3247
3248 3248 if (igb_stall_check(igb) || (igb->igb_state & IGB_STALL)) {
3249 3249 igb_fm_ereport(igb, DDI_FM_DEVICE_STALL);
3250 3250 ddi_fm_service_impact(igb->dip, DDI_SERVICE_LOST);
3251 3251 igb->reset_count++;
3252 3252 if (igb_reset(igb) == IGB_SUCCESS)
3253 3253 ddi_fm_service_impact(igb->dip, DDI_SERVICE_RESTORED);
3254 3254
3255 3255 igb_restart_watchdog_timer(igb);
3256 3256 return;
3257 3257 }
3258 3258
3259 3259 mutex_enter(&igb->gen_lock);
3260 3260 if (!(igb->igb_state & IGB_SUSPENDED) && (igb->igb_state & IGB_STARTED))
3261 3261 link_changed = igb_link_check(igb);
3262 3262 mutex_exit(&igb->gen_lock);
3263 3263
3264 3264 if (link_changed)
3265 3265 mac_link_update(igb->mac_hdl, igb->link_state);
3266 3266
3267 3267 igb_restart_watchdog_timer(igb);
3268 3268 }
3269 3269
3270 3270 /*
3271 3271 * igb_link_timer - link setup timer function
3272 3272 *
3273 3273 * It is called when the timer for link setup is expired, which indicates
3274 3274 * the completion of the link setup. The link state will not be updated
3275 3275 * until the link setup is completed. And the link state will not be sent
3276 3276 * to the upper layer through mac_link_update() in this function. It will
3277 3277 * be updated in the local timer routine or the interrupts service routine
3278 3278 * after the interface is started (plumbed).
3279 3279 */
3280 3280 static void
3281 3281 igb_link_timer(void *arg)
3282 3282 {
3283 3283 igb_t *igb = (igb_t *)arg;
3284 3284
3285 3285 mutex_enter(&igb->link_lock);
3286 3286 igb->link_complete = B_TRUE;
3287 3287 igb->link_tid = 0;
3288 3288 mutex_exit(&igb->link_lock);
3289 3289 }
3290 3290 /*
3291 3291 * igb_stall_check - check for transmit stall
3292 3292 *
3293 3293 * This function checks if the adapter is stalled (in transmit).
3294 3294 *
3295 3295 * It is called each time the watchdog timeout is invoked.
3296 3296 * If the transmit descriptor reclaim continuously fails,
3297 3297 * the watchdog value will increment by 1. If the watchdog
3298 3298 * value exceeds the threshold, the igb is assumed to
3299 3299 * have stalled and need to be reset.
3300 3300 */
3301 3301 static boolean_t
3302 3302 igb_stall_check(igb_t *igb)
3303 3303 {
3304 3304 igb_tx_ring_t *tx_ring;
3305 3305 struct e1000_hw *hw = &igb->hw;
3306 3306 boolean_t result;
3307 3307 int i;
3308 3308
3309 3309 if (igb->link_state != LINK_STATE_UP)
3310 3310 return (B_FALSE);
3311 3311
3312 3312 /*
3313 3313 * If any tx ring is stalled, we'll reset the chipset
3314 3314 */
3315 3315 result = B_FALSE;
3316 3316 for (i = 0; i < igb->num_tx_rings; i++) {
3317 3317 tx_ring = &igb->tx_rings[i];
3318 3318
3319 3319 if (tx_ring->recycle_fail > 0)
3320 3320 tx_ring->stall_watchdog++;
3321 3321 else
3322 3322 tx_ring->stall_watchdog = 0;
3323 3323
3324 3324 if (tx_ring->stall_watchdog >= STALL_WATCHDOG_TIMEOUT) {
3325 3325 result = B_TRUE;
3326 3326 if (hw->mac.type == e1000_82580) {
3327 3327 hw->dev_spec._82575.global_device_reset
3328 3328 = B_TRUE;
3329 3329 }
3330 3330 break;
3331 3331 }
3332 3332 }
3333 3333
3334 3334 if (result) {
3335 3335 tx_ring->stall_watchdog = 0;
3336 3336 tx_ring->recycle_fail = 0;
3337 3337 }
3338 3338
3339 3339 return (result);
3340 3340 }
3341 3341
3342 3342
3343 3343 /*
3344 3344 * is_valid_mac_addr - Check if the mac address is valid
3345 3345 */
3346 3346 static boolean_t
3347 3347 is_valid_mac_addr(uint8_t *mac_addr)
3348 3348 {
3349 3349 const uint8_t addr_test1[6] = { 0, 0, 0, 0, 0, 0 };
3350 3350 const uint8_t addr_test2[6] =
3351 3351 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
3352 3352
3353 3353 if (!(bcmp(addr_test1, mac_addr, ETHERADDRL)) ||
3354 3354 !(bcmp(addr_test2, mac_addr, ETHERADDRL)))
3355 3355 return (B_FALSE);
3356 3356
3357 3357 return (B_TRUE);
3358 3358 }
3359 3359
3360 3360 static boolean_t
3361 3361 igb_find_mac_address(igb_t *igb)
3362 3362 {
3363 3363 struct e1000_hw *hw = &igb->hw;
3364 3364 #ifdef __sparc
3365 3365 uchar_t *bytes;
3366 3366 struct ether_addr sysaddr;
3367 3367 uint_t nelts;
3368 3368 int err;
3369 3369 boolean_t found = B_FALSE;
3370 3370
3371 3371 /*
3372 3372 * The "vendor's factory-set address" may already have
3373 3373 * been extracted from the chip, but if the property
3374 3374 * "local-mac-address" is set we use that instead.
3375 3375 *
3376 3376 * We check whether it looks like an array of 6
3377 3377 * bytes (which it should, if OBP set it). If we can't
3378 3378 * make sense of it this way, we'll ignore it.
3379 3379 */
3380 3380 err = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, igb->dip,
3381 3381 DDI_PROP_DONTPASS, "local-mac-address", &bytes, &nelts);
3382 3382 if (err == DDI_PROP_SUCCESS) {
3383 3383 if (nelts == ETHERADDRL) {
3384 3384 while (nelts--)
3385 3385 hw->mac.addr[nelts] = bytes[nelts];
3386 3386 found = B_TRUE;
3387 3387 }
3388 3388 ddi_prop_free(bytes);
3389 3389 }
3390 3390
3391 3391 /*
3392 3392 * Look up the OBP property "local-mac-address?". If the user has set
3393 3393 * 'local-mac-address? = false', use "the system address" instead.
3394 3394 */
3395 3395 if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, igb->dip, 0,
3396 3396 "local-mac-address?", &bytes, &nelts) == DDI_PROP_SUCCESS) {
3397 3397 if (strncmp("false", (caddr_t)bytes, (size_t)nelts) == 0) {
3398 3398 if (localetheraddr(NULL, &sysaddr) != 0) {
3399 3399 bcopy(&sysaddr, hw->mac.addr, ETHERADDRL);
3400 3400 found = B_TRUE;
3401 3401 }
3402 3402 }
3403 3403 ddi_prop_free(bytes);
3404 3404 }
3405 3405
3406 3406 /*
3407 3407 * Finally(!), if there's a valid "mac-address" property (created
3408 3408 * if we netbooted from this interface), we must use this instead
3409 3409 * of any of the above to ensure that the NFS/install server doesn't
3410 3410 * get confused by the address changing as Solaris takes over!
3411 3411 */
3412 3412 err = ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, igb->dip,
3413 3413 DDI_PROP_DONTPASS, "mac-address", &bytes, &nelts);
3414 3414 if (err == DDI_PROP_SUCCESS) {
3415 3415 if (nelts == ETHERADDRL) {
3416 3416 while (nelts--)
3417 3417 hw->mac.addr[nelts] = bytes[nelts];
3418 3418 found = B_TRUE;
3419 3419 }
3420 3420 ddi_prop_free(bytes);
3421 3421 }
3422 3422
3423 3423 if (found) {
3424 3424 bcopy(hw->mac.addr, hw->mac.perm_addr, ETHERADDRL);
3425 3425 return (B_TRUE);
3426 3426 }
3427 3427 #endif
3428 3428
3429 3429 /*
3430 3430 * Read the device MAC address from the EEPROM
3431 3431 */
3432 3432 if (e1000_read_mac_addr(hw) != E1000_SUCCESS)
3433 3433 return (B_FALSE);
3434 3434
3435 3435 return (B_TRUE);
3436 3436 }
3437 3437
↓ open down ↓ |
3437 lines elided |
↑ open up ↑ |
3438 3438 #pragma inline(igb_arm_watchdog_timer)
3439 3439
3440 3440 static void
3441 3441 igb_arm_watchdog_timer(igb_t *igb)
3442 3442 {
3443 3443 /*
3444 3444 * Fire a watchdog timer
3445 3445 */
3446 3446 igb->watchdog_tid =
3447 3447 timeout(igb_local_timer,
3448 - (void *)igb, 1 * drv_usectohz(1000000));
3448 + (void *)igb, drv_sectohz(1));
3449 3449
3450 3450 }
3451 3451
3452 3452 /*
3453 3453 * igb_enable_watchdog_timer - Enable and start the driver watchdog timer
3454 3454 */
3455 3455 void
3456 3456 igb_enable_watchdog_timer(igb_t *igb)
3457 3457 {
3458 3458 mutex_enter(&igb->watchdog_lock);
3459 3459
3460 3460 if (!igb->watchdog_enable) {
3461 3461 igb->watchdog_enable = B_TRUE;
3462 3462 igb->watchdog_start = B_TRUE;
3463 3463 igb_arm_watchdog_timer(igb);
3464 3464 }
3465 3465
3466 3466 mutex_exit(&igb->watchdog_lock);
3467 3467
3468 3468 }
3469 3469
3470 3470 /*
3471 3471 * igb_disable_watchdog_timer - Disable and stop the driver watchdog timer
3472 3472 */
3473 3473 void
3474 3474 igb_disable_watchdog_timer(igb_t *igb)
3475 3475 {
3476 3476 timeout_id_t tid;
3477 3477
3478 3478 mutex_enter(&igb->watchdog_lock);
3479 3479
3480 3480 igb->watchdog_enable = B_FALSE;
3481 3481 igb->watchdog_start = B_FALSE;
3482 3482 tid = igb->watchdog_tid;
3483 3483 igb->watchdog_tid = 0;
3484 3484
3485 3485 mutex_exit(&igb->watchdog_lock);
3486 3486
3487 3487 if (tid != 0)
3488 3488 (void) untimeout(tid);
3489 3489
3490 3490 }
3491 3491
3492 3492 /*
3493 3493 * igb_start_watchdog_timer - Start the driver watchdog timer
3494 3494 */
3495 3495 static void
3496 3496 igb_start_watchdog_timer(igb_t *igb)
3497 3497 {
3498 3498 mutex_enter(&igb->watchdog_lock);
3499 3499
3500 3500 if (igb->watchdog_enable) {
3501 3501 if (!igb->watchdog_start) {
3502 3502 igb->watchdog_start = B_TRUE;
3503 3503 igb_arm_watchdog_timer(igb);
3504 3504 }
3505 3505 }
3506 3506
3507 3507 mutex_exit(&igb->watchdog_lock);
3508 3508 }
3509 3509
3510 3510 /*
3511 3511 * igb_restart_watchdog_timer - Restart the driver watchdog timer
3512 3512 */
3513 3513 static void
3514 3514 igb_restart_watchdog_timer(igb_t *igb)
3515 3515 {
3516 3516 mutex_enter(&igb->watchdog_lock);
3517 3517
3518 3518 if (igb->watchdog_start)
3519 3519 igb_arm_watchdog_timer(igb);
3520 3520
3521 3521 mutex_exit(&igb->watchdog_lock);
3522 3522 }
3523 3523
3524 3524 /*
3525 3525 * igb_stop_watchdog_timer - Stop the driver watchdog timer
3526 3526 */
3527 3527 static void
3528 3528 igb_stop_watchdog_timer(igb_t *igb)
3529 3529 {
3530 3530 timeout_id_t tid;
3531 3531
3532 3532 mutex_enter(&igb->watchdog_lock);
3533 3533
3534 3534 igb->watchdog_start = B_FALSE;
3535 3535 tid = igb->watchdog_tid;
3536 3536 igb->watchdog_tid = 0;
3537 3537
3538 3538 mutex_exit(&igb->watchdog_lock);
3539 3539
3540 3540 if (tid != 0)
3541 3541 (void) untimeout(tid);
3542 3542 }
3543 3543
3544 3544 /*
3545 3545 * igb_start_link_timer - Start the link setup timer
3546 3546 */
3547 3547 static void
3548 3548 igb_start_link_timer(struct igb *igb)
3549 3549 {
3550 3550 struct e1000_hw *hw = &igb->hw;
3551 3551 clock_t link_timeout;
3552 3552
3553 3553 if (hw->mac.autoneg)
3554 3554 link_timeout = PHY_AUTO_NEG_LIMIT *
3555 3555 drv_usectohz(100000);
3556 3556 else
3557 3557 link_timeout = PHY_FORCE_LIMIT * drv_usectohz(100000);
3558 3558
3559 3559 mutex_enter(&igb->link_lock);
3560 3560 if (hw->phy.autoneg_wait_to_complete) {
3561 3561 igb->link_complete = B_TRUE;
3562 3562 } else {
3563 3563 igb->link_complete = B_FALSE;
3564 3564 igb->link_tid = timeout(igb_link_timer, (void *)igb,
3565 3565 link_timeout);
3566 3566 }
3567 3567 mutex_exit(&igb->link_lock);
3568 3568 }
3569 3569
3570 3570 /*
3571 3571 * igb_stop_link_timer - Stop the link setup timer
3572 3572 */
3573 3573 static void
3574 3574 igb_stop_link_timer(struct igb *igb)
3575 3575 {
3576 3576 timeout_id_t tid;
3577 3577
3578 3578 mutex_enter(&igb->link_lock);
3579 3579 igb->link_complete = B_TRUE;
3580 3580 tid = igb->link_tid;
3581 3581 igb->link_tid = 0;
3582 3582 mutex_exit(&igb->link_lock);
3583 3583
3584 3584 if (tid != 0)
3585 3585 (void) untimeout(tid);
3586 3586 }
3587 3587
3588 3588 /*
3589 3589 * igb_disable_adapter_interrupts - Clear/disable all hardware interrupts
3590 3590 */
3591 3591 static void
3592 3592 igb_disable_adapter_interrupts(igb_t *igb)
3593 3593 {
3594 3594 struct e1000_hw *hw = &igb->hw;
3595 3595
3596 3596 /*
3597 3597 * Set the IMC register to mask all the interrupts,
3598 3598 * including the tx interrupts.
3599 3599 */
3600 3600 E1000_WRITE_REG(hw, E1000_IMC, ~0);
3601 3601 E1000_WRITE_REG(hw, E1000_IAM, 0);
3602 3602
3603 3603 /*
3604 3604 * Additional disabling for MSI-X
3605 3605 */
3606 3606 if (igb->intr_type == DDI_INTR_TYPE_MSIX) {
3607 3607 E1000_WRITE_REG(hw, E1000_EIMC, ~0);
3608 3608 E1000_WRITE_REG(hw, E1000_EIAC, 0);
3609 3609 E1000_WRITE_REG(hw, E1000_EIAM, 0);
3610 3610 }
3611 3611
3612 3612 E1000_WRITE_FLUSH(hw);
3613 3613 }
3614 3614
3615 3615 /*
3616 3616 * igb_enable_adapter_interrupts_82580 - Enable NIC interrupts for 82580
3617 3617 */
3618 3618 static void
3619 3619 igb_enable_adapter_interrupts_82580(igb_t *igb)
3620 3620 {
3621 3621 struct e1000_hw *hw = &igb->hw;
3622 3622
3623 3623 /* Clear any pending interrupts */
3624 3624 (void) E1000_READ_REG(hw, E1000_ICR);
3625 3625 igb->ims_mask |= E1000_IMS_DRSTA;
3626 3626
3627 3627 if (igb->intr_type == DDI_INTR_TYPE_MSIX) {
3628 3628
3629 3629 /* Interrupt enabling for MSI-X */
3630 3630 E1000_WRITE_REG(hw, E1000_EIMS, igb->eims_mask);
3631 3631 E1000_WRITE_REG(hw, E1000_EIAC, igb->eims_mask);
3632 3632 igb->ims_mask = (E1000_IMS_LSC | E1000_IMS_DRSTA);
3633 3633 E1000_WRITE_REG(hw, E1000_IMS, igb->ims_mask);
3634 3634 } else { /* Interrupt enabling for MSI and legacy */
3635 3635 E1000_WRITE_REG(hw, E1000_IVAR0, E1000_IVAR_VALID);
3636 3636 igb->ims_mask = IMS_ENABLE_MASK | E1000_IMS_TXQE;
3637 3637 igb->ims_mask |= E1000_IMS_DRSTA;
3638 3638 E1000_WRITE_REG(hw, E1000_IMS, igb->ims_mask);
3639 3639 }
3640 3640
3641 3641 /* Disable auto-mask for ICR interrupt bits */
3642 3642 E1000_WRITE_REG(hw, E1000_IAM, 0);
3643 3643
3644 3644 E1000_WRITE_FLUSH(hw);
3645 3645 }
3646 3646
3647 3647 /*
3648 3648 * igb_enable_adapter_interrupts_82576 - Enable NIC interrupts for 82576
3649 3649 */
3650 3650 static void
3651 3651 igb_enable_adapter_interrupts_82576(igb_t *igb)
3652 3652 {
3653 3653 struct e1000_hw *hw = &igb->hw;
3654 3654
3655 3655 /* Clear any pending interrupts */
3656 3656 (void) E1000_READ_REG(hw, E1000_ICR);
3657 3657
3658 3658 if (igb->intr_type == DDI_INTR_TYPE_MSIX) {
3659 3659
3660 3660 /* Interrupt enabling for MSI-X */
3661 3661 E1000_WRITE_REG(hw, E1000_EIMS, igb->eims_mask);
3662 3662 E1000_WRITE_REG(hw, E1000_EIAC, igb->eims_mask);
3663 3663 igb->ims_mask = E1000_IMS_LSC;
3664 3664 E1000_WRITE_REG(hw, E1000_IMS, E1000_IMS_LSC);
3665 3665 } else {
3666 3666 /* Interrupt enabling for MSI and legacy */
3667 3667 E1000_WRITE_REG(hw, E1000_IVAR0, E1000_IVAR_VALID);
3668 3668 igb->ims_mask = IMS_ENABLE_MASK | E1000_IMS_TXQE;
3669 3669 E1000_WRITE_REG(hw, E1000_IMS,
3670 3670 (IMS_ENABLE_MASK | E1000_IMS_TXQE));
3671 3671 }
3672 3672
3673 3673 /* Disable auto-mask for ICR interrupt bits */
3674 3674 E1000_WRITE_REG(hw, E1000_IAM, 0);
3675 3675
3676 3676 E1000_WRITE_FLUSH(hw);
3677 3677 }
3678 3678
3679 3679 /*
3680 3680 * igb_enable_adapter_interrupts_82575 - Enable NIC interrupts for 82575
3681 3681 */
3682 3682 static void
3683 3683 igb_enable_adapter_interrupts_82575(igb_t *igb)
3684 3684 {
3685 3685 struct e1000_hw *hw = &igb->hw;
3686 3686 uint32_t reg;
3687 3687
3688 3688 /* Clear any pending interrupts */
3689 3689 (void) E1000_READ_REG(hw, E1000_ICR);
3690 3690
3691 3691 if (igb->intr_type == DDI_INTR_TYPE_MSIX) {
3692 3692 /* Interrupt enabling for MSI-X */
3693 3693 E1000_WRITE_REG(hw, E1000_EIMS, igb->eims_mask);
3694 3694 E1000_WRITE_REG(hw, E1000_EIAC, igb->eims_mask);
3695 3695 igb->ims_mask = E1000_IMS_LSC;
3696 3696 E1000_WRITE_REG(hw, E1000_IMS, E1000_IMS_LSC);
3697 3697
3698 3698 /* Enable MSI-X PBA support */
3699 3699 reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
3700 3700 reg |= E1000_CTRL_EXT_PBA_CLR;
3701 3701
3702 3702 /* Non-selective interrupt clear-on-read */
3703 3703 reg |= E1000_CTRL_EXT_IRCA; /* Called NSICR in the EAS */
3704 3704
3705 3705 E1000_WRITE_REG(hw, E1000_CTRL_EXT, reg);
3706 3706 } else {
3707 3707 /* Interrupt enabling for MSI and legacy */
3708 3708 igb->ims_mask = IMS_ENABLE_MASK;
3709 3709 E1000_WRITE_REG(hw, E1000_IMS, IMS_ENABLE_MASK);
3710 3710 }
3711 3711
3712 3712 E1000_WRITE_FLUSH(hw);
3713 3713 }
3714 3714
3715 3715 /*
3716 3716 * Loopback Support
3717 3717 */
3718 3718 static lb_property_t lb_normal =
3719 3719 { normal, "normal", IGB_LB_NONE };
3720 3720 static lb_property_t lb_external =
3721 3721 { external, "External", IGB_LB_EXTERNAL };
3722 3722 static lb_property_t lb_phy =
3723 3723 { internal, "PHY", IGB_LB_INTERNAL_PHY };
3724 3724 static lb_property_t lb_serdes =
3725 3725 { internal, "SerDes", IGB_LB_INTERNAL_SERDES };
3726 3726
3727 3727 enum ioc_reply
3728 3728 igb_loopback_ioctl(igb_t *igb, struct iocblk *iocp, mblk_t *mp)
3729 3729 {
3730 3730 lb_info_sz_t *lbsp;
3731 3731 lb_property_t *lbpp;
3732 3732 struct e1000_hw *hw;
3733 3733 uint32_t *lbmp;
3734 3734 uint32_t size;
3735 3735 uint32_t value;
3736 3736
3737 3737 hw = &igb->hw;
3738 3738
3739 3739 if (mp->b_cont == NULL)
3740 3740 return (IOC_INVAL);
3741 3741
3742 3742 switch (iocp->ioc_cmd) {
3743 3743 default:
3744 3744 return (IOC_INVAL);
3745 3745
3746 3746 case LB_GET_INFO_SIZE:
3747 3747 size = sizeof (lb_info_sz_t);
3748 3748 if (iocp->ioc_count != size)
3749 3749 return (IOC_INVAL);
3750 3750
3751 3751 value = sizeof (lb_normal);
3752 3752 if (hw->phy.media_type == e1000_media_type_copper)
3753 3753 value += sizeof (lb_phy);
3754 3754 else
3755 3755 value += sizeof (lb_serdes);
3756 3756 value += sizeof (lb_external);
3757 3757
3758 3758 lbsp = (lb_info_sz_t *)(uintptr_t)mp->b_cont->b_rptr;
3759 3759 *lbsp = value;
3760 3760 break;
3761 3761
3762 3762 case LB_GET_INFO:
3763 3763 value = sizeof (lb_normal);
3764 3764 if (hw->phy.media_type == e1000_media_type_copper)
3765 3765 value += sizeof (lb_phy);
3766 3766 else
3767 3767 value += sizeof (lb_serdes);
3768 3768 value += sizeof (lb_external);
3769 3769
3770 3770 size = value;
3771 3771 if (iocp->ioc_count != size)
3772 3772 return (IOC_INVAL);
3773 3773
3774 3774 value = 0;
3775 3775 lbpp = (lb_property_t *)(uintptr_t)mp->b_cont->b_rptr;
3776 3776
3777 3777 lbpp[value++] = lb_normal;
3778 3778 if (hw->phy.media_type == e1000_media_type_copper)
3779 3779 lbpp[value++] = lb_phy;
3780 3780 else
3781 3781 lbpp[value++] = lb_serdes;
3782 3782 lbpp[value++] = lb_external;
3783 3783 break;
3784 3784
3785 3785 case LB_GET_MODE:
3786 3786 size = sizeof (uint32_t);
3787 3787 if (iocp->ioc_count != size)
3788 3788 return (IOC_INVAL);
3789 3789
3790 3790 lbmp = (uint32_t *)(uintptr_t)mp->b_cont->b_rptr;
3791 3791 *lbmp = igb->loopback_mode;
3792 3792 break;
3793 3793
3794 3794 case LB_SET_MODE:
3795 3795 size = 0;
3796 3796 if (iocp->ioc_count != sizeof (uint32_t))
3797 3797 return (IOC_INVAL);
3798 3798
3799 3799 lbmp = (uint32_t *)(uintptr_t)mp->b_cont->b_rptr;
3800 3800 if (!igb_set_loopback_mode(igb, *lbmp))
3801 3801 return (IOC_INVAL);
3802 3802 break;
3803 3803 }
3804 3804
3805 3805 iocp->ioc_count = size;
3806 3806 iocp->ioc_error = 0;
3807 3807
3808 3808 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK) {
3809 3809 ddi_fm_service_impact(igb->dip, DDI_SERVICE_DEGRADED);
3810 3810 return (IOC_INVAL);
3811 3811 }
3812 3812
3813 3813 return (IOC_REPLY);
3814 3814 }
3815 3815
3816 3816 /*
3817 3817 * igb_set_loopback_mode - Setup loopback based on the loopback mode
3818 3818 */
3819 3819 static boolean_t
3820 3820 igb_set_loopback_mode(igb_t *igb, uint32_t mode)
3821 3821 {
3822 3822 struct e1000_hw *hw;
3823 3823 int i;
3824 3824
3825 3825 if (mode == igb->loopback_mode)
3826 3826 return (B_TRUE);
3827 3827
3828 3828 hw = &igb->hw;
3829 3829
3830 3830 igb->loopback_mode = mode;
3831 3831
3832 3832 if (mode == IGB_LB_NONE) {
3833 3833 /* Reset the chip */
3834 3834 hw->phy.autoneg_wait_to_complete = B_TRUE;
3835 3835 (void) igb_reset(igb);
3836 3836 hw->phy.autoneg_wait_to_complete = B_FALSE;
3837 3837 return (B_TRUE);
3838 3838 }
3839 3839
3840 3840 mutex_enter(&igb->gen_lock);
3841 3841
3842 3842 switch (mode) {
3843 3843 default:
3844 3844 mutex_exit(&igb->gen_lock);
3845 3845 return (B_FALSE);
3846 3846
3847 3847 case IGB_LB_EXTERNAL:
3848 3848 igb_set_external_loopback(igb);
3849 3849 break;
3850 3850
3851 3851 case IGB_LB_INTERNAL_PHY:
3852 3852 igb_set_internal_phy_loopback(igb);
3853 3853 break;
3854 3854
3855 3855 case IGB_LB_INTERNAL_SERDES:
3856 3856 igb_set_internal_serdes_loopback(igb);
3857 3857 break;
3858 3858 }
3859 3859
3860 3860 mutex_exit(&igb->gen_lock);
3861 3861
3862 3862 /*
3863 3863 * When external loopback is set, wait up to 1000ms to get the link up.
3864 3864 * According to test, 1000ms can work and it's an experimental value.
3865 3865 */
3866 3866 if (mode == IGB_LB_EXTERNAL) {
3867 3867 for (i = 0; i <= 10; i++) {
3868 3868 mutex_enter(&igb->gen_lock);
3869 3869 (void) igb_link_check(igb);
3870 3870 mutex_exit(&igb->gen_lock);
3871 3871
3872 3872 if (igb->link_state == LINK_STATE_UP)
3873 3873 break;
3874 3874
3875 3875 msec_delay(100);
3876 3876 }
3877 3877
3878 3878 if (igb->link_state != LINK_STATE_UP) {
3879 3879 /*
3880 3880 * Does not support external loopback.
3881 3881 * Reset driver to loopback none.
3882 3882 */
3883 3883 igb->loopback_mode = IGB_LB_NONE;
3884 3884
3885 3885 /* Reset the chip */
3886 3886 hw->phy.autoneg_wait_to_complete = B_TRUE;
3887 3887 (void) igb_reset(igb);
3888 3888 hw->phy.autoneg_wait_to_complete = B_FALSE;
3889 3889
3890 3890 IGB_DEBUGLOG_0(igb, "Set external loopback failed, "
3891 3891 "reset to loopback none.");
3892 3892
3893 3893 return (B_FALSE);
3894 3894 }
3895 3895 }
3896 3896
3897 3897 return (B_TRUE);
3898 3898 }
3899 3899
3900 3900 /*
3901 3901 * igb_set_external_loopback - Set the external loopback mode
3902 3902 */
3903 3903 static void
3904 3904 igb_set_external_loopback(igb_t *igb)
3905 3905 {
3906 3906 struct e1000_hw *hw;
3907 3907 uint32_t ctrl_ext;
3908 3908
3909 3909 hw = &igb->hw;
3910 3910
3911 3911 /* Set link mode to PHY (00b) in the Extended Control register */
3912 3912 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
3913 3913 ctrl_ext &= ~E1000_CTRL_EXT_LINK_MODE_MASK;
3914 3914 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
3915 3915
3916 3916 (void) e1000_write_phy_reg(hw, 0x0, 0x0140);
3917 3917 (void) e1000_write_phy_reg(hw, 0x9, 0x1a00);
3918 3918 (void) e1000_write_phy_reg(hw, 0x12, 0x1610);
3919 3919 (void) e1000_write_phy_reg(hw, 0x1f37, 0x3f1c);
3920 3920 }
3921 3921
3922 3922 /*
3923 3923 * igb_set_internal_phy_loopback - Set the internal PHY loopback mode
3924 3924 */
3925 3925 static void
3926 3926 igb_set_internal_phy_loopback(igb_t *igb)
3927 3927 {
3928 3928 struct e1000_hw *hw;
3929 3929 uint32_t ctrl_ext;
3930 3930 uint16_t phy_ctrl;
3931 3931 uint16_t phy_pconf;
3932 3932
3933 3933 hw = &igb->hw;
3934 3934
3935 3935 /* Set link mode to PHY (00b) in the Extended Control register */
3936 3936 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
3937 3937 ctrl_ext &= ~E1000_CTRL_EXT_LINK_MODE_MASK;
3938 3938 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
3939 3939
3940 3940 /*
3941 3941 * Set PHY control register (0x4140):
3942 3942 * Set full duplex mode
3943 3943 * Set loopback bit
3944 3944 * Clear auto-neg enable bit
3945 3945 * Set PHY speed
3946 3946 */
3947 3947 phy_ctrl = MII_CR_FULL_DUPLEX | MII_CR_SPEED_1000 | MII_CR_LOOPBACK;
3948 3948 (void) e1000_write_phy_reg(hw, PHY_CONTROL, phy_ctrl);
3949 3949
3950 3950 /* Set the link disable bit in the Port Configuration register */
3951 3951 (void) e1000_read_phy_reg(hw, 0x10, &phy_pconf);
3952 3952 phy_pconf |= (uint16_t)1 << 14;
3953 3953 (void) e1000_write_phy_reg(hw, 0x10, phy_pconf);
3954 3954 }
3955 3955
3956 3956 /*
3957 3957 * igb_set_internal_serdes_loopback - Set the internal SerDes loopback mode
3958 3958 */
3959 3959 static void
3960 3960 igb_set_internal_serdes_loopback(igb_t *igb)
3961 3961 {
3962 3962 struct e1000_hw *hw;
3963 3963 uint32_t ctrl_ext;
3964 3964 uint32_t ctrl;
3965 3965 uint32_t pcs_lctl;
3966 3966 uint32_t connsw;
3967 3967
3968 3968 hw = &igb->hw;
3969 3969
3970 3970 /* Set link mode to SerDes (11b) in the Extended Control register */
3971 3971 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
3972 3972 ctrl_ext |= E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES;
3973 3973 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
3974 3974
3975 3975 /* Configure the SerDes to loopback */
3976 3976 E1000_WRITE_REG(hw, E1000_SCTL, 0x410);
3977 3977
3978 3978 /* Set Device Control register */
3979 3979 ctrl = E1000_READ_REG(hw, E1000_CTRL);
3980 3980 ctrl |= (E1000_CTRL_FD | /* Force full duplex */
3981 3981 E1000_CTRL_SLU); /* Force link up */
3982 3982 ctrl &= ~(E1000_CTRL_RFCE | /* Disable receive flow control */
3983 3983 E1000_CTRL_TFCE | /* Disable transmit flow control */
3984 3984 E1000_CTRL_LRST); /* Clear link reset */
3985 3985 E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
3986 3986
3987 3987 /* Set PCS Link Control register */
3988 3988 pcs_lctl = E1000_READ_REG(hw, E1000_PCS_LCTL);
3989 3989 pcs_lctl |= (E1000_PCS_LCTL_FORCE_LINK |
3990 3990 E1000_PCS_LCTL_FSD |
3991 3991 E1000_PCS_LCTL_FDV_FULL |
3992 3992 E1000_PCS_LCTL_FLV_LINK_UP);
3993 3993 pcs_lctl &= ~E1000_PCS_LCTL_AN_ENABLE;
3994 3994 E1000_WRITE_REG(hw, E1000_PCS_LCTL, pcs_lctl);
3995 3995
3996 3996 /* Set the Copper/Fiber Switch Control - CONNSW register */
3997 3997 connsw = E1000_READ_REG(hw, E1000_CONNSW);
3998 3998 connsw &= ~E1000_CONNSW_ENRGSRC;
3999 3999 E1000_WRITE_REG(hw, E1000_CONNSW, connsw);
4000 4000 }
4001 4001
4002 4002 #pragma inline(igb_intr_rx_work)
4003 4003 /*
4004 4004 * igb_intr_rx_work - rx processing of ISR
4005 4005 */
4006 4006 static void
4007 4007 igb_intr_rx_work(igb_rx_ring_t *rx_ring)
4008 4008 {
4009 4009 mblk_t *mp;
4010 4010
4011 4011 mutex_enter(&rx_ring->rx_lock);
4012 4012 mp = igb_rx(rx_ring, IGB_NO_POLL);
4013 4013 mutex_exit(&rx_ring->rx_lock);
4014 4014
4015 4015 if (mp != NULL)
4016 4016 mac_rx_ring(rx_ring->igb->mac_hdl, rx_ring->ring_handle, mp,
4017 4017 rx_ring->ring_gen_num);
4018 4018 }
4019 4019
4020 4020 #pragma inline(igb_intr_tx_work)
4021 4021 /*
4022 4022 * igb_intr_tx_work - tx processing of ISR
4023 4023 */
4024 4024 static void
4025 4025 igb_intr_tx_work(igb_tx_ring_t *tx_ring)
4026 4026 {
4027 4027 igb_t *igb = tx_ring->igb;
4028 4028
4029 4029 /* Recycle the tx descriptors */
4030 4030 tx_ring->tx_recycle(tx_ring);
4031 4031
4032 4032 /* Schedule the re-transmit */
4033 4033 if (tx_ring->reschedule &&
4034 4034 (tx_ring->tbd_free >= igb->tx_resched_thresh)) {
4035 4035 tx_ring->reschedule = B_FALSE;
4036 4036 mac_tx_ring_update(tx_ring->igb->mac_hdl, tx_ring->ring_handle);
4037 4037 IGB_DEBUG_STAT(tx_ring->stat_reschedule);
4038 4038 }
4039 4039 }
4040 4040
4041 4041 #pragma inline(igb_intr_link_work)
4042 4042 /*
4043 4043 * igb_intr_link_work - link-status-change processing of ISR
4044 4044 */
4045 4045 static void
4046 4046 igb_intr_link_work(igb_t *igb)
4047 4047 {
4048 4048 boolean_t link_changed;
4049 4049
4050 4050 igb_stop_watchdog_timer(igb);
4051 4051
4052 4052 mutex_enter(&igb->gen_lock);
4053 4053
4054 4054 /*
4055 4055 * Because we got a link-status-change interrupt, force
4056 4056 * e1000_check_for_link() to look at phy
4057 4057 */
4058 4058 igb->hw.mac.get_link_status = B_TRUE;
4059 4059
4060 4060 /* igb_link_check takes care of link status change */
4061 4061 link_changed = igb_link_check(igb);
4062 4062
4063 4063 /* Get new phy state */
4064 4064 igb_get_phy_state(igb);
4065 4065
4066 4066 mutex_exit(&igb->gen_lock);
4067 4067
4068 4068 if (link_changed)
4069 4069 mac_link_update(igb->mac_hdl, igb->link_state);
4070 4070
4071 4071 igb_start_watchdog_timer(igb);
4072 4072 }
4073 4073
4074 4074 /*
4075 4075 * igb_intr_legacy - Interrupt handler for legacy interrupts
4076 4076 */
4077 4077 static uint_t
4078 4078 igb_intr_legacy(void *arg1, void *arg2)
4079 4079 {
4080 4080 igb_t *igb = (igb_t *)arg1;
4081 4081 igb_tx_ring_t *tx_ring;
4082 4082 uint32_t icr;
4083 4083 mblk_t *mp;
4084 4084 boolean_t tx_reschedule;
4085 4085 boolean_t link_changed;
4086 4086 uint_t result;
4087 4087
4088 4088 _NOTE(ARGUNUSED(arg2));
4089 4089
4090 4090 mutex_enter(&igb->gen_lock);
4091 4091
4092 4092 if (igb->igb_state & IGB_SUSPENDED) {
4093 4093 mutex_exit(&igb->gen_lock);
4094 4094 return (DDI_INTR_UNCLAIMED);
4095 4095 }
4096 4096
4097 4097 mp = NULL;
4098 4098 tx_reschedule = B_FALSE;
4099 4099 link_changed = B_FALSE;
4100 4100 icr = E1000_READ_REG(&igb->hw, E1000_ICR);
4101 4101
4102 4102 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK) {
4103 4103 mutex_exit(&igb->gen_lock);
4104 4104 ddi_fm_service_impact(igb->dip, DDI_SERVICE_DEGRADED);
4105 4105 atomic_or_32(&igb->igb_state, IGB_ERROR);
4106 4106 return (DDI_INTR_UNCLAIMED);
4107 4107 }
4108 4108
4109 4109 if (icr & E1000_ICR_INT_ASSERTED) {
4110 4110 /*
4111 4111 * E1000_ICR_INT_ASSERTED bit was set:
4112 4112 * Read(Clear) the ICR, claim this interrupt,
4113 4113 * look for work to do.
4114 4114 */
4115 4115 ASSERT(igb->num_rx_rings == 1);
4116 4116 ASSERT(igb->num_tx_rings == 1);
4117 4117
4118 4118 /* Make sure all interrupt causes cleared */
4119 4119 (void) E1000_READ_REG(&igb->hw, E1000_EICR);
4120 4120
4121 4121 if (icr & E1000_ICR_RXT0) {
4122 4122 mp = igb_rx(&igb->rx_rings[0], IGB_NO_POLL);
4123 4123 }
4124 4124
4125 4125 if (icr & E1000_ICR_TXDW) {
4126 4126 tx_ring = &igb->tx_rings[0];
4127 4127
4128 4128 /* Recycle the tx descriptors */
4129 4129 tx_ring->tx_recycle(tx_ring);
4130 4130
4131 4131 /* Schedule the re-transmit */
4132 4132 tx_reschedule = (tx_ring->reschedule &&
4133 4133 (tx_ring->tbd_free >= igb->tx_resched_thresh));
4134 4134 }
4135 4135
4136 4136 if (icr & E1000_ICR_LSC) {
4137 4137 /*
4138 4138 * Because we got a link-status-change interrupt, force
4139 4139 * e1000_check_for_link() to look at phy
4140 4140 */
4141 4141 igb->hw.mac.get_link_status = B_TRUE;
4142 4142
4143 4143 /* igb_link_check takes care of link status change */
4144 4144 link_changed = igb_link_check(igb);
4145 4145
4146 4146 /* Get new phy state */
4147 4147 igb_get_phy_state(igb);
4148 4148 }
4149 4149
4150 4150 if (icr & E1000_ICR_DRSTA) {
4151 4151 /* 82580 Full Device Reset needed */
4152 4152 atomic_or_32(&igb->igb_state, IGB_STALL);
4153 4153 }
4154 4154
4155 4155 result = DDI_INTR_CLAIMED;
4156 4156 } else {
4157 4157 /*
4158 4158 * E1000_ICR_INT_ASSERTED bit was not set:
4159 4159 * Don't claim this interrupt.
4160 4160 */
4161 4161 result = DDI_INTR_UNCLAIMED;
4162 4162 }
4163 4163
4164 4164 mutex_exit(&igb->gen_lock);
4165 4165
4166 4166 /*
4167 4167 * Do the following work outside of the gen_lock
4168 4168 */
4169 4169 if (mp != NULL)
4170 4170 mac_rx(igb->mac_hdl, NULL, mp);
4171 4171
4172 4172 if (tx_reschedule) {
4173 4173 tx_ring->reschedule = B_FALSE;
4174 4174 mac_tx_ring_update(igb->mac_hdl, tx_ring->ring_handle);
4175 4175 IGB_DEBUG_STAT(tx_ring->stat_reschedule);
4176 4176 }
4177 4177
4178 4178 if (link_changed)
4179 4179 mac_link_update(igb->mac_hdl, igb->link_state);
4180 4180
4181 4181 return (result);
4182 4182 }
4183 4183
4184 4184 /*
4185 4185 * igb_intr_msi - Interrupt handler for MSI
4186 4186 */
4187 4187 static uint_t
4188 4188 igb_intr_msi(void *arg1, void *arg2)
4189 4189 {
4190 4190 igb_t *igb = (igb_t *)arg1;
4191 4191 uint32_t icr;
4192 4192
4193 4193 _NOTE(ARGUNUSED(arg2));
4194 4194
4195 4195 icr = E1000_READ_REG(&igb->hw, E1000_ICR);
4196 4196
4197 4197 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK) {
4198 4198 ddi_fm_service_impact(igb->dip, DDI_SERVICE_DEGRADED);
4199 4199 atomic_or_32(&igb->igb_state, IGB_ERROR);
4200 4200 return (DDI_INTR_CLAIMED);
4201 4201 }
4202 4202
4203 4203 /* Make sure all interrupt causes cleared */
4204 4204 (void) E1000_READ_REG(&igb->hw, E1000_EICR);
4205 4205
4206 4206 /*
4207 4207 * For MSI interrupt, we have only one vector,
4208 4208 * so we have only one rx ring and one tx ring enabled.
4209 4209 */
4210 4210 ASSERT(igb->num_rx_rings == 1);
4211 4211 ASSERT(igb->num_tx_rings == 1);
4212 4212
4213 4213 if (icr & E1000_ICR_RXT0) {
4214 4214 igb_intr_rx_work(&igb->rx_rings[0]);
4215 4215 }
4216 4216
4217 4217 if (icr & E1000_ICR_TXDW) {
4218 4218 igb_intr_tx_work(&igb->tx_rings[0]);
4219 4219 }
4220 4220
4221 4221 if (icr & E1000_ICR_LSC) {
4222 4222 igb_intr_link_work(igb);
4223 4223 }
4224 4224
4225 4225 if (icr & E1000_ICR_DRSTA) {
4226 4226 /* 82580 Full Device Reset needed */
4227 4227 atomic_or_32(&igb->igb_state, IGB_STALL);
4228 4228 }
4229 4229
4230 4230 return (DDI_INTR_CLAIMED);
4231 4231 }
4232 4232
4233 4233 /*
4234 4234 * igb_intr_rx - Interrupt handler for rx
4235 4235 */
4236 4236 static uint_t
4237 4237 igb_intr_rx(void *arg1, void *arg2)
4238 4238 {
4239 4239 igb_rx_ring_t *rx_ring = (igb_rx_ring_t *)arg1;
4240 4240
4241 4241 _NOTE(ARGUNUSED(arg2));
4242 4242
4243 4243 /*
4244 4244 * Only used via MSI-X vector so don't check cause bits
4245 4245 * and only clean the given ring.
4246 4246 */
4247 4247 igb_intr_rx_work(rx_ring);
4248 4248
4249 4249 return (DDI_INTR_CLAIMED);
4250 4250 }
4251 4251
4252 4252 /*
4253 4253 * igb_intr_tx - Interrupt handler for tx
4254 4254 */
4255 4255 static uint_t
4256 4256 igb_intr_tx(void *arg1, void *arg2)
4257 4257 {
4258 4258 igb_tx_ring_t *tx_ring = (igb_tx_ring_t *)arg1;
4259 4259
4260 4260 _NOTE(ARGUNUSED(arg2));
4261 4261
4262 4262 /*
4263 4263 * Only used via MSI-X vector so don't check cause bits
4264 4264 * and only clean the given ring.
4265 4265 */
4266 4266 igb_intr_tx_work(tx_ring);
4267 4267
4268 4268 return (DDI_INTR_CLAIMED);
4269 4269 }
4270 4270
4271 4271 /*
4272 4272 * igb_intr_tx_other - Interrupt handler for both tx and other
4273 4273 *
4274 4274 */
4275 4275 static uint_t
4276 4276 igb_intr_tx_other(void *arg1, void *arg2)
4277 4277 {
4278 4278 igb_t *igb = (igb_t *)arg1;
4279 4279 uint32_t icr;
4280 4280
4281 4281 _NOTE(ARGUNUSED(arg2));
4282 4282
4283 4283 icr = E1000_READ_REG(&igb->hw, E1000_ICR);
4284 4284
4285 4285 if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK) {
4286 4286 ddi_fm_service_impact(igb->dip, DDI_SERVICE_DEGRADED);
4287 4287 atomic_or_32(&igb->igb_state, IGB_ERROR);
4288 4288 return (DDI_INTR_CLAIMED);
4289 4289 }
4290 4290
4291 4291 /*
4292 4292 * Look for tx reclaiming work first. Remember, in the
4293 4293 * case of only interrupt sharing, only one tx ring is
4294 4294 * used
4295 4295 */
4296 4296 igb_intr_tx_work(&igb->tx_rings[0]);
4297 4297
4298 4298 /*
4299 4299 * Check for "other" causes.
4300 4300 */
4301 4301 if (icr & E1000_ICR_LSC) {
4302 4302 igb_intr_link_work(igb);
4303 4303 }
4304 4304
4305 4305 /*
4306 4306 * The DOUTSYNC bit indicates a tx packet dropped because
4307 4307 * DMA engine gets "out of sync". There isn't a real fix
4308 4308 * for this. The Intel recommendation is to count the number
4309 4309 * of occurrences so user can detect when it is happening.
4310 4310 * The issue is non-fatal and there's no recovery action
4311 4311 * available.
4312 4312 */
4313 4313 if (icr & E1000_ICR_DOUTSYNC) {
4314 4314 IGB_STAT(igb->dout_sync);
4315 4315 }
4316 4316
4317 4317 if (icr & E1000_ICR_DRSTA) {
4318 4318 /* 82580 Full Device Reset needed */
4319 4319 atomic_or_32(&igb->igb_state, IGB_STALL);
4320 4320 }
4321 4321
4322 4322 return (DDI_INTR_CLAIMED);
4323 4323 }
4324 4324
4325 4325 /*
4326 4326 * igb_alloc_intrs - Allocate interrupts for the driver
4327 4327 *
4328 4328 * Normal sequence is to try MSI-X; if not sucessful, try MSI;
4329 4329 * if not successful, try Legacy.
4330 4330 * igb->intr_force can be used to force sequence to start with
4331 4331 * any of the 3 types.
4332 4332 * If MSI-X is not used, number of tx/rx rings is forced to 1.
4333 4333 */
4334 4334 static int
4335 4335 igb_alloc_intrs(igb_t *igb)
4336 4336 {
4337 4337 dev_info_t *devinfo;
4338 4338 int intr_types;
4339 4339 int rc;
4340 4340
4341 4341 devinfo = igb->dip;
4342 4342
4343 4343 /* Get supported interrupt types */
4344 4344 rc = ddi_intr_get_supported_types(devinfo, &intr_types);
4345 4345
4346 4346 if (rc != DDI_SUCCESS) {
4347 4347 igb_log(igb,
4348 4348 "Get supported interrupt types failed: %d", rc);
4349 4349 return (IGB_FAILURE);
4350 4350 }
4351 4351 IGB_DEBUGLOG_1(igb, "Supported interrupt types: %x", intr_types);
4352 4352
4353 4353 igb->intr_type = 0;
4354 4354
4355 4355 /* Install MSI-X interrupts */
4356 4356 if ((intr_types & DDI_INTR_TYPE_MSIX) &&
4357 4357 (igb->intr_force <= IGB_INTR_MSIX)) {
4358 4358 rc = igb_alloc_intr_handles(igb, DDI_INTR_TYPE_MSIX);
4359 4359
4360 4360 if (rc == IGB_SUCCESS)
4361 4361 return (IGB_SUCCESS);
4362 4362
4363 4363 igb_log(igb,
4364 4364 "Allocate MSI-X failed, trying MSI interrupts...");
4365 4365 }
4366 4366
4367 4367 /* MSI-X not used, force rings to 1 */
4368 4368 igb->num_rx_rings = 1;
4369 4369 igb->num_tx_rings = 1;
4370 4370 igb_log(igb,
4371 4371 "MSI-X not used, force rx and tx queue number to 1");
4372 4372
4373 4373 /* Install MSI interrupts */
4374 4374 if ((intr_types & DDI_INTR_TYPE_MSI) &&
4375 4375 (igb->intr_force <= IGB_INTR_MSI)) {
4376 4376 rc = igb_alloc_intr_handles(igb, DDI_INTR_TYPE_MSI);
4377 4377
4378 4378 if (rc == IGB_SUCCESS)
4379 4379 return (IGB_SUCCESS);
4380 4380
4381 4381 igb_log(igb,
4382 4382 "Allocate MSI failed, trying Legacy interrupts...");
4383 4383 }
4384 4384
4385 4385 /* Install legacy interrupts */
4386 4386 if (intr_types & DDI_INTR_TYPE_FIXED) {
4387 4387 rc = igb_alloc_intr_handles(igb, DDI_INTR_TYPE_FIXED);
4388 4388
4389 4389 if (rc == IGB_SUCCESS)
4390 4390 return (IGB_SUCCESS);
4391 4391
4392 4392 igb_log(igb,
4393 4393 "Allocate Legacy interrupts failed");
4394 4394 }
4395 4395
4396 4396 /* If none of the 3 types succeeded, return failure */
4397 4397 return (IGB_FAILURE);
4398 4398 }
4399 4399
4400 4400 /*
4401 4401 * igb_alloc_intr_handles - Allocate interrupt handles.
4402 4402 *
4403 4403 * For legacy and MSI, only 1 handle is needed. For MSI-X,
4404 4404 * if fewer than 2 handles are available, return failure.
4405 4405 * Upon success, this sets the number of Rx rings to a number that
4406 4406 * matches the handles available for Rx interrupts.
4407 4407 */
4408 4408 static int
4409 4409 igb_alloc_intr_handles(igb_t *igb, int intr_type)
4410 4410 {
4411 4411 dev_info_t *devinfo;
4412 4412 int orig, request, count, avail, actual;
4413 4413 int diff, minimum;
4414 4414 int rc;
4415 4415
4416 4416 devinfo = igb->dip;
4417 4417
4418 4418 switch (intr_type) {
4419 4419 case DDI_INTR_TYPE_FIXED:
4420 4420 request = 1; /* Request 1 legacy interrupt handle */
4421 4421 minimum = 1;
4422 4422 IGB_DEBUGLOG_0(igb, "interrupt type: legacy");
4423 4423 break;
4424 4424
4425 4425 case DDI_INTR_TYPE_MSI:
4426 4426 request = 1; /* Request 1 MSI interrupt handle */
4427 4427 minimum = 1;
4428 4428 IGB_DEBUGLOG_0(igb, "interrupt type: MSI");
4429 4429 break;
4430 4430
4431 4431 case DDI_INTR_TYPE_MSIX:
4432 4432 /*
4433 4433 * Number of vectors for the adapter is
4434 4434 * # rx rings + # tx rings
4435 4435 * One of tx vectors is for tx & other
4436 4436 */
4437 4437 request = igb->num_rx_rings + igb->num_tx_rings;
4438 4438 orig = request;
4439 4439 minimum = 2;
4440 4440 IGB_DEBUGLOG_0(igb, "interrupt type: MSI-X");
4441 4441 break;
4442 4442
4443 4443 default:
4444 4444 igb_log(igb,
4445 4445 "invalid call to igb_alloc_intr_handles(): %d\n",
4446 4446 intr_type);
4447 4447 return (IGB_FAILURE);
4448 4448 }
4449 4449 IGB_DEBUGLOG_2(igb, "interrupt handles requested: %d minimum: %d",
4450 4450 request, minimum);
4451 4451
4452 4452 /*
4453 4453 * Get number of supported interrupts
4454 4454 */
4455 4455 rc = ddi_intr_get_nintrs(devinfo, intr_type, &count);
4456 4456 if ((rc != DDI_SUCCESS) || (count < minimum)) {
4457 4457 igb_log(igb,
4458 4458 "Get supported interrupt number failed. "
4459 4459 "Return: %d, count: %d", rc, count);
4460 4460 return (IGB_FAILURE);
4461 4461 }
4462 4462 IGB_DEBUGLOG_1(igb, "interrupts supported: %d", count);
4463 4463
4464 4464 /*
4465 4465 * Get number of available interrupts
4466 4466 */
4467 4467 rc = ddi_intr_get_navail(devinfo, intr_type, &avail);
4468 4468 if ((rc != DDI_SUCCESS) || (avail < minimum)) {
4469 4469 igb_log(igb,
4470 4470 "Get available interrupt number failed. "
4471 4471 "Return: %d, available: %d", rc, avail);
4472 4472 return (IGB_FAILURE);
4473 4473 }
4474 4474 IGB_DEBUGLOG_1(igb, "interrupts available: %d", avail);
4475 4475
4476 4476 if (avail < request) {
4477 4477 igb_log(igb, "Request %d handles, %d available",
4478 4478 request, avail);
4479 4479 request = avail;
4480 4480 }
4481 4481
4482 4482 actual = 0;
4483 4483 igb->intr_cnt = 0;
4484 4484
4485 4485 /*
4486 4486 * Allocate an array of interrupt handles
4487 4487 */
4488 4488 igb->intr_size = request * sizeof (ddi_intr_handle_t);
4489 4489 igb->htable = kmem_alloc(igb->intr_size, KM_SLEEP);
4490 4490
4491 4491 rc = ddi_intr_alloc(devinfo, igb->htable, intr_type, 0,
4492 4492 request, &actual, DDI_INTR_ALLOC_NORMAL);
4493 4493 if (rc != DDI_SUCCESS) {
4494 4494 igb_log(igb, "Allocate interrupts failed. "
4495 4495 "return: %d, request: %d, actual: %d",
4496 4496 rc, request, actual);
4497 4497 goto alloc_handle_fail;
4498 4498 }
4499 4499 IGB_DEBUGLOG_1(igb, "interrupts actually allocated: %d", actual);
4500 4500
4501 4501 igb->intr_cnt = actual;
4502 4502
4503 4503 if (actual < minimum) {
4504 4504 igb_log(igb, "Insufficient interrupt handles allocated: %d",
4505 4505 actual);
4506 4506 goto alloc_handle_fail;
4507 4507 }
4508 4508
4509 4509 /*
4510 4510 * For MSI-X, actual might force us to reduce number of tx & rx rings
4511 4511 */
4512 4512 if ((intr_type == DDI_INTR_TYPE_MSIX) && (orig > actual)) {
4513 4513 diff = orig - actual;
4514 4514 if (diff < igb->num_tx_rings) {
4515 4515 igb_log(igb,
4516 4516 "MSI-X vectors force Tx queue number to %d",
4517 4517 igb->num_tx_rings - diff);
4518 4518 igb->num_tx_rings -= diff;
4519 4519 } else {
4520 4520 igb_log(igb,
4521 4521 "MSI-X vectors force Tx queue number to 1");
4522 4522 igb->num_tx_rings = 1;
4523 4523
4524 4524 igb_log(igb,
4525 4525 "MSI-X vectors force Rx queue number to %d",
4526 4526 actual - 1);
4527 4527 igb->num_rx_rings = actual - 1;
4528 4528 }
4529 4529 }
4530 4530
4531 4531 /*
4532 4532 * Get priority for first vector, assume remaining are all the same
4533 4533 */
4534 4534 rc = ddi_intr_get_pri(igb->htable[0], &igb->intr_pri);
4535 4535 if (rc != DDI_SUCCESS) {
4536 4536 igb_log(igb,
4537 4537 "Get interrupt priority failed: %d", rc);
4538 4538 goto alloc_handle_fail;
4539 4539 }
4540 4540
4541 4541 rc = ddi_intr_get_cap(igb->htable[0], &igb->intr_cap);
4542 4542 if (rc != DDI_SUCCESS) {
4543 4543 igb_log(igb,
4544 4544 "Get interrupt cap failed: %d", rc);
4545 4545 goto alloc_handle_fail;
4546 4546 }
4547 4547
4548 4548 igb->intr_type = intr_type;
4549 4549
4550 4550 return (IGB_SUCCESS);
4551 4551
4552 4552 alloc_handle_fail:
4553 4553 igb_rem_intrs(igb);
4554 4554
4555 4555 return (IGB_FAILURE);
4556 4556 }
4557 4557
4558 4558 /*
4559 4559 * igb_add_intr_handlers - Add interrupt handlers based on the interrupt type
4560 4560 *
4561 4561 * Before adding the interrupt handlers, the interrupt vectors have
4562 4562 * been allocated, and the rx/tx rings have also been allocated.
4563 4563 */
4564 4564 static int
4565 4565 igb_add_intr_handlers(igb_t *igb)
4566 4566 {
4567 4567 igb_rx_ring_t *rx_ring;
4568 4568 igb_tx_ring_t *tx_ring;
4569 4569 int vector;
4570 4570 int rc;
4571 4571 int i;
4572 4572
4573 4573 vector = 0;
4574 4574
4575 4575 switch (igb->intr_type) {
4576 4576 case DDI_INTR_TYPE_MSIX:
4577 4577 /* Add interrupt handler for tx + other */
4578 4578 tx_ring = &igb->tx_rings[0];
4579 4579 rc = ddi_intr_add_handler(igb->htable[vector],
4580 4580 (ddi_intr_handler_t *)igb_intr_tx_other,
4581 4581 (void *)igb, NULL);
4582 4582
4583 4583 if (rc != DDI_SUCCESS) {
4584 4584 igb_log(igb,
4585 4585 "Add tx/other interrupt handler failed: %d", rc);
4586 4586 return (IGB_FAILURE);
4587 4587 }
4588 4588 tx_ring->intr_vector = vector;
4589 4589 vector++;
4590 4590
4591 4591 /* Add interrupt handler for each rx ring */
4592 4592 for (i = 0; i < igb->num_rx_rings; i++) {
4593 4593 rx_ring = &igb->rx_rings[i];
4594 4594
4595 4595 rc = ddi_intr_add_handler(igb->htable[vector],
4596 4596 (ddi_intr_handler_t *)igb_intr_rx,
4597 4597 (void *)rx_ring, NULL);
4598 4598
4599 4599 if (rc != DDI_SUCCESS) {
4600 4600 igb_log(igb,
4601 4601 "Add rx interrupt handler failed. "
4602 4602 "return: %d, rx ring: %d", rc, i);
4603 4603 for (vector--; vector >= 0; vector--) {
4604 4604 (void) ddi_intr_remove_handler(
4605 4605 igb->htable[vector]);
4606 4606 }
4607 4607 return (IGB_FAILURE);
4608 4608 }
4609 4609
4610 4610 rx_ring->intr_vector = vector;
4611 4611
4612 4612 vector++;
4613 4613 }
4614 4614
4615 4615 /* Add interrupt handler for each tx ring from 2nd ring */
4616 4616 for (i = 1; i < igb->num_tx_rings; i++) {
4617 4617 tx_ring = &igb->tx_rings[i];
4618 4618
4619 4619 rc = ddi_intr_add_handler(igb->htable[vector],
4620 4620 (ddi_intr_handler_t *)igb_intr_tx,
4621 4621 (void *)tx_ring, NULL);
4622 4622
4623 4623 if (rc != DDI_SUCCESS) {
4624 4624 igb_log(igb,
4625 4625 "Add tx interrupt handler failed. "
4626 4626 "return: %d, tx ring: %d", rc, i);
4627 4627 for (vector--; vector >= 0; vector--) {
4628 4628 (void) ddi_intr_remove_handler(
4629 4629 igb->htable[vector]);
4630 4630 }
4631 4631 return (IGB_FAILURE);
4632 4632 }
4633 4633
4634 4634 tx_ring->intr_vector = vector;
4635 4635
4636 4636 vector++;
4637 4637 }
4638 4638
4639 4639 break;
4640 4640
4641 4641 case DDI_INTR_TYPE_MSI:
4642 4642 /* Add interrupt handlers for the only vector */
4643 4643 rc = ddi_intr_add_handler(igb->htable[vector],
4644 4644 (ddi_intr_handler_t *)igb_intr_msi,
4645 4645 (void *)igb, NULL);
4646 4646
4647 4647 if (rc != DDI_SUCCESS) {
4648 4648 igb_log(igb,
4649 4649 "Add MSI interrupt handler failed: %d", rc);
4650 4650 return (IGB_FAILURE);
4651 4651 }
4652 4652
4653 4653 rx_ring = &igb->rx_rings[0];
4654 4654 rx_ring->intr_vector = vector;
4655 4655
4656 4656 vector++;
4657 4657 break;
4658 4658
4659 4659 case DDI_INTR_TYPE_FIXED:
4660 4660 /* Add interrupt handlers for the only vector */
4661 4661 rc = ddi_intr_add_handler(igb->htable[vector],
4662 4662 (ddi_intr_handler_t *)igb_intr_legacy,
4663 4663 (void *)igb, NULL);
4664 4664
4665 4665 if (rc != DDI_SUCCESS) {
4666 4666 igb_log(igb,
4667 4667 "Add legacy interrupt handler failed: %d", rc);
4668 4668 return (IGB_FAILURE);
4669 4669 }
4670 4670
4671 4671 rx_ring = &igb->rx_rings[0];
4672 4672 rx_ring->intr_vector = vector;
4673 4673
4674 4674 vector++;
4675 4675 break;
4676 4676
4677 4677 default:
4678 4678 return (IGB_FAILURE);
4679 4679 }
4680 4680
4681 4681 ASSERT(vector == igb->intr_cnt);
4682 4682
4683 4683 return (IGB_SUCCESS);
4684 4684 }
4685 4685
4686 4686 /*
4687 4687 * igb_setup_msix_82575 - setup 82575 adapter to use MSI-X interrupts
4688 4688 *
4689 4689 * For each vector enabled on the adapter, Set the MSIXBM register accordingly
4690 4690 */
4691 4691 static void
4692 4692 igb_setup_msix_82575(igb_t *igb)
4693 4693 {
4694 4694 uint32_t eims = 0;
4695 4695 int i, vector;
4696 4696 struct e1000_hw *hw = &igb->hw;
4697 4697
4698 4698 /*
4699 4699 * Set vector for tx ring 0 and other causes.
4700 4700 * NOTE assumption that it is vector 0.
4701 4701 */
4702 4702 vector = 0;
4703 4703
4704 4704 igb->eims_mask = E1000_EICR_TX_QUEUE0 | E1000_EICR_OTHER;
4705 4705 E1000_WRITE_REG(hw, E1000_MSIXBM(vector), igb->eims_mask);
4706 4706 vector++;
4707 4707
4708 4708 for (i = 0; i < igb->num_rx_rings; i++) {
4709 4709 /*
4710 4710 * Set vector for each rx ring
4711 4711 */
4712 4712 eims = (E1000_EICR_RX_QUEUE0 << i);
4713 4713 E1000_WRITE_REG(hw, E1000_MSIXBM(vector), eims);
4714 4714
4715 4715 /*
4716 4716 * Accumulate bits to enable in
4717 4717 * igb_enable_adapter_interrupts_82575()
4718 4718 */
4719 4719 igb->eims_mask |= eims;
4720 4720
4721 4721 vector++;
4722 4722 }
4723 4723
4724 4724 for (i = 1; i < igb->num_tx_rings; i++) {
4725 4725 /*
4726 4726 * Set vector for each tx ring from 2nd tx ring
4727 4727 */
4728 4728 eims = (E1000_EICR_TX_QUEUE0 << i);
4729 4729 E1000_WRITE_REG(hw, E1000_MSIXBM(vector), eims);
4730 4730
4731 4731 /*
4732 4732 * Accumulate bits to enable in
4733 4733 * igb_enable_adapter_interrupts_82575()
4734 4734 */
4735 4735 igb->eims_mask |= eims;
4736 4736
4737 4737 vector++;
4738 4738 }
4739 4739
4740 4740 ASSERT(vector == igb->intr_cnt);
4741 4741
4742 4742 /*
4743 4743 * Disable IAM for ICR interrupt bits
4744 4744 */
4745 4745 E1000_WRITE_REG(hw, E1000_IAM, 0);
4746 4746 E1000_WRITE_FLUSH(hw);
4747 4747 }
4748 4748
4749 4749 /*
4750 4750 * igb_setup_msix_82576 - setup 82576 adapter to use MSI-X interrupts
4751 4751 *
4752 4752 * 82576 uses a table based method for assigning vectors. Each queue has a
4753 4753 * single entry in the table to which we write a vector number along with a
4754 4754 * "valid" bit. The entry is a single byte in a 4-byte register. Vectors
4755 4755 * take a different position in the 4-byte register depending on whether
4756 4756 * they are numbered above or below 8.
4757 4757 */
4758 4758 static void
4759 4759 igb_setup_msix_82576(igb_t *igb)
4760 4760 {
4761 4761 struct e1000_hw *hw = &igb->hw;
4762 4762 uint32_t ivar, index, vector;
4763 4763 int i;
4764 4764
4765 4765 /* must enable msi-x capability before IVAR settings */
4766 4766 E1000_WRITE_REG(hw, E1000_GPIE,
4767 4767 (E1000_GPIE_MSIX_MODE | E1000_GPIE_PBA | E1000_GPIE_NSICR));
4768 4768
4769 4769 /*
4770 4770 * Set vector for tx ring 0 and other causes.
4771 4771 * NOTE assumption that it is vector 0.
4772 4772 * This is also interdependent with installation of interrupt service
4773 4773 * routines in igb_add_intr_handlers().
4774 4774 */
4775 4775
4776 4776 /* assign "other" causes to vector 0 */
4777 4777 vector = 0;
4778 4778 ivar = ((vector | E1000_IVAR_VALID) << 8);
4779 4779 E1000_WRITE_REG(hw, E1000_IVAR_MISC, ivar);
4780 4780
4781 4781 /* assign tx ring 0 to vector 0 */
4782 4782 ivar = ((vector | E1000_IVAR_VALID) << 8);
4783 4783 E1000_WRITE_REG(hw, E1000_IVAR0, ivar);
4784 4784
4785 4785 /* prepare to enable tx & other interrupt causes */
4786 4786 igb->eims_mask = (1 << vector);
4787 4787
4788 4788 vector ++;
4789 4789 for (i = 0; i < igb->num_rx_rings; i++) {
4790 4790 /*
4791 4791 * Set vector for each rx ring
4792 4792 */
4793 4793 index = (i & 0x7);
4794 4794 ivar = E1000_READ_REG_ARRAY(hw, E1000_IVAR0, index);
4795 4795
4796 4796 if (i < 8) {
4797 4797 /* vector goes into low byte of register */
4798 4798 ivar = ivar & 0xFFFFFF00;
4799 4799 ivar |= (vector | E1000_IVAR_VALID);
4800 4800 } else {
4801 4801 /* vector goes into third byte of register */
4802 4802 ivar = ivar & 0xFF00FFFF;
4803 4803 ivar |= ((vector | E1000_IVAR_VALID) << 16);
4804 4804 }
4805 4805 E1000_WRITE_REG_ARRAY(hw, E1000_IVAR0, index, ivar);
4806 4806
4807 4807 /* Accumulate interrupt-cause bits to enable */
4808 4808 igb->eims_mask |= (1 << vector);
4809 4809
4810 4810 vector ++;
4811 4811 }
4812 4812
4813 4813 for (i = 1; i < igb->num_tx_rings; i++) {
4814 4814 /*
4815 4815 * Set vector for each tx ring from 2nd tx ring.
4816 4816 * Note assumption that tx vectors numericall follow rx vectors.
4817 4817 */
4818 4818 index = (i & 0x7);
4819 4819 ivar = E1000_READ_REG_ARRAY(hw, E1000_IVAR0, index);
4820 4820
4821 4821 if (i < 8) {
4822 4822 /* vector goes into second byte of register */
4823 4823 ivar = ivar & 0xFFFF00FF;
4824 4824 ivar |= ((vector | E1000_IVAR_VALID) << 8);
4825 4825 } else {
4826 4826 /* vector goes into fourth byte of register */
4827 4827 ivar = ivar & 0x00FFFFFF;
4828 4828 ivar |= (vector | E1000_IVAR_VALID) << 24;
4829 4829 }
4830 4830 E1000_WRITE_REG_ARRAY(hw, E1000_IVAR0, index, ivar);
4831 4831
4832 4832 /* Accumulate interrupt-cause bits to enable */
4833 4833 igb->eims_mask |= (1 << vector);
4834 4834
4835 4835 vector ++;
4836 4836 }
4837 4837
4838 4838 ASSERT(vector == igb->intr_cnt);
4839 4839 }
4840 4840
4841 4841 /*
4842 4842 * igb_setup_msix_82580 - setup 82580 adapter to use MSI-X interrupts
4843 4843 *
4844 4844 * 82580 uses same table approach at 82576 but has fewer entries. Each
4845 4845 * queue has a single entry in the table to which we write a vector number
4846 4846 * along with a "valid" bit. Vectors take a different position in the
4847 4847 * register depending on * whether * they are numbered above or below 4.
4848 4848 */
4849 4849 static void
4850 4850 igb_setup_msix_82580(igb_t *igb)
4851 4851 {
4852 4852 struct e1000_hw *hw = &igb->hw;
4853 4853 uint32_t ivar, index, vector;
4854 4854 int i;
4855 4855
4856 4856 /* must enable msi-x capability before IVAR settings */
4857 4857 E1000_WRITE_REG(hw, E1000_GPIE, (E1000_GPIE_MSIX_MODE |
4858 4858 E1000_GPIE_PBA | E1000_GPIE_NSICR | E1000_GPIE_EIAME));
4859 4859 /*
4860 4860 * Set vector for tx ring 0 and other causes.
4861 4861 * NOTE assumption that it is vector 0.
4862 4862 * This is also interdependent with installation of interrupt service
4863 4863 * routines in igb_add_intr_handlers().
4864 4864 */
4865 4865
4866 4866 /* assign "other" causes to vector 0 */
4867 4867 vector = 0;
4868 4868 ivar = ((vector | E1000_IVAR_VALID) << 8);
4869 4869 E1000_WRITE_REG(hw, E1000_IVAR_MISC, ivar);
4870 4870
4871 4871 /* assign tx ring 0 to vector 0 */
4872 4872 ivar = ((vector | E1000_IVAR_VALID) << 8);
4873 4873 E1000_WRITE_REG(hw, E1000_IVAR0, ivar);
4874 4874
4875 4875 /* prepare to enable tx & other interrupt causes */
4876 4876 igb->eims_mask = (1 << vector);
4877 4877
4878 4878 vector ++;
4879 4879
4880 4880 for (i = 0; i < igb->num_rx_rings; i++) {
4881 4881 /*
4882 4882 * Set vector for each rx ring
4883 4883 */
4884 4884 index = (i >> 1);
4885 4885 ivar = E1000_READ_REG_ARRAY(hw, E1000_IVAR0, index);
4886 4886
4887 4887 if (i & 1) {
4888 4888 /* vector goes into third byte of register */
4889 4889 ivar = ivar & 0xFF00FFFF;
4890 4890 ivar |= ((vector | E1000_IVAR_VALID) << 16);
4891 4891 } else {
4892 4892 /* vector goes into low byte of register */
4893 4893 ivar = ivar & 0xFFFFFF00;
4894 4894 ivar |= (vector | E1000_IVAR_VALID);
4895 4895 }
4896 4896 E1000_WRITE_REG_ARRAY(hw, E1000_IVAR0, index, ivar);
4897 4897
4898 4898 /* Accumulate interrupt-cause bits to enable */
4899 4899 igb->eims_mask |= (1 << vector);
4900 4900
4901 4901 vector ++;
4902 4902 }
4903 4903
4904 4904 for (i = 1; i < igb->num_tx_rings; i++) {
4905 4905 /*
4906 4906 * Set vector for each tx ring from 2nd tx ring.
4907 4907 * Note assumption that tx vectors numericall follow rx vectors.
4908 4908 */
4909 4909 index = (i >> 1);
4910 4910 ivar = E1000_READ_REG_ARRAY(hw, E1000_IVAR0, index);
4911 4911
4912 4912 if (i & 1) {
4913 4913 /* vector goes into high byte of register */
4914 4914 ivar = ivar & 0x00FFFFFF;
4915 4915 ivar |= ((vector | E1000_IVAR_VALID) << 24);
4916 4916 } else {
4917 4917 /* vector goes into second byte of register */
4918 4918 ivar = ivar & 0xFFFF00FF;
4919 4919 ivar |= (vector | E1000_IVAR_VALID) << 8;
4920 4920 }
4921 4921 E1000_WRITE_REG_ARRAY(hw, E1000_IVAR0, index, ivar);
4922 4922
4923 4923 /* Accumulate interrupt-cause bits to enable */
4924 4924 igb->eims_mask |= (1 << vector);
4925 4925
4926 4926 vector ++;
4927 4927 }
4928 4928 ASSERT(vector == igb->intr_cnt);
4929 4929 }
4930 4930
4931 4931 /*
4932 4932 * igb_rem_intr_handlers - remove the interrupt handlers
4933 4933 */
4934 4934 static void
4935 4935 igb_rem_intr_handlers(igb_t *igb)
4936 4936 {
4937 4937 int i;
4938 4938 int rc;
4939 4939
4940 4940 for (i = 0; i < igb->intr_cnt; i++) {
4941 4941 rc = ddi_intr_remove_handler(igb->htable[i]);
4942 4942 if (rc != DDI_SUCCESS) {
4943 4943 IGB_DEBUGLOG_1(igb,
4944 4944 "Remove intr handler failed: %d", rc);
4945 4945 }
4946 4946 }
4947 4947 }
4948 4948
4949 4949 /*
4950 4950 * igb_rem_intrs - remove the allocated interrupts
4951 4951 */
4952 4952 static void
4953 4953 igb_rem_intrs(igb_t *igb)
4954 4954 {
4955 4955 int i;
4956 4956 int rc;
4957 4957
4958 4958 for (i = 0; i < igb->intr_cnt; i++) {
4959 4959 rc = ddi_intr_free(igb->htable[i]);
4960 4960 if (rc != DDI_SUCCESS) {
4961 4961 IGB_DEBUGLOG_1(igb,
4962 4962 "Free intr failed: %d", rc);
4963 4963 }
4964 4964 }
4965 4965
4966 4966 kmem_free(igb->htable, igb->intr_size);
4967 4967 igb->htable = NULL;
4968 4968 }
4969 4969
4970 4970 /*
4971 4971 * igb_enable_intrs - enable all the ddi interrupts
4972 4972 */
4973 4973 static int
4974 4974 igb_enable_intrs(igb_t *igb)
4975 4975 {
4976 4976 int i;
4977 4977 int rc;
4978 4978
4979 4979 /* Enable interrupts */
4980 4980 if (igb->intr_cap & DDI_INTR_FLAG_BLOCK) {
4981 4981 /* Call ddi_intr_block_enable() for MSI */
4982 4982 rc = ddi_intr_block_enable(igb->htable, igb->intr_cnt);
4983 4983 if (rc != DDI_SUCCESS) {
4984 4984 igb_log(igb,
4985 4985 "Enable block intr failed: %d", rc);
4986 4986 return (IGB_FAILURE);
4987 4987 }
4988 4988 } else {
4989 4989 /* Call ddi_intr_enable() for Legacy/MSI non block enable */
4990 4990 for (i = 0; i < igb->intr_cnt; i++) {
4991 4991 rc = ddi_intr_enable(igb->htable[i]);
4992 4992 if (rc != DDI_SUCCESS) {
4993 4993 igb_log(igb,
4994 4994 "Enable intr failed: %d", rc);
4995 4995 return (IGB_FAILURE);
4996 4996 }
4997 4997 }
4998 4998 }
4999 4999
5000 5000 return (IGB_SUCCESS);
5001 5001 }
5002 5002
5003 5003 /*
5004 5004 * igb_disable_intrs - disable all the ddi interrupts
5005 5005 */
5006 5006 static int
5007 5007 igb_disable_intrs(igb_t *igb)
5008 5008 {
5009 5009 int i;
5010 5010 int rc;
5011 5011
5012 5012 /* Disable all interrupts */
5013 5013 if (igb->intr_cap & DDI_INTR_FLAG_BLOCK) {
5014 5014 rc = ddi_intr_block_disable(igb->htable, igb->intr_cnt);
5015 5015 if (rc != DDI_SUCCESS) {
5016 5016 igb_log(igb,
5017 5017 "Disable block intr failed: %d", rc);
5018 5018 return (IGB_FAILURE);
5019 5019 }
5020 5020 } else {
5021 5021 for (i = 0; i < igb->intr_cnt; i++) {
5022 5022 rc = ddi_intr_disable(igb->htable[i]);
5023 5023 if (rc != DDI_SUCCESS) {
5024 5024 igb_log(igb,
5025 5025 "Disable intr failed: %d", rc);
5026 5026 return (IGB_FAILURE);
5027 5027 }
5028 5028 }
5029 5029 }
5030 5030
5031 5031 return (IGB_SUCCESS);
5032 5032 }
5033 5033
5034 5034 /*
5035 5035 * igb_get_phy_state - Get and save the parameters read from PHY registers
5036 5036 */
5037 5037 static void
5038 5038 igb_get_phy_state(igb_t *igb)
5039 5039 {
5040 5040 struct e1000_hw *hw = &igb->hw;
5041 5041 uint16_t phy_ctrl;
5042 5042 uint16_t phy_status;
5043 5043 uint16_t phy_an_adv;
5044 5044 uint16_t phy_an_exp;
5045 5045 uint16_t phy_ext_status;
5046 5046 uint16_t phy_1000t_ctrl;
5047 5047 uint16_t phy_1000t_status;
5048 5048 uint16_t phy_lp_able;
5049 5049
5050 5050 ASSERT(mutex_owned(&igb->gen_lock));
5051 5051
5052 5052 if (hw->phy.media_type == e1000_media_type_copper) {
5053 5053 (void) e1000_read_phy_reg(hw, PHY_CONTROL, &phy_ctrl);
5054 5054 (void) e1000_read_phy_reg(hw, PHY_STATUS, &phy_status);
5055 5055 (void) e1000_read_phy_reg(hw, PHY_AUTONEG_ADV, &phy_an_adv);
5056 5056 (void) e1000_read_phy_reg(hw, PHY_AUTONEG_EXP, &phy_an_exp);
5057 5057 (void) e1000_read_phy_reg(hw, PHY_EXT_STATUS, &phy_ext_status);
5058 5058 (void) e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_1000t_ctrl);
5059 5059 (void) e1000_read_phy_reg(hw,
5060 5060 PHY_1000T_STATUS, &phy_1000t_status);
5061 5061 (void) e1000_read_phy_reg(hw, PHY_LP_ABILITY, &phy_lp_able);
5062 5062
5063 5063 igb->param_autoneg_cap =
5064 5064 (phy_status & MII_SR_AUTONEG_CAPS) ? 1 : 0;
5065 5065 igb->param_pause_cap =
5066 5066 (phy_an_adv & NWAY_AR_PAUSE) ? 1 : 0;
5067 5067 igb->param_asym_pause_cap =
5068 5068 (phy_an_adv & NWAY_AR_ASM_DIR) ? 1 : 0;
5069 5069 igb->param_1000fdx_cap =
5070 5070 ((phy_ext_status & IEEE_ESR_1000T_FD_CAPS) ||
5071 5071 (phy_ext_status & IEEE_ESR_1000X_FD_CAPS)) ? 1 : 0;
5072 5072 igb->param_1000hdx_cap =
5073 5073 ((phy_ext_status & IEEE_ESR_1000T_HD_CAPS) ||
5074 5074 (phy_ext_status & IEEE_ESR_1000X_HD_CAPS)) ? 1 : 0;
5075 5075 igb->param_100t4_cap =
5076 5076 (phy_status & MII_SR_100T4_CAPS) ? 1 : 0;
5077 5077 igb->param_100fdx_cap = ((phy_status & MII_SR_100X_FD_CAPS) ||
5078 5078 (phy_status & MII_SR_100T2_FD_CAPS)) ? 1 : 0;
5079 5079 igb->param_100hdx_cap = ((phy_status & MII_SR_100X_HD_CAPS) ||
5080 5080 (phy_status & MII_SR_100T2_HD_CAPS)) ? 1 : 0;
5081 5081 igb->param_10fdx_cap =
5082 5082 (phy_status & MII_SR_10T_FD_CAPS) ? 1 : 0;
5083 5083 igb->param_10hdx_cap =
5084 5084 (phy_status & MII_SR_10T_HD_CAPS) ? 1 : 0;
5085 5085 igb->param_rem_fault =
5086 5086 (phy_status & MII_SR_REMOTE_FAULT) ? 1 : 0;
5087 5087
5088 5088 igb->param_adv_autoneg_cap = hw->mac.autoneg;
5089 5089 igb->param_adv_pause_cap =
5090 5090 (phy_an_adv & NWAY_AR_PAUSE) ? 1 : 0;
5091 5091 igb->param_adv_asym_pause_cap =
5092 5092 (phy_an_adv & NWAY_AR_ASM_DIR) ? 1 : 0;
5093 5093 igb->param_adv_1000hdx_cap =
5094 5094 (phy_1000t_ctrl & CR_1000T_HD_CAPS) ? 1 : 0;
5095 5095 igb->param_adv_100t4_cap =
5096 5096 (phy_an_adv & NWAY_AR_100T4_CAPS) ? 1 : 0;
5097 5097 igb->param_adv_rem_fault =
5098 5098 (phy_an_adv & NWAY_AR_REMOTE_FAULT) ? 1 : 0;
5099 5099 if (igb->param_adv_autoneg_cap == 1) {
5100 5100 igb->param_adv_1000fdx_cap =
5101 5101 (phy_1000t_ctrl & CR_1000T_FD_CAPS) ? 1 : 0;
5102 5102 igb->param_adv_100fdx_cap =
5103 5103 (phy_an_adv & NWAY_AR_100TX_FD_CAPS) ? 1 : 0;
5104 5104 igb->param_adv_100hdx_cap =
5105 5105 (phy_an_adv & NWAY_AR_100TX_HD_CAPS) ? 1 : 0;
5106 5106 igb->param_adv_10fdx_cap =
5107 5107 (phy_an_adv & NWAY_AR_10T_FD_CAPS) ? 1 : 0;
5108 5108 igb->param_adv_10hdx_cap =
5109 5109 (phy_an_adv & NWAY_AR_10T_HD_CAPS) ? 1 : 0;
5110 5110 }
5111 5111
5112 5112 igb->param_lp_autoneg_cap =
5113 5113 (phy_an_exp & NWAY_ER_LP_NWAY_CAPS) ? 1 : 0;
5114 5114 igb->param_lp_pause_cap =
5115 5115 (phy_lp_able & NWAY_LPAR_PAUSE) ? 1 : 0;
5116 5116 igb->param_lp_asym_pause_cap =
5117 5117 (phy_lp_able & NWAY_LPAR_ASM_DIR) ? 1 : 0;
5118 5118 igb->param_lp_1000fdx_cap =
5119 5119 (phy_1000t_status & SR_1000T_LP_FD_CAPS) ? 1 : 0;
5120 5120 igb->param_lp_1000hdx_cap =
5121 5121 (phy_1000t_status & SR_1000T_LP_HD_CAPS) ? 1 : 0;
5122 5122 igb->param_lp_100t4_cap =
5123 5123 (phy_lp_able & NWAY_LPAR_100T4_CAPS) ? 1 : 0;
5124 5124 igb->param_lp_100fdx_cap =
5125 5125 (phy_lp_able & NWAY_LPAR_100TX_FD_CAPS) ? 1 : 0;
5126 5126 igb->param_lp_100hdx_cap =
5127 5127 (phy_lp_able & NWAY_LPAR_100TX_HD_CAPS) ? 1 : 0;
5128 5128 igb->param_lp_10fdx_cap =
5129 5129 (phy_lp_able & NWAY_LPAR_10T_FD_CAPS) ? 1 : 0;
5130 5130 igb->param_lp_10hdx_cap =
5131 5131 (phy_lp_able & NWAY_LPAR_10T_HD_CAPS) ? 1 : 0;
5132 5132 igb->param_lp_rem_fault =
5133 5133 (phy_lp_able & NWAY_LPAR_REMOTE_FAULT) ? 1 : 0;
5134 5134 } else {
5135 5135 /*
5136 5136 * 1Gig Fiber adapter only offers 1Gig Full Duplex.
5137 5137 */
5138 5138 igb->param_autoneg_cap = 0;
5139 5139 igb->param_pause_cap = 1;
5140 5140 igb->param_asym_pause_cap = 1;
5141 5141 igb->param_1000fdx_cap = 1;
5142 5142 igb->param_1000hdx_cap = 0;
5143 5143 igb->param_100t4_cap = 0;
5144 5144 igb->param_100fdx_cap = 0;
5145 5145 igb->param_100hdx_cap = 0;
5146 5146 igb->param_10fdx_cap = 0;
5147 5147 igb->param_10hdx_cap = 0;
5148 5148
5149 5149 igb->param_adv_autoneg_cap = 0;
5150 5150 igb->param_adv_pause_cap = 1;
5151 5151 igb->param_adv_asym_pause_cap = 1;
5152 5152 igb->param_adv_1000fdx_cap = 1;
5153 5153 igb->param_adv_1000hdx_cap = 0;
5154 5154 igb->param_adv_100t4_cap = 0;
5155 5155 igb->param_adv_100fdx_cap = 0;
5156 5156 igb->param_adv_100hdx_cap = 0;
5157 5157 igb->param_adv_10fdx_cap = 0;
5158 5158 igb->param_adv_10hdx_cap = 0;
5159 5159
5160 5160 igb->param_lp_autoneg_cap = 0;
5161 5161 igb->param_lp_pause_cap = 0;
5162 5162 igb->param_lp_asym_pause_cap = 0;
5163 5163 igb->param_lp_1000fdx_cap = 0;
5164 5164 igb->param_lp_1000hdx_cap = 0;
5165 5165 igb->param_lp_100t4_cap = 0;
5166 5166 igb->param_lp_100fdx_cap = 0;
5167 5167 igb->param_lp_100hdx_cap = 0;
5168 5168 igb->param_lp_10fdx_cap = 0;
5169 5169 igb->param_lp_10hdx_cap = 0;
5170 5170 igb->param_lp_rem_fault = 0;
5171 5171 }
5172 5172 }
5173 5173
5174 5174 /*
5175 5175 * synchronize the adv* and en* parameters.
5176 5176 *
5177 5177 * See comments in <sys/dld.h> for details of the *_en_*
5178 5178 * parameters. The usage of ndd for setting adv parameters will
5179 5179 * synchronize all the en parameters with the e1000g parameters,
5180 5180 * implicitly disabling any settings made via dladm.
5181 5181 */
5182 5182 static void
5183 5183 igb_param_sync(igb_t *igb)
5184 5184 {
5185 5185 igb->param_en_1000fdx_cap = igb->param_adv_1000fdx_cap;
5186 5186 igb->param_en_1000hdx_cap = igb->param_adv_1000hdx_cap;
5187 5187 igb->param_en_100t4_cap = igb->param_adv_100t4_cap;
5188 5188 igb->param_en_100fdx_cap = igb->param_adv_100fdx_cap;
5189 5189 igb->param_en_100hdx_cap = igb->param_adv_100hdx_cap;
5190 5190 igb->param_en_10fdx_cap = igb->param_adv_10fdx_cap;
5191 5191 igb->param_en_10hdx_cap = igb->param_adv_10hdx_cap;
5192 5192 }
5193 5193
5194 5194 /*
5195 5195 * igb_get_driver_control
5196 5196 */
5197 5197 static void
5198 5198 igb_get_driver_control(struct e1000_hw *hw)
5199 5199 {
5200 5200 uint32_t ctrl_ext;
5201 5201
5202 5202 /* Notify firmware that driver is in control of device */
5203 5203 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
5204 5204 ctrl_ext |= E1000_CTRL_EXT_DRV_LOAD;
5205 5205 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
5206 5206 }
5207 5207
5208 5208 /*
5209 5209 * igb_release_driver_control
5210 5210 */
5211 5211 static void
5212 5212 igb_release_driver_control(struct e1000_hw *hw)
5213 5213 {
5214 5214 uint32_t ctrl_ext;
5215 5215
5216 5216 /* Notify firmware that driver is no longer in control of device */
5217 5217 ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
5218 5218 ctrl_ext &= ~E1000_CTRL_EXT_DRV_LOAD;
5219 5219 E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
5220 5220 }
5221 5221
5222 5222 /*
5223 5223 * igb_atomic_reserve - Atomic decrease operation
5224 5224 */
5225 5225 int
5226 5226 igb_atomic_reserve(uint32_t *count_p, uint32_t n)
5227 5227 {
5228 5228 uint32_t oldval;
5229 5229 uint32_t newval;
5230 5230
5231 5231 /* ATOMICALLY */
5232 5232 do {
5233 5233 oldval = *count_p;
5234 5234 if (oldval < n)
5235 5235 return (-1);
5236 5236 newval = oldval - n;
5237 5237 } while (atomic_cas_32(count_p, oldval, newval) != oldval);
5238 5238
5239 5239 return (newval);
5240 5240 }
5241 5241
5242 5242 /*
5243 5243 * FMA support
5244 5244 */
5245 5245
5246 5246 int
5247 5247 igb_check_acc_handle(ddi_acc_handle_t handle)
5248 5248 {
5249 5249 ddi_fm_error_t de;
5250 5250
5251 5251 ddi_fm_acc_err_get(handle, &de, DDI_FME_VERSION);
5252 5252 ddi_fm_acc_err_clear(handle, DDI_FME_VERSION);
5253 5253 return (de.fme_status);
5254 5254 }
5255 5255
5256 5256 int
5257 5257 igb_check_dma_handle(ddi_dma_handle_t handle)
5258 5258 {
5259 5259 ddi_fm_error_t de;
5260 5260
5261 5261 ddi_fm_dma_err_get(handle, &de, DDI_FME_VERSION);
5262 5262 return (de.fme_status);
5263 5263 }
5264 5264
5265 5265 /*
5266 5266 * The IO fault service error handling callback function
5267 5267 */
5268 5268 /*ARGSUSED*/
5269 5269 static int
5270 5270 igb_fm_error_cb(dev_info_t *dip, ddi_fm_error_t *err, const void *impl_data)
5271 5271 {
5272 5272 /*
5273 5273 * as the driver can always deal with an error in any dma or
5274 5274 * access handle, we can just return the fme_status value.
5275 5275 */
5276 5276 pci_ereport_post(dip, err, NULL);
5277 5277 return (err->fme_status);
5278 5278 }
5279 5279
5280 5280 static void
5281 5281 igb_fm_init(igb_t *igb)
5282 5282 {
5283 5283 ddi_iblock_cookie_t iblk;
5284 5284 int fma_dma_flag;
5285 5285
5286 5286 /* Only register with IO Fault Services if we have some capability */
5287 5287 if (igb->fm_capabilities & DDI_FM_ACCCHK_CAPABLE) {
5288 5288 igb_regs_acc_attr.devacc_attr_access = DDI_FLAGERR_ACC;
5289 5289 } else {
5290 5290 igb_regs_acc_attr.devacc_attr_access = DDI_DEFAULT_ACC;
5291 5291 }
5292 5292
5293 5293 if (igb->fm_capabilities & DDI_FM_DMACHK_CAPABLE) {
5294 5294 fma_dma_flag = 1;
5295 5295 } else {
5296 5296 fma_dma_flag = 0;
5297 5297 }
5298 5298
5299 5299 (void) igb_set_fma_flags(fma_dma_flag);
5300 5300
5301 5301 if (igb->fm_capabilities) {
5302 5302
5303 5303 /* Register capabilities with IO Fault Services */
5304 5304 ddi_fm_init(igb->dip, &igb->fm_capabilities, &iblk);
5305 5305
5306 5306 /*
5307 5307 * Initialize pci ereport capabilities if ereport capable
5308 5308 */
5309 5309 if (DDI_FM_EREPORT_CAP(igb->fm_capabilities) ||
5310 5310 DDI_FM_ERRCB_CAP(igb->fm_capabilities))
5311 5311 pci_ereport_setup(igb->dip);
5312 5312
5313 5313 /*
5314 5314 * Register error callback if error callback capable
5315 5315 */
5316 5316 if (DDI_FM_ERRCB_CAP(igb->fm_capabilities))
5317 5317 ddi_fm_handler_register(igb->dip,
5318 5318 igb_fm_error_cb, (void*) igb);
5319 5319 }
5320 5320 }
5321 5321
5322 5322 static void
5323 5323 igb_fm_fini(igb_t *igb)
5324 5324 {
5325 5325 /* Only unregister FMA capabilities if we registered some */
5326 5326 if (igb->fm_capabilities) {
5327 5327
5328 5328 /*
5329 5329 * Release any resources allocated by pci_ereport_setup()
5330 5330 */
5331 5331 if (DDI_FM_EREPORT_CAP(igb->fm_capabilities) ||
5332 5332 DDI_FM_ERRCB_CAP(igb->fm_capabilities))
5333 5333 pci_ereport_teardown(igb->dip);
5334 5334
5335 5335 /*
5336 5336 * Un-register error callback if error callback capable
5337 5337 */
5338 5338 if (DDI_FM_ERRCB_CAP(igb->fm_capabilities))
5339 5339 ddi_fm_handler_unregister(igb->dip);
5340 5340
5341 5341 /* Unregister from IO Fault Services */
5342 5342 ddi_fm_fini(igb->dip);
5343 5343 }
5344 5344 }
5345 5345
5346 5346 void
5347 5347 igb_fm_ereport(igb_t *igb, char *detail)
5348 5348 {
5349 5349 uint64_t ena;
5350 5350 char buf[FM_MAX_CLASS];
5351 5351
5352 5352 (void) snprintf(buf, FM_MAX_CLASS, "%s.%s", DDI_FM_DEVICE, detail);
5353 5353 ena = fm_ena_generate(0, FM_ENA_FMT1);
5354 5354 if (DDI_FM_EREPORT_CAP(igb->fm_capabilities)) {
5355 5355 ddi_fm_ereport_post(igb->dip, buf, ena, DDI_NOSLEEP,
5356 5356 FM_VERSION, DATA_TYPE_UINT8, FM_EREPORT_VERS0, NULL);
5357 5357 }
5358 5358 }
↓ open down ↓ |
1900 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX