2 * This file is provided under a CDDLv1 license. When using or
3 * redistributing this file, you may do so under this license.
4 * In redistributing this file this license must be included
5 * and no other modification of this header file is permitted.
9 * Copyright(c) 1999 - 2009 Intel Corporation. All rights reserved.
11 * The contents of this file are subject to the terms of Version
12 * 1.0 of the Common Development and Distribution License (the "License").
14 * You should have received a copy of the License with this software.
15 * You can obtain a copy of the License at
16 * http://www.opensolaris.org/os/licensing.
17 * See the License for the specific language governing permissions
18 * and limitations under the License.
22 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
26 * Copyright 2012 DEY Storage Systems, Inc. All rights reserved.
27 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
28 * Copyright (c) 2015, Joyent, Inc.
32 * **********************************************************************
38 * This file contains the interface routines for the solaris OS. *
39 * It has all DDI entry point routines and GLD entry point routines. *
41 * This file also contains routines that take care of initialization *
42 * uninit routine and interrupt routine. *
44 * **********************************************************************
49 #include "e1000g_sw.h"
50 #include "e1000g_debug.h"
52 static char ident
[] = "Intel PRO/1000 Ethernet";
53 /* LINTED E_STATIC_UNUSED */
54 static char e1000g_version
[] = "Driver Ver. 5.3.24";
57 * Proto types for DDI entry points
59 static int e1000g_attach(dev_info_t
*, ddi_attach_cmd_t
);
60 static int e1000g_detach(dev_info_t
*, ddi_detach_cmd_t
);
61 static int e1000g_quiesce(dev_info_t
*);
64 * init and intr routines prototype
66 static int e1000g_resume(dev_info_t
*);
67 static int e1000g_suspend(dev_info_t
*);
68 static uint_t
e1000g_intr_pciexpress(caddr_t
);
69 static uint_t
e1000g_intr(caddr_t
);
70 static void e1000g_intr_work(struct e1000g
*, uint32_t);
71 #pragma inline(e1000g_intr_work)
72 static int e1000g_init(struct e1000g
*);
73 static int e1000g_start(struct e1000g
*, boolean_t
);
74 static void e1000g_stop(struct e1000g
*, boolean_t
);
75 static int e1000g_m_start(void *);
76 static void e1000g_m_stop(void *);
77 static int e1000g_m_promisc(void *, boolean_t
);
78 static boolean_t
e1000g_m_getcapab(void *, mac_capab_t
, void *);
79 static int e1000g_m_multicst(void *, boolean_t
, const uint8_t *);
80 static void e1000g_m_ioctl(void *, queue_t
*, mblk_t
*);
81 static int e1000g_m_setprop(void *, const char *, mac_prop_id_t
,
82 uint_t
, const void *);
83 static int e1000g_m_getprop(void *, const char *, mac_prop_id_t
,
85 static void e1000g_m_propinfo(void *, const char *, mac_prop_id_t
,
86 mac_prop_info_handle_t
);
87 static int e1000g_set_priv_prop(struct e1000g
*, const char *, uint_t
,
89 static int e1000g_get_priv_prop(struct e1000g
*, const char *, uint_t
, void *);
90 static void e1000g_init_locks(struct e1000g
*);
91 static void e1000g_destroy_locks(struct e1000g
*);
92 static int e1000g_identify_hardware(struct e1000g
*);
93 static int e1000g_regs_map(struct e1000g
*);
94 static int e1000g_set_driver_params(struct e1000g
*);
95 static void e1000g_set_bufsize(struct e1000g
*);
96 static int e1000g_register_mac(struct e1000g
*);
97 static boolean_t
e1000g_rx_drain(struct e1000g
*);
98 static boolean_t
e1000g_tx_drain(struct e1000g
*);
99 static void e1000g_init_unicst(struct e1000g
*);
100 static int e1000g_unicst_set(struct e1000g
*, const uint8_t *, int);
101 static int e1000g_alloc_rx_data(struct e1000g
*);
102 static void e1000g_release_multicast(struct e1000g
*);
103 static void e1000g_pch_limits(struct e1000g
*);
104 static uint32_t e1000g_mtu2maxframe(uint32_t);
109 static boolean_t
e1000g_reset_adapter(struct e1000g
*);
110 static void e1000g_tx_clean(struct e1000g
*);
111 static void e1000g_rx_clean(struct e1000g
*);
112 static void e1000g_link_timer(void *);
113 static void e1000g_local_timer(void *);
114 static boolean_t
e1000g_link_check(struct e1000g
*);
115 static boolean_t
e1000g_stall_check(struct e1000g
*);
116 static void e1000g_smartspeed(struct e1000g
*);
117 static void e1000g_get_conf(struct e1000g
*);
118 static boolean_t
e1000g_get_prop(struct e1000g
*, char *, int, int, int,
120 static void enable_watchdog_timer(struct e1000g
*);
121 static void disable_watchdog_timer(struct e1000g
*);
122 static void start_watchdog_timer(struct e1000g
*);
123 static void restart_watchdog_timer(struct e1000g
*);
124 static void stop_watchdog_timer(struct e1000g
*);
125 static void stop_link_timer(struct e1000g
*);
126 static void stop_82547_timer(e1000g_tx_ring_t
*);
127 static void e1000g_force_speed_duplex(struct e1000g
*);
128 static void e1000g_setup_max_mtu(struct e1000g
*);
129 static void e1000g_get_max_frame_size(struct e1000g
*);
130 static boolean_t
is_valid_mac_addr(uint8_t *);
131 static void e1000g_unattach(dev_info_t
*, struct e1000g
*);
132 static int e1000g_get_bar_info(dev_info_t
*, int, bar_info_t
*);
134 static void e1000g_ioc_peek_reg(struct e1000g
*, e1000g_peekpoke_t
*);
135 static void e1000g_ioc_poke_reg(struct e1000g
*, e1000g_peekpoke_t
*);
136 static void e1000g_ioc_peek_mem(struct e1000g
*, e1000g_peekpoke_t
*);
137 static void e1000g_ioc_poke_mem(struct e1000g
*, e1000g_peekpoke_t
*);
138 static enum ioc_reply
e1000g_pp_ioctl(struct e1000g
*,
139 struct iocblk
*, mblk_t
*);
141 static enum ioc_reply
e1000g_loopback_ioctl(struct e1000g
*,
142 struct iocblk
*, mblk_t
*);
143 static boolean_t
e1000g_check_loopback_support(struct e1000_hw
*);
144 static boolean_t
e1000g_set_loopback_mode(struct e1000g
*, uint32_t);
145 static void e1000g_set_internal_loopback(struct e1000g
*);
146 static void e1000g_set_external_loopback_1000(struct e1000g
*);
147 static void e1000g_set_external_loopback_100(struct e1000g
*);
148 static void e1000g_set_external_loopback_10(struct e1000g
*);
149 static int e1000g_add_intrs(struct e1000g
*);
150 static int e1000g_intr_add(struct e1000g
*, int);
151 static int e1000g_rem_intrs(struct e1000g
*);
152 static int e1000g_enable_intrs(struct e1000g
*);
153 static int e1000g_disable_intrs(struct e1000g
*);
154 static boolean_t
e1000g_link_up(struct e1000g
*);
156 static boolean_t
e1000g_find_mac_address(struct e1000g
*);
158 static void e1000g_get_phy_state(struct e1000g
*);
159 static int e1000g_fm_error_cb(dev_info_t
*dip
, ddi_fm_error_t
*err
,
160 const void *impl_data
);
161 static void e1000g_fm_init(struct e1000g
*Adapter
);
162 static void e1000g_fm_fini(struct e1000g
*Adapter
);
163 static void e1000g_param_sync(struct e1000g
*);
164 static void e1000g_get_driver_control(struct e1000_hw
*);
165 static void e1000g_release_driver_control(struct e1000_hw
*);
166 static void e1000g_restore_promisc(struct e1000g
*Adapter
);
168 char *e1000g_priv_props
[] = {
169 "_tx_bcopy_threshold",
170 "_tx_interrupt_enable",
172 "_tx_intr_abs_delay",
173 "_rx_bcopy_threshold",
174 "_max_num_rcv_packets",
176 "_rx_intr_abs_delay",
177 "_intr_throttling_rate",
180 "_adv_asym_pause_cap",
184 static struct cb_ops cb_ws_ops
= {
185 nulldev
, /* cb_open */
186 nulldev
, /* cb_close */
187 nodev
, /* cb_strategy */
188 nodev
, /* cb_print */
191 nodev
, /* cb_write */
192 nodev
, /* cb_ioctl */
193 nodev
, /* cb_devmap */
195 nodev
, /* cb_segmap */
196 nochpoll
, /* cb_chpoll */
197 ddi_prop_op
, /* cb_prop_op */
198 NULL
, /* cb_stream */
199 D_MP
| D_HOTPLUG
, /* cb_flag */
201 nodev
, /* cb_aread */
202 nodev
/* cb_awrite */
205 static struct dev_ops ws_ops
= {
206 DEVO_REV
, /* devo_rev */
208 NULL
, /* devo_getinfo */
209 nulldev
, /* devo_identify */
210 nulldev
, /* devo_probe */
211 e1000g_attach
, /* devo_attach */
212 e1000g_detach
, /* devo_detach */
213 nodev
, /* devo_reset */
214 &cb_ws_ops
, /* devo_cb_ops */
215 NULL
, /* devo_bus_ops */
216 ddi_power
, /* devo_power */
217 e1000g_quiesce
/* devo_quiesce */
220 static struct modldrv modldrv
= {
221 &mod_driverops
, /* Type of module. This one is a driver */
222 ident
, /* Discription string */
223 &ws_ops
, /* driver ops */
226 static struct modlinkage modlinkage
= {
227 MODREV_1
, &modldrv
, NULL
230 /* Access attributes for register mapping */
231 static ddi_device_acc_attr_t e1000g_regs_acc_attr
= {
233 DDI_STRUCTURE_LE_ACC
,
238 #define E1000G_M_CALLBACK_FLAGS \
239 (MC_IOCTL | MC_GETCAPAB | MC_SETPROP | MC_GETPROP | MC_PROPINFO)
241 static mac_callbacks_t e1000g_m_callbacks
= {
242 E1000G_M_CALLBACK_FLAGS
,
263 uint32_t e1000g_jumbo_mtu
= MAXIMUM_MTU_9K
;
264 uint32_t e1000g_mblks_pending
= 0;
266 * Workaround for Dynamic Reconfiguration support, for x86 platform only.
267 * Here we maintain a private dev_info list if e1000g_force_detach is
268 * enabled. If we force the driver to detach while there are still some
269 * rx buffers retained in the upper layer, we have to keep a copy of the
270 * dev_info. In some cases (Dynamic Reconfiguration), the dev_info data
271 * structure will be freed after the driver is detached. However when we
272 * finally free those rx buffers released by the upper layer, we need to
273 * refer to the dev_info to free the dma buffers. So we save a copy of
274 * the dev_info for this purpose. On x86 platform, we assume this copy
275 * of dev_info is always valid, but on SPARC platform, it could be invalid
276 * after the system board level DR operation. For this reason, the global
277 * variable e1000g_force_detach must be B_FALSE on SPARC platform.
280 boolean_t e1000g_force_detach
= B_FALSE
;
282 boolean_t e1000g_force_detach
= B_TRUE
;
284 private_devi_list_t
*e1000g_private_devi_list
= NULL
;
287 * The mutex e1000g_rx_detach_lock is defined to protect the processing of
288 * the private dev_info list, and to serialize the processing of rx buffer
289 * freeing and rx buffer recycling.
291 kmutex_t e1000g_rx_detach_lock
;
293 * The rwlock e1000g_dma_type_lock is defined to protect the global flag
294 * e1000g_dma_type. For SPARC, the initial value of the flag is "USE_DVMA".
295 * If there are many e1000g instances, the system may run out of DVMA
296 * resources during the initialization of the instances, then the flag will
297 * be changed to "USE_DMA". Because different e1000g instances are initialized
298 * in parallel, we need to use this lock to protect the flag.
300 krwlock_t e1000g_dma_type_lock
;
303 * The 82546 chipset is a dual-port device, both the ports share one eeprom.
304 * Based on the information from Intel, the 82546 chipset has some hardware
305 * problem. When one port is being reset and the other port is trying to
306 * access the eeprom, it could cause system hang or panic. To workaround this
307 * hardware problem, we use a global mutex to prevent such operations from
308 * happening simultaneously on different instances. This workaround is applied
309 * to all the devices supported by this driver.
311 kmutex_t e1000g_nvm_lock
;
314 * Loadable module configuration entry points for the driver
318 * _init - module initialization
325 mac_init_ops(&ws_ops
, WSNAME
);
326 status
= mod_install(&modlinkage
);
327 if (status
!= DDI_SUCCESS
)
328 mac_fini_ops(&ws_ops
);
330 mutex_init(&e1000g_rx_detach_lock
, NULL
, MUTEX_DRIVER
, NULL
);
331 rw_init(&e1000g_dma_type_lock
, NULL
, RW_DRIVER
, NULL
);
332 mutex_init(&e1000g_nvm_lock
, NULL
, MUTEX_DRIVER
, NULL
);
339 * _fini - module finalization
346 if (e1000g_mblks_pending
!= 0)
349 status
= mod_remove(&modlinkage
);
350 if (status
== DDI_SUCCESS
) {
351 mac_fini_ops(&ws_ops
);
353 if (e1000g_force_detach
) {
354 private_devi_list_t
*devi_node
;
356 mutex_enter(&e1000g_rx_detach_lock
);
357 while (e1000g_private_devi_list
!= NULL
) {
358 devi_node
= e1000g_private_devi_list
;
359 e1000g_private_devi_list
=
360 e1000g_private_devi_list
->next
;
362 kmem_free(devi_node
->priv_dip
,
363 sizeof (struct dev_info
));
365 sizeof (private_devi_list_t
));
367 mutex_exit(&e1000g_rx_detach_lock
);
370 mutex_destroy(&e1000g_rx_detach_lock
);
371 rw_destroy(&e1000g_dma_type_lock
);
372 mutex_destroy(&e1000g_nvm_lock
);
379 * _info - module information
382 _info(struct modinfo
*modinfop
)
384 return (mod_info(&modlinkage
, modinfop
));
388 * e1000g_attach - driver attach
390 * This function is the device-specific initialization entry
391 * point. This entry point is required and must be written.
392 * The DDI_ATTACH command must be provided in the attach entry
393 * point. When attach() is called with cmd set to DDI_ATTACH,
394 * all normal kernel services (such as kmem_alloc(9F)) are
395 * available for use by the driver.
397 * The attach() function will be called once for each instance
398 * of the device on the system with cmd set to DDI_ATTACH.
399 * Until attach() succeeds, the only driver entry points which
400 * may be called are open(9E) and getinfo(9E).
403 e1000g_attach(dev_info_t
*devinfo
, ddi_attach_cmd_t cmd
)
405 struct e1000g
*Adapter
;
407 struct e1000g_osdep
*osdep
;
412 e1000g_log(NULL
, CE_WARN
,
413 "Unsupported command send to e1000g_attach... ");
414 return (DDI_FAILURE
);
417 return (e1000g_resume(devinfo
));
424 * get device instance number
426 instance
= ddi_get_instance(devinfo
);
429 * Allocate soft data structure
432 (struct e1000g
*)kmem_zalloc(sizeof (*Adapter
), KM_SLEEP
);
434 Adapter
->dip
= devinfo
;
435 Adapter
->instance
= instance
;
436 Adapter
->tx_ring
->adapter
= Adapter
;
437 Adapter
->rx_ring
->adapter
= Adapter
;
439 hw
= &Adapter
->shared
;
440 osdep
= &Adapter
->osdep
;
442 osdep
->adapter
= Adapter
;
444 ddi_set_driver_private(devinfo
, (caddr_t
)Adapter
);
447 * Initialize for fma support
449 (void) e1000g_get_prop(Adapter
, "fm-capable",
451 DDI_FM_EREPORT_CAPABLE
| DDI_FM_ACCCHK_CAPABLE
|
452 DDI_FM_DMACHK_CAPABLE
| DDI_FM_ERRCB_CAPABLE
,
453 &Adapter
->fm_capabilities
);
454 e1000g_fm_init(Adapter
);
455 Adapter
->attach_progress
|= ATTACH_PROGRESS_FMINIT
;
460 if (pci_config_setup(devinfo
, &osdep
->cfg_handle
) != DDI_SUCCESS
) {
461 e1000g_log(Adapter
, CE_WARN
, "PCI configuration failed");
464 Adapter
->attach_progress
|= ATTACH_PROGRESS_PCI_CONFIG
;
469 if (e1000g_identify_hardware(Adapter
) != DDI_SUCCESS
) {
470 e1000g_log(Adapter
, CE_WARN
, "Identify hardware failed");
475 * Map in the device registers.
477 if (e1000g_regs_map(Adapter
) != DDI_SUCCESS
) {
478 e1000g_log(Adapter
, CE_WARN
, "Mapping registers failed");
481 Adapter
->attach_progress
|= ATTACH_PROGRESS_REGS_MAP
;
484 * Initialize driver parameters
486 if (e1000g_set_driver_params(Adapter
) != DDI_SUCCESS
) {
489 Adapter
->attach_progress
|= ATTACH_PROGRESS_SETUP
;
491 if (e1000g_check_acc_handle(Adapter
->osdep
.cfg_handle
) != DDI_FM_OK
) {
492 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_LOST
);
497 * Disable ULP support
499 (void) e1000_disable_ulp_lpt_lp(hw
, TRUE
);
502 * Initialize interrupts
504 if (e1000g_add_intrs(Adapter
) != DDI_SUCCESS
) {
505 e1000g_log(Adapter
, CE_WARN
, "Add interrupts failed");
508 Adapter
->attach_progress
|= ATTACH_PROGRESS_ADD_INTR
;
511 * Initialize mutex's for this device.
512 * Do this before enabling the interrupt handler and
513 * register the softint to avoid the condition where
514 * interrupt handler can try using uninitialized mutex
516 e1000g_init_locks(Adapter
);
517 Adapter
->attach_progress
|= ATTACH_PROGRESS_LOCKS
;
520 * Initialize Driver Counters
522 if (e1000g_init_stats(Adapter
) != DDI_SUCCESS
) {
523 e1000g_log(Adapter
, CE_WARN
, "Init stats failed");
526 Adapter
->attach_progress
|= ATTACH_PROGRESS_KSTATS
;
529 * Initialize chip hardware and software structures
531 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
532 if (e1000g_init(Adapter
) != DDI_SUCCESS
) {
533 rw_exit(&Adapter
->chip_lock
);
534 e1000g_log(Adapter
, CE_WARN
, "Adapter initialization failed");
537 rw_exit(&Adapter
->chip_lock
);
538 Adapter
->attach_progress
|= ATTACH_PROGRESS_INIT
;
541 * Register the driver to the MAC
543 if (e1000g_register_mac(Adapter
) != DDI_SUCCESS
) {
544 e1000g_log(Adapter
, CE_WARN
, "Register MAC failed");
547 Adapter
->attach_progress
|= ATTACH_PROGRESS_MAC
;
550 * Now that mutex locks are initialized, and the chip is also
551 * initialized, enable interrupts.
553 if (e1000g_enable_intrs(Adapter
) != DDI_SUCCESS
) {
554 e1000g_log(Adapter
, CE_WARN
, "Enable DDI interrupts failed");
557 Adapter
->attach_progress
|= ATTACH_PROGRESS_ENABLE_INTR
;
560 * If e1000g_force_detach is enabled, in global private dip list,
561 * we will create a new entry, which maintains the priv_dip for DR
562 * supports after driver detached.
564 if (e1000g_force_detach
) {
565 private_devi_list_t
*devi_node
;
568 kmem_zalloc(sizeof (struct dev_info
), KM_SLEEP
);
569 bcopy(DEVI(devinfo
), DEVI(Adapter
->priv_dip
),
570 sizeof (struct dev_info
));
573 kmem_zalloc(sizeof (private_devi_list_t
), KM_SLEEP
);
575 mutex_enter(&e1000g_rx_detach_lock
);
576 devi_node
->priv_dip
= Adapter
->priv_dip
;
577 devi_node
->flag
= E1000G_PRIV_DEVI_ATTACH
;
578 devi_node
->pending_rx_count
= 0;
580 Adapter
->priv_devi_node
= devi_node
;
582 if (e1000g_private_devi_list
== NULL
) {
583 devi_node
->prev
= NULL
;
584 devi_node
->next
= NULL
;
585 e1000g_private_devi_list
= devi_node
;
587 devi_node
->prev
= NULL
;
588 devi_node
->next
= e1000g_private_devi_list
;
589 e1000g_private_devi_list
->prev
= devi_node
;
590 e1000g_private_devi_list
= devi_node
;
592 mutex_exit(&e1000g_rx_detach_lock
);
595 Adapter
->e1000g_state
= E1000G_INITIALIZED
;
596 return (DDI_SUCCESS
);
599 e1000g_unattach(devinfo
, Adapter
);
600 return (DDI_FAILURE
);
604 e1000g_register_mac(struct e1000g
*Adapter
)
606 struct e1000_hw
*hw
= &Adapter
->shared
;
610 if ((mac
= mac_alloc(MAC_VERSION
)) == NULL
)
611 return (DDI_FAILURE
);
613 mac
->m_type_ident
= MAC_PLUGIN_IDENT_ETHER
;
614 mac
->m_driver
= Adapter
;
615 mac
->m_dip
= Adapter
->dip
;
616 mac
->m_src_addr
= hw
->mac
.addr
;
617 mac
->m_callbacks
= &e1000g_m_callbacks
;
619 mac
->m_max_sdu
= Adapter
->default_mtu
;
620 mac
->m_margin
= VLAN_TAGSZ
;
621 mac
->m_priv_props
= e1000g_priv_props
;
622 mac
->m_v12n
= MAC_VIRT_LEVEL1
;
624 err
= mac_register(mac
, &Adapter
->mh
);
627 return (err
== 0 ? DDI_SUCCESS
: DDI_FAILURE
);
631 e1000g_identify_hardware(struct e1000g
*Adapter
)
633 struct e1000_hw
*hw
= &Adapter
->shared
;
634 struct e1000g_osdep
*osdep
= &Adapter
->osdep
;
636 /* Get the device id */
638 pci_config_get16(osdep
->cfg_handle
, PCI_CONF_VENID
);
640 pci_config_get16(osdep
->cfg_handle
, PCI_CONF_DEVID
);
642 pci_config_get8(osdep
->cfg_handle
, PCI_CONF_REVID
);
643 hw
->subsystem_device_id
=
644 pci_config_get16(osdep
->cfg_handle
, PCI_CONF_SUBSYSID
);
645 hw
->subsystem_vendor_id
=
646 pci_config_get16(osdep
->cfg_handle
, PCI_CONF_SUBVENID
);
648 if (e1000_set_mac_type(hw
) != E1000_SUCCESS
) {
649 E1000G_DEBUGLOG_0(Adapter
, E1000G_INFO_LEVEL
,
650 "MAC type could not be set properly.");
651 return (DDI_FAILURE
);
654 return (DDI_SUCCESS
);
658 e1000g_regs_map(struct e1000g
*Adapter
)
660 dev_info_t
*devinfo
= Adapter
->dip
;
661 struct e1000_hw
*hw
= &Adapter
->shared
;
662 struct e1000g_osdep
*osdep
= &Adapter
->osdep
;
667 rnumber
= ADAPTER_REG_SET
;
668 /* Get size of adapter register memory */
669 if (ddi_dev_regsize(devinfo
, rnumber
, &mem_size
) !=
671 E1000G_DEBUGLOG_0(Adapter
, CE_WARN
,
672 "ddi_dev_regsize for registers failed");
673 return (DDI_FAILURE
);
676 /* Map adapter register memory */
677 if ((ddi_regs_map_setup(devinfo
, rnumber
,
678 (caddr_t
*)&hw
->hw_addr
, 0, mem_size
, &e1000g_regs_acc_attr
,
679 &osdep
->reg_handle
)) != DDI_SUCCESS
) {
680 E1000G_DEBUGLOG_0(Adapter
, CE_WARN
,
681 "ddi_regs_map_setup for registers failed");
685 /* ICH needs to map flash memory */
686 switch (hw
->mac
.type
) {
693 rnumber
= ICH_FLASH_REG_SET
;
696 if (ddi_dev_regsize(devinfo
, rnumber
,
697 &mem_size
) != DDI_SUCCESS
) {
698 E1000G_DEBUGLOG_0(Adapter
, CE_WARN
,
699 "ddi_dev_regsize for ICH flash failed");
704 if (ddi_regs_map_setup(devinfo
, rnumber
,
705 (caddr_t
*)&hw
->flash_address
, 0,
706 mem_size
, &e1000g_regs_acc_attr
,
707 &osdep
->ich_flash_handle
) != DDI_SUCCESS
) {
708 E1000G_DEBUGLOG_0(Adapter
, CE_WARN
,
709 "ddi_regs_map_setup for ICH flash failed");
718 switch (hw
->mac
.type
) {
724 case e1000_82541_rev_2
:
725 /* find the IO bar */
727 for (offset
= PCI_CONF_BASE1
;
728 offset
<= PCI_CONF_BASE5
; offset
+= 4) {
729 if (e1000g_get_bar_info(devinfo
, offset
, &bar_info
)
732 if (bar_info
.type
== E1000G_BAR_IO
) {
733 rnumber
= bar_info
.rnumber
;
739 E1000G_DEBUGLOG_0(Adapter
, CE_WARN
,
740 "No io space is found");
744 /* get io space size */
745 if (ddi_dev_regsize(devinfo
, rnumber
,
746 &mem_size
) != DDI_SUCCESS
) {
747 E1000G_DEBUGLOG_0(Adapter
, CE_WARN
,
748 "ddi_dev_regsize for io space failed");
753 if ((ddi_regs_map_setup(devinfo
, rnumber
,
754 (caddr_t
*)&hw
->io_base
, 0, mem_size
,
755 &e1000g_regs_acc_attr
,
756 &osdep
->io_reg_handle
)) != DDI_SUCCESS
) {
757 E1000G_DEBUGLOG_0(Adapter
, CE_WARN
,
758 "ddi_regs_map_setup for io space failed");
767 return (DDI_SUCCESS
);
770 if (osdep
->reg_handle
!= NULL
)
771 ddi_regs_map_free(&osdep
->reg_handle
);
772 if (osdep
->ich_flash_handle
!= NULL
)
773 ddi_regs_map_free(&osdep
->ich_flash_handle
);
774 return (DDI_FAILURE
);
778 e1000g_set_driver_params(struct e1000g
*Adapter
)
782 hw
= &Adapter
->shared
;
784 /* Set MAC type and initialize hardware functions */
785 if (e1000_setup_init_funcs(hw
, B_TRUE
) != E1000_SUCCESS
) {
786 E1000G_DEBUGLOG_0(Adapter
, CE_WARN
,
787 "Could not setup hardware functions");
788 return (DDI_FAILURE
);
791 /* Get bus information */
792 if (e1000_get_bus_info(hw
) != E1000_SUCCESS
) {
793 E1000G_DEBUGLOG_0(Adapter
, CE_WARN
,
794 "Could not get bus information");
795 return (DDI_FAILURE
);
798 e1000_read_pci_cfg(hw
, PCI_COMMAND_REGISTER
, &hw
->bus
.pci_cmd_word
);
800 hw
->mac
.autoneg_failed
= B_TRUE
;
802 /* Set the autoneg_wait_to_complete flag to B_FALSE */
803 hw
->phy
.autoneg_wait_to_complete
= B_FALSE
;
805 /* Adaptive IFS related changes */
806 hw
->mac
.adaptive_ifs
= B_TRUE
;
808 /* Enable phy init script for IGP phy of 82541/82547 */
809 if ((hw
->mac
.type
== e1000_82547
) ||
810 (hw
->mac
.type
== e1000_82541
) ||
811 (hw
->mac
.type
== e1000_82547_rev_2
) ||
812 (hw
->mac
.type
== e1000_82541_rev_2
))
813 e1000_init_script_state_82541(hw
, B_TRUE
);
815 /* Enable the TTL workaround for 82541/82547 */
816 e1000_set_ttl_workaround_state_82541(hw
, B_TRUE
);
819 Adapter
->strip_crc
= B_TRUE
;
821 Adapter
->strip_crc
= B_FALSE
;
824 /* setup the maximum MTU size of the chip */
825 e1000g_setup_max_mtu(Adapter
);
827 /* Get speed/duplex settings in conf file */
828 hw
->mac
.forced_speed_duplex
= ADVERTISE_100_FULL
;
829 hw
->phy
.autoneg_advertised
= AUTONEG_ADVERTISE_SPEED_DEFAULT
;
830 e1000g_force_speed_duplex(Adapter
);
832 /* Get Jumbo Frames settings in conf file */
833 e1000g_get_max_frame_size(Adapter
);
835 /* Get conf file properties */
836 e1000g_get_conf(Adapter
);
838 /* enforce PCH limits */
839 e1000g_pch_limits(Adapter
);
841 /* Set Rx/Tx buffer size */
842 e1000g_set_bufsize(Adapter
);
844 /* Master Latency Timer */
845 Adapter
->master_latency_timer
= DEFAULT_MASTER_LATENCY_TIMER
;
848 if (hw
->phy
.media_type
== e1000_media_type_copper
) {
849 hw
->phy
.mdix
= 0; /* AUTO_ALL_MODES */
850 hw
->phy
.disable_polarity_correction
= B_FALSE
;
851 hw
->phy
.ms_type
= e1000_ms_hw_default
; /* E1000_MASTER_SLAVE */
854 /* The initial link state should be "unknown" */
855 Adapter
->link_state
= LINK_STATE_UNKNOWN
;
857 /* Initialize rx parameters */
858 Adapter
->rx_intr_delay
= DEFAULT_RX_INTR_DELAY
;
859 Adapter
->rx_intr_abs_delay
= DEFAULT_RX_INTR_ABS_DELAY
;
861 /* Initialize tx parameters */
862 Adapter
->tx_intr_enable
= DEFAULT_TX_INTR_ENABLE
;
863 Adapter
->tx_bcopy_thresh
= DEFAULT_TX_BCOPY_THRESHOLD
;
864 Adapter
->tx_intr_delay
= DEFAULT_TX_INTR_DELAY
;
865 Adapter
->tx_intr_abs_delay
= DEFAULT_TX_INTR_ABS_DELAY
;
867 /* Initialize rx parameters */
868 Adapter
->rx_bcopy_thresh
= DEFAULT_RX_BCOPY_THRESHOLD
;
870 return (DDI_SUCCESS
);
874 e1000g_setup_max_mtu(struct e1000g
*Adapter
)
876 struct e1000_mac_info
*mac
= &Adapter
->shared
.mac
;
877 struct e1000_phy_info
*phy
= &Adapter
->shared
.phy
;
880 /* types that do not support jumbo frames */
884 Adapter
->max_mtu
= ETHERMTU
;
886 /* ich9 supports jumbo frames except on one phy type */
888 if (phy
->type
== e1000_phy_ife
)
889 Adapter
->max_mtu
= ETHERMTU
;
891 Adapter
->max_mtu
= MAXIMUM_MTU_9K
;
893 /* pch can do jumbo frames up to 4K */
895 Adapter
->max_mtu
= MAXIMUM_MTU_4K
;
897 /* pch2 can do jumbo frames up to 9K */
900 Adapter
->max_mtu
= MAXIMUM_MTU_9K
;
902 /* types with a special limit */
906 case e1000_80003es2lan
:
908 if (e1000g_jumbo_mtu
>= ETHERMTU
&&
909 e1000g_jumbo_mtu
<= MAXIMUM_MTU_9K
) {
910 Adapter
->max_mtu
= e1000g_jumbo_mtu
;
912 Adapter
->max_mtu
= MAXIMUM_MTU_9K
;
915 /* default limit is 16K */
917 Adapter
->max_mtu
= FRAME_SIZE_UPTO_16K
-
918 sizeof (struct ether_vlan_header
) - ETHERFCSL
;
924 e1000g_set_bufsize(struct e1000g
*Adapter
)
926 struct e1000_mac_info
*mac
= &Adapter
->shared
.mac
;
930 dev_info_t
*devinfo
= Adapter
->dip
;
932 ulong_t iommu_pagesize
;
934 /* Get the system page size */
935 Adapter
->sys_page_sz
= ddi_ptob(devinfo
, (ulong_t
)1);
938 iommu_pagesize
= dvma_pagesize(devinfo
);
939 if (iommu_pagesize
!= 0) {
940 if (Adapter
->sys_page_sz
== iommu_pagesize
) {
941 if (iommu_pagesize
> 0x4000)
942 Adapter
->sys_page_sz
= 0x4000;
944 if (Adapter
->sys_page_sz
> iommu_pagesize
)
945 Adapter
->sys_page_sz
= iommu_pagesize
;
948 if (Adapter
->lso_enable
) {
949 Adapter
->dvma_page_num
= E1000_LSO_MAXLEN
/
950 Adapter
->sys_page_sz
+ E1000G_DEFAULT_DVMA_PAGE_NUM
;
952 Adapter
->dvma_page_num
= Adapter
->max_frame_size
/
953 Adapter
->sys_page_sz
+ E1000G_DEFAULT_DVMA_PAGE_NUM
;
955 ASSERT(Adapter
->dvma_page_num
>= E1000G_DEFAULT_DVMA_PAGE_NUM
);
958 Adapter
->min_frame_size
= ETHERMIN
+ ETHERFCSL
;
960 if (Adapter
->mem_workaround_82546
&&
961 ((mac
->type
== e1000_82545
) ||
962 (mac
->type
== e1000_82546
) ||
963 (mac
->type
== e1000_82546_rev_3
))) {
964 Adapter
->rx_buffer_size
= E1000_RX_BUFFER_SIZE_2K
;
966 rx_size
= Adapter
->max_frame_size
;
967 if ((rx_size
> FRAME_SIZE_UPTO_2K
) &&
968 (rx_size
<= FRAME_SIZE_UPTO_4K
))
969 Adapter
->rx_buffer_size
= E1000_RX_BUFFER_SIZE_4K
;
970 else if ((rx_size
> FRAME_SIZE_UPTO_4K
) &&
971 (rx_size
<= FRAME_SIZE_UPTO_8K
))
972 Adapter
->rx_buffer_size
= E1000_RX_BUFFER_SIZE_8K
;
973 else if ((rx_size
> FRAME_SIZE_UPTO_8K
) &&
974 (rx_size
<= FRAME_SIZE_UPTO_16K
))
975 Adapter
->rx_buffer_size
= E1000_RX_BUFFER_SIZE_16K
;
977 Adapter
->rx_buffer_size
= E1000_RX_BUFFER_SIZE_2K
;
979 Adapter
->rx_buffer_size
+= E1000G_IPALIGNROOM
;
981 tx_size
= Adapter
->max_frame_size
;
982 if ((tx_size
> FRAME_SIZE_UPTO_2K
) && (tx_size
<= FRAME_SIZE_UPTO_4K
))
983 Adapter
->tx_buffer_size
= E1000_TX_BUFFER_SIZE_4K
;
984 else if ((tx_size
> FRAME_SIZE_UPTO_4K
) &&
985 (tx_size
<= FRAME_SIZE_UPTO_8K
))
986 Adapter
->tx_buffer_size
= E1000_TX_BUFFER_SIZE_8K
;
987 else if ((tx_size
> FRAME_SIZE_UPTO_8K
) &&
988 (tx_size
<= FRAME_SIZE_UPTO_16K
))
989 Adapter
->tx_buffer_size
= E1000_TX_BUFFER_SIZE_16K
;
991 Adapter
->tx_buffer_size
= E1000_TX_BUFFER_SIZE_2K
;
994 * For Wiseman adapters we have an requirement of having receive
995 * buffers aligned at 256 byte boundary. Since Livengood does not
996 * require this and forcing it for all hardwares will have
997 * performance implications, I am making it applicable only for
998 * Wiseman and for Jumbo frames enabled mode as rest of the time,
999 * it is okay to have normal frames...but it does involve a
1000 * potential risk where we may loose data if buffer is not
1001 * aligned...so all wiseman boards to have 256 byte aligned
1004 if (mac
->type
< e1000_82543
)
1005 Adapter
->rx_buf_align
= RECEIVE_BUFFER_ALIGN_SIZE
;
1007 Adapter
->rx_buf_align
= 1;
1011 * e1000g_detach - driver detach
1013 * The detach() function is the complement of the attach routine.
1014 * If cmd is set to DDI_DETACH, detach() is used to remove the
1015 * state associated with a given instance of a device node
1016 * prior to the removal of that instance from the system.
1018 * The detach() function will be called once for each instance
1019 * of the device for which there has been a successful attach()
1020 * once there are no longer any opens on the device.
1022 * Interrupts routine are disabled, All memory allocated by this
1026 e1000g_detach(dev_info_t
*devinfo
, ddi_detach_cmd_t cmd
)
1028 struct e1000g
*Adapter
;
1033 return (DDI_FAILURE
);
1036 return (e1000g_suspend(devinfo
));
1042 Adapter
= (struct e1000g
*)ddi_get_driver_private(devinfo
);
1043 if (Adapter
== NULL
)
1044 return (DDI_FAILURE
);
1046 rx_drain
= e1000g_rx_drain(Adapter
);
1047 if (!rx_drain
&& !e1000g_force_detach
)
1048 return (DDI_FAILURE
);
1050 if (mac_unregister(Adapter
->mh
) != 0) {
1051 e1000g_log(Adapter
, CE_WARN
, "Unregister MAC failed");
1052 return (DDI_FAILURE
);
1054 Adapter
->attach_progress
&= ~ATTACH_PROGRESS_MAC
;
1056 ASSERT(!(Adapter
->e1000g_state
& E1000G_STARTED
));
1058 if (!e1000g_force_detach
&& !rx_drain
)
1059 return (DDI_FAILURE
);
1061 e1000g_unattach(devinfo
, Adapter
);
1063 return (DDI_SUCCESS
);
1067 * e1000g_free_priv_devi_node - free a priv_dip entry for driver instance
1070 e1000g_free_priv_devi_node(private_devi_list_t
*devi_node
)
1072 ASSERT(e1000g_private_devi_list
!= NULL
);
1073 ASSERT(devi_node
!= NULL
);
1075 if (devi_node
->prev
!= NULL
)
1076 devi_node
->prev
->next
= devi_node
->next
;
1077 if (devi_node
->next
!= NULL
)
1078 devi_node
->next
->prev
= devi_node
->prev
;
1079 if (devi_node
== e1000g_private_devi_list
)
1080 e1000g_private_devi_list
= devi_node
->next
;
1082 kmem_free(devi_node
->priv_dip
,
1083 sizeof (struct dev_info
));
1084 kmem_free(devi_node
,
1085 sizeof (private_devi_list_t
));
1089 e1000g_unattach(dev_info_t
*devinfo
, struct e1000g
*Adapter
)
1091 private_devi_list_t
*devi_node
;
1094 if (Adapter
->attach_progress
& ATTACH_PROGRESS_ENABLE_INTR
) {
1095 (void) e1000g_disable_intrs(Adapter
);
1098 if (Adapter
->attach_progress
& ATTACH_PROGRESS_MAC
) {
1099 (void) mac_unregister(Adapter
->mh
);
1102 if (Adapter
->attach_progress
& ATTACH_PROGRESS_ADD_INTR
) {
1103 (void) e1000g_rem_intrs(Adapter
);
1106 if (Adapter
->attach_progress
& ATTACH_PROGRESS_SETUP
) {
1107 (void) ddi_prop_remove_all(devinfo
);
1110 if (Adapter
->attach_progress
& ATTACH_PROGRESS_KSTATS
) {
1111 kstat_delete((kstat_t
*)Adapter
->e1000g_ksp
);
1114 if (Adapter
->attach_progress
& ATTACH_PROGRESS_INIT
) {
1115 stop_link_timer(Adapter
);
1117 mutex_enter(&e1000g_nvm_lock
);
1118 result
= e1000_reset_hw(&Adapter
->shared
);
1119 mutex_exit(&e1000g_nvm_lock
);
1121 if (result
!= E1000_SUCCESS
) {
1122 e1000g_fm_ereport(Adapter
, DDI_FM_DEVICE_INVAL_STATE
);
1123 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_LOST
);
1127 e1000g_release_multicast(Adapter
);
1129 if (Adapter
->attach_progress
& ATTACH_PROGRESS_REGS_MAP
) {
1130 if (Adapter
->osdep
.reg_handle
!= NULL
)
1131 ddi_regs_map_free(&Adapter
->osdep
.reg_handle
);
1132 if (Adapter
->osdep
.ich_flash_handle
!= NULL
)
1133 ddi_regs_map_free(&Adapter
->osdep
.ich_flash_handle
);
1134 if (Adapter
->osdep
.io_reg_handle
!= NULL
)
1135 ddi_regs_map_free(&Adapter
->osdep
.io_reg_handle
);
1138 if (Adapter
->attach_progress
& ATTACH_PROGRESS_PCI_CONFIG
) {
1139 if (Adapter
->osdep
.cfg_handle
!= NULL
)
1140 pci_config_teardown(&Adapter
->osdep
.cfg_handle
);
1143 if (Adapter
->attach_progress
& ATTACH_PROGRESS_LOCKS
) {
1144 e1000g_destroy_locks(Adapter
);
1147 if (Adapter
->attach_progress
& ATTACH_PROGRESS_FMINIT
) {
1148 e1000g_fm_fini(Adapter
);
1151 mutex_enter(&e1000g_rx_detach_lock
);
1152 if (e1000g_force_detach
&& (Adapter
->priv_devi_node
!= NULL
)) {
1153 devi_node
= Adapter
->priv_devi_node
;
1154 devi_node
->flag
|= E1000G_PRIV_DEVI_DETACH
;
1156 if (devi_node
->pending_rx_count
== 0) {
1157 e1000g_free_priv_devi_node(devi_node
);
1160 mutex_exit(&e1000g_rx_detach_lock
);
1162 kmem_free((caddr_t
)Adapter
, sizeof (struct e1000g
));
1165 * Another hotplug spec requirement,
1166 * run ddi_set_driver_private(devinfo, null);
1168 ddi_set_driver_private(devinfo
, NULL
);
1172 * Get the BAR type and rnumber for a given PCI BAR offset
1175 e1000g_get_bar_info(dev_info_t
*dip
, int bar_offset
, bar_info_t
*bar_info
)
1177 pci_regspec_t
*regs
;
1179 int type
, rnumber
, rcount
;
1181 ASSERT((bar_offset
>= PCI_CONF_BASE0
) &&
1182 (bar_offset
<= PCI_CONF_BASE5
));
1185 * Get the DDI "reg" property
1187 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY
, dip
,
1188 DDI_PROP_DONTPASS
, "reg", (int **)®s
,
1189 ®s_length
) != DDI_PROP_SUCCESS
) {
1190 return (DDI_FAILURE
);
1193 rcount
= regs_length
* sizeof (int) / sizeof (pci_regspec_t
);
1195 * Check the BAR offset
1197 for (rnumber
= 0; rnumber
< rcount
; ++rnumber
) {
1198 if (PCI_REG_REG_G(regs
[rnumber
].pci_phys_hi
) == bar_offset
) {
1199 type
= regs
[rnumber
].pci_phys_hi
& PCI_ADDR_MASK
;
1204 ddi_prop_free(regs
);
1206 if (rnumber
>= rcount
)
1207 return (DDI_FAILURE
);
1210 case PCI_ADDR_CONFIG
:
1211 bar_info
->type
= E1000G_BAR_CONFIG
;
1214 bar_info
->type
= E1000G_BAR_IO
;
1216 case PCI_ADDR_MEM32
:
1217 bar_info
->type
= E1000G_BAR_MEM32
;
1219 case PCI_ADDR_MEM64
:
1220 bar_info
->type
= E1000G_BAR_MEM64
;
1223 return (DDI_FAILURE
);
1225 bar_info
->rnumber
= rnumber
;
1226 return (DDI_SUCCESS
);
1230 e1000g_init_locks(struct e1000g
*Adapter
)
1232 e1000g_tx_ring_t
*tx_ring
;
1233 e1000g_rx_ring_t
*rx_ring
;
1235 rw_init(&Adapter
->chip_lock
, NULL
,
1236 RW_DRIVER
, DDI_INTR_PRI(Adapter
->intr_pri
));
1237 mutex_init(&Adapter
->link_lock
, NULL
,
1238 MUTEX_DRIVER
, DDI_INTR_PRI(Adapter
->intr_pri
));
1239 mutex_init(&Adapter
->watchdog_lock
, NULL
,
1240 MUTEX_DRIVER
, DDI_INTR_PRI(Adapter
->intr_pri
));
1242 tx_ring
= Adapter
->tx_ring
;
1244 mutex_init(&tx_ring
->tx_lock
, NULL
,
1245 MUTEX_DRIVER
, DDI_INTR_PRI(Adapter
->intr_pri
));
1246 mutex_init(&tx_ring
->usedlist_lock
, NULL
,
1247 MUTEX_DRIVER
, DDI_INTR_PRI(Adapter
->intr_pri
));
1248 mutex_init(&tx_ring
->freelist_lock
, NULL
,
1249 MUTEX_DRIVER
, DDI_INTR_PRI(Adapter
->intr_pri
));
1251 rx_ring
= Adapter
->rx_ring
;
1253 mutex_init(&rx_ring
->rx_lock
, NULL
,
1254 MUTEX_DRIVER
, DDI_INTR_PRI(Adapter
->intr_pri
));
1258 e1000g_destroy_locks(struct e1000g
*Adapter
)
1260 e1000g_tx_ring_t
*tx_ring
;
1261 e1000g_rx_ring_t
*rx_ring
;
1263 tx_ring
= Adapter
->tx_ring
;
1264 mutex_destroy(&tx_ring
->tx_lock
);
1265 mutex_destroy(&tx_ring
->usedlist_lock
);
1266 mutex_destroy(&tx_ring
->freelist_lock
);
1268 rx_ring
= Adapter
->rx_ring
;
1269 mutex_destroy(&rx_ring
->rx_lock
);
1271 mutex_destroy(&Adapter
->link_lock
);
1272 mutex_destroy(&Adapter
->watchdog_lock
);
1273 rw_destroy(&Adapter
->chip_lock
);
1275 /* destory mutex initialized in shared code */
1276 e1000_destroy_hw_mutex(&Adapter
->shared
);
1280 e1000g_resume(dev_info_t
*devinfo
)
1282 struct e1000g
*Adapter
;
1284 Adapter
= (struct e1000g
*)ddi_get_driver_private(devinfo
);
1285 if (Adapter
== NULL
)
1286 e1000g_log(Adapter
, CE_PANIC
,
1287 "Instance pointer is null\n");
1289 if (Adapter
->dip
!= devinfo
)
1290 e1000g_log(Adapter
, CE_PANIC
,
1291 "Devinfo is not the same as saved devinfo\n");
1293 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
1295 if (Adapter
->e1000g_state
& E1000G_STARTED
) {
1296 if (e1000g_start(Adapter
, B_FALSE
) != DDI_SUCCESS
) {
1297 rw_exit(&Adapter
->chip_lock
);
1299 * We note the failure, but return success, as the
1300 * system is still usable without this controller.
1302 e1000g_log(Adapter
, CE_WARN
,
1303 "e1000g_resume: failed to restart controller\n");
1304 return (DDI_SUCCESS
);
1306 /* Enable and start the watchdog timer */
1307 enable_watchdog_timer(Adapter
);
1310 Adapter
->e1000g_state
&= ~E1000G_SUSPENDED
;
1312 rw_exit(&Adapter
->chip_lock
);
1314 return (DDI_SUCCESS
);
1318 e1000g_suspend(dev_info_t
*devinfo
)
1320 struct e1000g
*Adapter
;
1322 Adapter
= (struct e1000g
*)ddi_get_driver_private(devinfo
);
1323 if (Adapter
== NULL
)
1324 return (DDI_FAILURE
);
1326 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
1328 Adapter
->e1000g_state
|= E1000G_SUSPENDED
;
1330 /* if the port isn't plumbed, we can simply return */
1331 if (!(Adapter
->e1000g_state
& E1000G_STARTED
)) {
1332 rw_exit(&Adapter
->chip_lock
);
1333 return (DDI_SUCCESS
);
1336 e1000g_stop(Adapter
, B_FALSE
);
1338 rw_exit(&Adapter
->chip_lock
);
1340 /* Disable and stop all the timers */
1341 disable_watchdog_timer(Adapter
);
1342 stop_link_timer(Adapter
);
1343 stop_82547_timer(Adapter
->tx_ring
);
1345 return (DDI_SUCCESS
);
1349 e1000g_init(struct e1000g
*Adapter
)
1352 uint32_t high_water
;
1353 struct e1000_hw
*hw
;
1354 clock_t link_timeout
;
1357 hw
= &Adapter
->shared
;
1360 * reset to put the hardware in a known state
1361 * before we try to do anything with the eeprom
1363 mutex_enter(&e1000g_nvm_lock
);
1364 result
= e1000_reset_hw(hw
);
1365 mutex_exit(&e1000g_nvm_lock
);
1367 if (result
!= E1000_SUCCESS
) {
1368 e1000g_fm_ereport(Adapter
, DDI_FM_DEVICE_INVAL_STATE
);
1372 mutex_enter(&e1000g_nvm_lock
);
1373 result
= e1000_validate_nvm_checksum(hw
);
1374 if (result
< E1000_SUCCESS
) {
1376 * Some PCI-E parts fail the first check due to
1377 * the link being in sleep state. Call it again,
1378 * if it fails a second time its a real issue.
1380 result
= e1000_validate_nvm_checksum(hw
);
1382 mutex_exit(&e1000g_nvm_lock
);
1384 if (result
< E1000_SUCCESS
) {
1385 e1000g_log(Adapter
, CE_WARN
,
1386 "Invalid NVM checksum. Please contact "
1387 "the vendor to update the NVM.");
1388 e1000g_fm_ereport(Adapter
, DDI_FM_DEVICE_INVAL_STATE
);
1395 * First, we try to get the local ethernet address from OBP. If
1396 * failed, then we get it from the EEPROM of NIC card.
1398 result
= e1000g_find_mac_address(Adapter
);
1400 /* Get the local ethernet address. */
1402 mutex_enter(&e1000g_nvm_lock
);
1403 result
= e1000_read_mac_addr(hw
);
1404 mutex_exit(&e1000g_nvm_lock
);
1407 if (result
< E1000_SUCCESS
) {
1408 e1000g_log(Adapter
, CE_WARN
, "Read mac addr failed");
1409 e1000g_fm_ereport(Adapter
, DDI_FM_DEVICE_INVAL_STATE
);
1413 /* check for valid mac address */
1414 if (!is_valid_mac_addr(hw
->mac
.addr
)) {
1415 e1000g_log(Adapter
, CE_WARN
, "Invalid mac addr");
1416 e1000g_fm_ereport(Adapter
, DDI_FM_DEVICE_INVAL_STATE
);
1420 /* Set LAA state for 82571 chipset */
1421 e1000_set_laa_state_82571(hw
, B_TRUE
);
1423 /* Master Latency Timer implementation */
1424 if (Adapter
->master_latency_timer
) {
1425 pci_config_put8(Adapter
->osdep
.cfg_handle
,
1426 PCI_CONF_LATENCY_TIMER
, Adapter
->master_latency_timer
);
1429 if (hw
->mac
.type
< e1000_82547
) {
1433 if (Adapter
->max_frame_size
> FRAME_SIZE_UPTO_8K
)
1434 pba
= E1000_PBA_40K
; /* 40K for Rx, 24K for Tx */
1436 pba
= E1000_PBA_48K
; /* 48K for Rx, 16K for Tx */
1437 } else if ((hw
->mac
.type
== e1000_82571
) ||
1438 (hw
->mac
.type
== e1000_82572
) ||
1439 (hw
->mac
.type
== e1000_80003es2lan
)) {
1443 if (Adapter
->max_frame_size
> FRAME_SIZE_UPTO_8K
)
1444 pba
= E1000_PBA_30K
; /* 30K for Rx, 18K for Tx */
1446 pba
= E1000_PBA_38K
; /* 38K for Rx, 10K for Tx */
1447 } else if (hw
->mac
.type
== e1000_82573
) {
1448 pba
= E1000_PBA_20K
; /* 20K for Rx, 12K for Tx */
1449 } else if (hw
->mac
.type
== e1000_82574
) {
1450 /* Keep adapter default: 20K for Rx, 20K for Tx */
1451 pba
= E1000_READ_REG(hw
, E1000_PBA
);
1452 } else if (hw
->mac
.type
== e1000_ich8lan
) {
1453 pba
= E1000_PBA_8K
; /* 8K for Rx, 12K for Tx */
1454 } else if (hw
->mac
.type
== e1000_ich9lan
) {
1455 pba
= E1000_PBA_10K
;
1456 } else if (hw
->mac
.type
== e1000_ich10lan
) {
1457 pba
= E1000_PBA_10K
;
1458 } else if (hw
->mac
.type
== e1000_pchlan
) {
1459 pba
= E1000_PBA_26K
;
1460 } else if (hw
->mac
.type
== e1000_pch2lan
) {
1461 pba
= E1000_PBA_26K
;
1462 } else if (hw
->mac
.type
== e1000_pch_lpt
) {
1463 pba
= E1000_PBA_26K
;
1468 if (Adapter
->max_frame_size
> FRAME_SIZE_UPTO_8K
)
1469 pba
= E1000_PBA_22K
; /* 22K for Rx, 18K for Tx */
1471 pba
= E1000_PBA_30K
; /* 30K for Rx, 10K for Tx */
1473 E1000_WRITE_REG(hw
, E1000_PBA
, pba
);
1476 * These parameters set thresholds for the adapter's generation(Tx)
1477 * and response(Rx) to Ethernet PAUSE frames. These are just threshold
1478 * settings. Flow control is enabled or disabled in the configuration
1480 * High-water mark is set down from the top of the rx fifo (not
1481 * sensitive to max_frame_size) and low-water is set just below
1483 * The high water mark must be low enough to fit one full frame above
1484 * it in the rx FIFO. Should be the lower of:
1485 * 90% of the Rx FIFO size and the full Rx FIFO size minus the early
1486 * receive size (assuming ERT set to E1000_ERT_2048), or the full
1487 * Rx FIFO size minus one full frame.
1489 high_water
= min(((pba
<< 10) * 9 / 10),
1490 ((hw
->mac
.type
== e1000_82573
|| hw
->mac
.type
== e1000_82574
||
1491 hw
->mac
.type
== e1000_ich9lan
|| hw
->mac
.type
== e1000_ich10lan
) ?
1492 ((pba
<< 10) - (E1000_ERT_2048
<< 3)) :
1493 ((pba
<< 10) - Adapter
->max_frame_size
)));
1495 hw
->fc
.high_water
= high_water
& 0xFFF8;
1496 hw
->fc
.low_water
= hw
->fc
.high_water
- 8;
1498 if (hw
->mac
.type
== e1000_80003es2lan
)
1499 hw
->fc
.pause_time
= 0xFFFF;
1501 hw
->fc
.pause_time
= E1000_FC_PAUSE_TIME
;
1502 hw
->fc
.send_xon
= B_TRUE
;
1505 * Reset the adapter hardware the second time.
1507 mutex_enter(&e1000g_nvm_lock
);
1508 result
= e1000_reset_hw(hw
);
1509 mutex_exit(&e1000g_nvm_lock
);
1511 if (result
!= E1000_SUCCESS
) {
1512 e1000g_fm_ereport(Adapter
, DDI_FM_DEVICE_INVAL_STATE
);
1516 /* disable wakeup control by default */
1517 if (hw
->mac
.type
>= e1000_82544
)
1518 E1000_WRITE_REG(hw
, E1000_WUC
, 0);
1521 * MWI should be disabled on 82546.
1523 if (hw
->mac
.type
== e1000_82546
)
1524 e1000_pci_clear_mwi(hw
);
1526 e1000_pci_set_mwi(hw
);
1529 * Configure/Initialize hardware
1531 mutex_enter(&e1000g_nvm_lock
);
1532 result
= e1000_init_hw(hw
);
1533 mutex_exit(&e1000g_nvm_lock
);
1535 if (result
< E1000_SUCCESS
) {
1536 e1000g_log(Adapter
, CE_WARN
, "Initialize hw failed");
1537 e1000g_fm_ereport(Adapter
, DDI_FM_DEVICE_INVAL_STATE
);
1542 * Restore LED settings to the default from EEPROM
1543 * to meet the standard for Sun platforms.
1545 (void) e1000_cleanup_led(hw
);
1547 /* Disable Smart Power Down */
1548 phy_spd_state(hw
, B_FALSE
);
1550 /* Make sure driver has control */
1551 e1000g_get_driver_control(hw
);
1554 * Initialize unicast addresses.
1556 e1000g_init_unicst(Adapter
);
1559 * Setup and initialize the mctable structures. After this routine
1560 * completes Multicast table will be set
1562 e1000_update_mc_addr_list(hw
,
1563 (uint8_t *)Adapter
->mcast_table
, Adapter
->mcast_count
);
1567 * Implement Adaptive IFS
1569 e1000_reset_adaptive(hw
);
1571 /* Setup Interrupt Throttling Register */
1572 if (hw
->mac
.type
>= e1000_82540
) {
1573 E1000_WRITE_REG(hw
, E1000_ITR
, Adapter
->intr_throttling_rate
);
1575 Adapter
->intr_adaptive
= B_FALSE
;
1577 /* Start the timer for link setup */
1578 if (hw
->mac
.autoneg
)
1579 link_timeout
= PHY_AUTO_NEG_LIMIT
* drv_usectohz(100000);
1581 link_timeout
= PHY_FORCE_LIMIT
* drv_usectohz(100000);
1583 mutex_enter(&Adapter
->link_lock
);
1584 if (hw
->phy
.autoneg_wait_to_complete
) {
1585 Adapter
->link_complete
= B_TRUE
;
1587 Adapter
->link_complete
= B_FALSE
;
1588 Adapter
->link_tid
= timeout(e1000g_link_timer
,
1589 (void *)Adapter
, link_timeout
);
1591 mutex_exit(&Adapter
->link_lock
);
1593 /* Save the state of the phy */
1594 e1000g_get_phy_state(Adapter
);
1596 e1000g_param_sync(Adapter
);
1598 Adapter
->init_count
++;
1600 if (e1000g_check_acc_handle(Adapter
->osdep
.cfg_handle
) != DDI_FM_OK
) {
1603 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
1607 Adapter
->poll_mode
= e1000g_poll_mode
;
1609 return (DDI_SUCCESS
);
1612 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_LOST
);
1613 return (DDI_FAILURE
);
1617 e1000g_alloc_rx_data(struct e1000g
*Adapter
)
1619 e1000g_rx_ring_t
*rx_ring
;
1620 e1000g_rx_data_t
*rx_data
;
1622 rx_ring
= Adapter
->rx_ring
;
1624 rx_data
= kmem_zalloc(sizeof (e1000g_rx_data_t
), KM_NOSLEEP
);
1626 if (rx_data
== NULL
)
1627 return (DDI_FAILURE
);
1629 rx_data
->priv_devi_node
= Adapter
->priv_devi_node
;
1630 rx_data
->rx_ring
= rx_ring
;
1632 mutex_init(&rx_data
->freelist_lock
, NULL
,
1633 MUTEX_DRIVER
, DDI_INTR_PRI(Adapter
->intr_pri
));
1634 mutex_init(&rx_data
->recycle_lock
, NULL
,
1635 MUTEX_DRIVER
, DDI_INTR_PRI(Adapter
->intr_pri
));
1637 rx_ring
->rx_data
= rx_data
;
1639 return (DDI_SUCCESS
);
1643 e1000g_free_rx_pending_buffers(e1000g_rx_data_t
*rx_data
)
1645 rx_sw_packet_t
*packet
, *next_packet
;
1647 if (rx_data
== NULL
)
1650 packet
= rx_data
->packet_area
;
1651 while (packet
!= NULL
) {
1652 next_packet
= packet
->next
;
1653 e1000g_free_rx_sw_packet(packet
, B_TRUE
);
1654 packet
= next_packet
;
1656 rx_data
->packet_area
= NULL
;
1660 e1000g_free_rx_data(e1000g_rx_data_t
*rx_data
)
1662 if (rx_data
== NULL
)
1665 mutex_destroy(&rx_data
->freelist_lock
);
1666 mutex_destroy(&rx_data
->recycle_lock
);
1668 kmem_free(rx_data
, sizeof (e1000g_rx_data_t
));
1672 * Check if the link is up
1675 e1000g_link_up(struct e1000g
*Adapter
)
1677 struct e1000_hw
*hw
= &Adapter
->shared
;
1678 boolean_t link_up
= B_FALSE
;
1681 * get_link_status is set in the interrupt handler on link-status-change
1682 * or rx sequence error interrupt. get_link_status will stay
1683 * false until the e1000_check_for_link establishes link only
1684 * for copper adapters.
1686 switch (hw
->phy
.media_type
) {
1687 case e1000_media_type_copper
:
1688 if (hw
->mac
.get_link_status
) {
1689 (void) e1000_check_for_link(hw
);
1690 if ((E1000_READ_REG(hw
, E1000_STATUS
) &
1694 link_up
= !hw
->mac
.get_link_status
;
1700 case e1000_media_type_fiber
:
1701 (void) e1000_check_for_link(hw
);
1702 link_up
= (E1000_READ_REG(hw
, E1000_STATUS
) &
1705 case e1000_media_type_internal_serdes
:
1706 (void) e1000_check_for_link(hw
);
1707 link_up
= hw
->mac
.serdes_has_link
;
1715 e1000g_m_ioctl(void *arg
, queue_t
*q
, mblk_t
*mp
)
1717 struct iocblk
*iocp
;
1718 struct e1000g
*e1000gp
;
1719 enum ioc_reply status
;
1721 iocp
= (struct iocblk
*)(uintptr_t)mp
->b_rptr
;
1722 iocp
->ioc_error
= 0;
1723 e1000gp
= (struct e1000g
*)arg
;
1726 if (e1000gp
== NULL
) {
1727 miocnak(q
, mp
, 0, EINVAL
);
1731 rw_enter(&e1000gp
->chip_lock
, RW_READER
);
1732 if (e1000gp
->e1000g_state
& E1000G_SUSPENDED
) {
1733 rw_exit(&e1000gp
->chip_lock
);
1734 miocnak(q
, mp
, 0, EINVAL
);
1737 rw_exit(&e1000gp
->chip_lock
);
1739 switch (iocp
->ioc_cmd
) {
1741 case LB_GET_INFO_SIZE
:
1745 status
= e1000g_loopback_ioctl(e1000gp
, iocp
, mp
);
1750 case E1000G_IOC_REG_PEEK
:
1751 case E1000G_IOC_REG_POKE
:
1752 status
= e1000g_pp_ioctl(e1000gp
, iocp
, mp
);
1754 case E1000G_IOC_CHIP_RESET
:
1755 e1000gp
->reset_count
++;
1756 if (e1000g_reset_adapter(e1000gp
))
1768 * Decide how to reply
1774 * Error, reply with a NAK and EINVAL or the specified error
1776 miocnak(q
, mp
, 0, iocp
->ioc_error
== 0 ?
1777 EINVAL
: iocp
->ioc_error
);
1782 * OK, reply already sent
1788 * OK, reply with an ACK
1790 miocack(q
, mp
, 0, 0);
1795 * OK, send prepared reply as ACK or NAK
1797 mp
->b_datap
->db_type
= iocp
->ioc_error
== 0 ?
1798 M_IOCACK
: M_IOCNAK
;
1805 * The default value of e1000g_poll_mode == 0 assumes that the NIC is
1806 * capable of supporting only one interrupt and we shouldn't disable
1807 * the physical interrupt. In this case we let the interrupt come and
1808 * we queue the packets in the rx ring itself in case we are in polling
1809 * mode (better latency but slightly lower performance and a very
1810 * high intrrupt count in mpstat which is harmless).
1812 * e1000g_poll_mode == 1 assumes that we have per Rx ring interrupt
1813 * which can be disabled in poll mode. This gives better overall
1814 * throughput (compared to the mode above), shows very low interrupt
1815 * count but has slightly higher latency since we pick the packets when
1816 * the poll thread does polling.
1818 * Currently, this flag should be enabled only while doing performance
1819 * measurement or when it can be guaranteed that entire NIC going
1820 * in poll mode will not harm any traffic like cluster heartbeat etc.
1822 int e1000g_poll_mode
= 0;
1825 * Called from the upper layers when driver is in polling mode to
1826 * pick up any queued packets. Care should be taken to not block
1829 static mblk_t
*e1000g_poll_ring(void *arg
, int bytes_to_pickup
)
1831 e1000g_rx_ring_t
*rx_ring
= (e1000g_rx_ring_t
*)arg
;
1834 struct e1000g
*adapter
;
1836 adapter
= rx_ring
->adapter
;
1838 rw_enter(&adapter
->chip_lock
, RW_READER
);
1840 if (adapter
->e1000g_state
& E1000G_SUSPENDED
) {
1841 rw_exit(&adapter
->chip_lock
);
1845 mutex_enter(&rx_ring
->rx_lock
);
1846 mp
= e1000g_receive(rx_ring
, &tail
, bytes_to_pickup
);
1847 mutex_exit(&rx_ring
->rx_lock
);
1848 rw_exit(&adapter
->chip_lock
);
1853 e1000g_m_start(void *arg
)
1855 struct e1000g
*Adapter
= (struct e1000g
*)arg
;
1857 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
1859 if (Adapter
->e1000g_state
& E1000G_SUSPENDED
) {
1860 rw_exit(&Adapter
->chip_lock
);
1864 if (e1000g_start(Adapter
, B_TRUE
) != DDI_SUCCESS
) {
1865 rw_exit(&Adapter
->chip_lock
);
1866 return (ENOTACTIVE
);
1869 Adapter
->e1000g_state
|= E1000G_STARTED
;
1871 rw_exit(&Adapter
->chip_lock
);
1873 /* Enable and start the watchdog timer */
1874 enable_watchdog_timer(Adapter
);
1880 e1000g_start(struct e1000g
*Adapter
, boolean_t global
)
1882 e1000g_rx_data_t
*rx_data
;
1885 if (e1000g_alloc_rx_data(Adapter
) != DDI_SUCCESS
) {
1886 e1000g_log(Adapter
, CE_WARN
, "Allocate rx data failed");
1890 /* Allocate dma resources for descriptors and buffers */
1891 if (e1000g_alloc_dma_resources(Adapter
) != DDI_SUCCESS
) {
1892 e1000g_log(Adapter
, CE_WARN
,
1893 "Alloc DMA resources failed");
1896 Adapter
->rx_buffer_setup
= B_FALSE
;
1899 if (!(Adapter
->attach_progress
& ATTACH_PROGRESS_INIT
)) {
1900 if (e1000g_init(Adapter
) != DDI_SUCCESS
) {
1901 e1000g_log(Adapter
, CE_WARN
,
1902 "Adapter initialization failed");
1907 /* Setup and initialize the transmit structures */
1908 e1000g_tx_setup(Adapter
);
1911 /* Setup and initialize the receive structures */
1912 e1000g_rx_setup(Adapter
);
1915 /* Restore the e1000g promiscuous mode */
1916 e1000g_restore_promisc(Adapter
);
1918 e1000g_mask_interrupt(Adapter
);
1920 Adapter
->attach_progress
|= ATTACH_PROGRESS_INIT
;
1922 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
1923 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_LOST
);
1927 return (DDI_SUCCESS
);
1930 rx_data
= Adapter
->rx_ring
->rx_data
;
1933 e1000g_release_dma_resources(Adapter
);
1934 e1000g_free_rx_pending_buffers(rx_data
);
1935 e1000g_free_rx_data(rx_data
);
1938 mutex_enter(&e1000g_nvm_lock
);
1939 (void) e1000_reset_hw(&Adapter
->shared
);
1940 mutex_exit(&e1000g_nvm_lock
);
1942 return (DDI_FAILURE
);
1946 e1000g_m_stop(void *arg
)
1948 struct e1000g
*Adapter
= (struct e1000g
*)arg
;
1950 /* Drain tx sessions */
1951 (void) e1000g_tx_drain(Adapter
);
1953 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
1955 if (Adapter
->e1000g_state
& E1000G_SUSPENDED
) {
1956 rw_exit(&Adapter
->chip_lock
);
1959 Adapter
->e1000g_state
&= ~E1000G_STARTED
;
1960 e1000g_stop(Adapter
, B_TRUE
);
1962 rw_exit(&Adapter
->chip_lock
);
1964 /* Disable and stop all the timers */
1965 disable_watchdog_timer(Adapter
);
1966 stop_link_timer(Adapter
);
1967 stop_82547_timer(Adapter
->tx_ring
);
1971 e1000g_stop(struct e1000g
*Adapter
, boolean_t global
)
1973 private_devi_list_t
*devi_node
;
1974 e1000g_rx_data_t
*rx_data
;
1977 Adapter
->attach_progress
&= ~ATTACH_PROGRESS_INIT
;
1979 /* Stop the chip and release pending resources */
1981 /* Tell firmware driver is no longer in control */
1982 e1000g_release_driver_control(&Adapter
->shared
);
1984 e1000g_clear_all_interrupts(Adapter
);
1986 mutex_enter(&e1000g_nvm_lock
);
1987 result
= e1000_reset_hw(&Adapter
->shared
);
1988 mutex_exit(&e1000g_nvm_lock
);
1990 if (result
!= E1000_SUCCESS
) {
1991 e1000g_fm_ereport(Adapter
, DDI_FM_DEVICE_INVAL_STATE
);
1992 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_LOST
);
1995 mutex_enter(&Adapter
->link_lock
);
1996 Adapter
->link_complete
= B_FALSE
;
1997 mutex_exit(&Adapter
->link_lock
);
1999 /* Release resources still held by the TX descriptors */
2000 e1000g_tx_clean(Adapter
);
2002 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
)
2003 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_LOST
);
2005 /* Clean the pending rx jumbo packet fragment */
2006 e1000g_rx_clean(Adapter
);
2009 e1000g_release_dma_resources(Adapter
);
2011 mutex_enter(&e1000g_rx_detach_lock
);
2012 rx_data
= Adapter
->rx_ring
->rx_data
;
2013 rx_data
->flag
|= E1000G_RX_STOPPED
;
2015 if (rx_data
->pending_count
== 0) {
2016 e1000g_free_rx_pending_buffers(rx_data
);
2017 e1000g_free_rx_data(rx_data
);
2019 devi_node
= rx_data
->priv_devi_node
;
2020 if (devi_node
!= NULL
)
2021 atomic_inc_32(&devi_node
->pending_rx_count
);
2023 atomic_inc_32(&Adapter
->pending_rx_count
);
2025 mutex_exit(&e1000g_rx_detach_lock
);
2028 if (Adapter
->link_state
!= LINK_STATE_UNKNOWN
) {
2029 Adapter
->link_state
= LINK_STATE_UNKNOWN
;
2030 if (!Adapter
->reset_flag
)
2031 mac_link_update(Adapter
->mh
, Adapter
->link_state
);
2036 e1000g_rx_clean(struct e1000g
*Adapter
)
2038 e1000g_rx_data_t
*rx_data
= Adapter
->rx_ring
->rx_data
;
2040 if (rx_data
== NULL
)
2043 if (rx_data
->rx_mblk
!= NULL
) {
2044 freemsg(rx_data
->rx_mblk
);
2045 rx_data
->rx_mblk
= NULL
;
2046 rx_data
->rx_mblk_tail
= NULL
;
2047 rx_data
->rx_mblk_len
= 0;
2052 e1000g_tx_clean(struct e1000g
*Adapter
)
2054 e1000g_tx_ring_t
*tx_ring
;
2055 p_tx_sw_packet_t packet
;
2058 uint32_t packet_count
;
2060 tx_ring
= Adapter
->tx_ring
;
2063 * Here we don't need to protect the lists using
2064 * the usedlist_lock and freelist_lock, for they
2065 * have been protected by the chip_lock.
2070 packet
= (p_tx_sw_packet_t
)QUEUE_GET_HEAD(&tx_ring
->used_list
);
2071 while (packet
!= NULL
) {
2072 if (packet
->mp
!= NULL
) {
2073 /* Assemble the message chain */
2078 nmp
->b_next
= packet
->mp
;
2081 /* Disconnect the message from the sw packet */
2085 e1000g_free_tx_swpkt(packet
);
2088 packet
= (p_tx_sw_packet_t
)
2089 QUEUE_GET_NEXT(&tx_ring
->used_list
, &packet
->Link
);
2095 if (packet_count
> 0) {
2096 QUEUE_APPEND(&tx_ring
->free_list
, &tx_ring
->used_list
);
2097 QUEUE_INIT_LIST(&tx_ring
->used_list
);
2099 /* Setup TX descriptor pointers */
2100 tx_ring
->tbd_next
= tx_ring
->tbd_first
;
2101 tx_ring
->tbd_oldest
= tx_ring
->tbd_first
;
2103 /* Setup our HW Tx Head & Tail descriptor pointers */
2104 E1000_WRITE_REG(&Adapter
->shared
, E1000_TDH(0), 0);
2105 E1000_WRITE_REG(&Adapter
->shared
, E1000_TDT(0), 0);
2110 e1000g_tx_drain(struct e1000g
*Adapter
)
2114 e1000g_tx_ring_t
*tx_ring
;
2116 tx_ring
= Adapter
->tx_ring
;
2118 /* Allow up to 'wsdraintime' for pending xmit's to complete. */
2119 for (i
= 0; i
< TX_DRAIN_TIME
; i
++) {
2120 mutex_enter(&tx_ring
->usedlist_lock
);
2121 done
= IS_QUEUE_EMPTY(&tx_ring
->used_list
);
2122 mutex_exit(&tx_ring
->usedlist_lock
);
2134 e1000g_rx_drain(struct e1000g
*Adapter
)
2140 * Allow up to RX_DRAIN_TIME for pending received packets to complete.
2142 for (i
= 0; i
< RX_DRAIN_TIME
; i
++) {
2143 done
= (Adapter
->pending_rx_count
== 0);
2155 e1000g_reset_adapter(struct e1000g
*Adapter
)
2157 /* Disable and stop all the timers */
2158 disable_watchdog_timer(Adapter
);
2159 stop_link_timer(Adapter
);
2160 stop_82547_timer(Adapter
->tx_ring
);
2162 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
2164 if (Adapter
->stall_flag
) {
2165 Adapter
->stall_flag
= B_FALSE
;
2166 Adapter
->reset_flag
= B_TRUE
;
2169 if (!(Adapter
->e1000g_state
& E1000G_STARTED
)) {
2170 rw_exit(&Adapter
->chip_lock
);
2174 e1000g_stop(Adapter
, B_FALSE
);
2176 if (e1000g_start(Adapter
, B_FALSE
) != DDI_SUCCESS
) {
2177 rw_exit(&Adapter
->chip_lock
);
2178 e1000g_log(Adapter
, CE_WARN
, "Reset failed");
2182 rw_exit(&Adapter
->chip_lock
);
2184 /* Enable and start the watchdog timer */
2185 enable_watchdog_timer(Adapter
);
2191 e1000g_global_reset(struct e1000g
*Adapter
)
2193 /* Disable and stop all the timers */
2194 disable_watchdog_timer(Adapter
);
2195 stop_link_timer(Adapter
);
2196 stop_82547_timer(Adapter
->tx_ring
);
2198 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
2200 e1000g_stop(Adapter
, B_TRUE
);
2202 Adapter
->init_count
= 0;
2204 if (e1000g_start(Adapter
, B_TRUE
) != DDI_SUCCESS
) {
2205 rw_exit(&Adapter
->chip_lock
);
2206 e1000g_log(Adapter
, CE_WARN
, "Reset failed");
2210 rw_exit(&Adapter
->chip_lock
);
2212 /* Enable and start the watchdog timer */
2213 enable_watchdog_timer(Adapter
);
2219 * e1000g_intr_pciexpress - ISR for PCI Express chipsets
2221 * This interrupt service routine is for PCI-Express adapters.
2222 * The ICR contents is valid only when the E1000_ICR_INT_ASSERTED
2226 e1000g_intr_pciexpress(caddr_t arg
)
2228 struct e1000g
*Adapter
;
2231 Adapter
= (struct e1000g
*)(uintptr_t)arg
;
2232 icr
= E1000_READ_REG(&Adapter
->shared
, E1000_ICR
);
2234 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
2235 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_DEGRADED
);
2236 return (DDI_INTR_CLAIMED
);
2239 if (icr
& E1000_ICR_INT_ASSERTED
) {
2241 * E1000_ICR_INT_ASSERTED bit was set:
2242 * Read(Clear) the ICR, claim this interrupt,
2243 * look for work to do.
2245 e1000g_intr_work(Adapter
, icr
);
2246 return (DDI_INTR_CLAIMED
);
2249 * E1000_ICR_INT_ASSERTED bit was not set:
2250 * Don't claim this interrupt, return immediately.
2252 return (DDI_INTR_UNCLAIMED
);
2257 * e1000g_intr - ISR for PCI/PCI-X chipsets
2259 * This interrupt service routine is for PCI/PCI-X adapters.
2260 * We check the ICR contents no matter the E1000_ICR_INT_ASSERTED
2261 * bit is set or not.
2264 e1000g_intr(caddr_t arg
)
2266 struct e1000g
*Adapter
;
2269 Adapter
= (struct e1000g
*)(uintptr_t)arg
;
2270 icr
= E1000_READ_REG(&Adapter
->shared
, E1000_ICR
);
2272 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
2273 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_DEGRADED
);
2274 return (DDI_INTR_CLAIMED
);
2279 * Any bit was set in ICR:
2280 * Read(Clear) the ICR, claim this interrupt,
2281 * look for work to do.
2283 e1000g_intr_work(Adapter
, icr
);
2284 return (DDI_INTR_CLAIMED
);
2287 * No bit was set in ICR:
2288 * Don't claim this interrupt, return immediately.
2290 return (DDI_INTR_UNCLAIMED
);
2295 * e1000g_intr_work - actual processing of ISR
2297 * Read(clear) the ICR contents and call appropriate interrupt
2298 * processing routines.
2301 e1000g_intr_work(struct e1000g
*Adapter
, uint32_t icr
)
2303 struct e1000_hw
*hw
;
2304 hw
= &Adapter
->shared
;
2305 e1000g_tx_ring_t
*tx_ring
= Adapter
->tx_ring
;
2307 Adapter
->rx_pkt_cnt
= 0;
2308 Adapter
->tx_pkt_cnt
= 0;
2310 rw_enter(&Adapter
->chip_lock
, RW_READER
);
2312 if (Adapter
->e1000g_state
& E1000G_SUSPENDED
) {
2313 rw_exit(&Adapter
->chip_lock
);
2317 * Here we need to check the "e1000g_state" flag within the chip_lock to
2318 * ensure the receive routine will not execute when the adapter is
2321 if (!(Adapter
->e1000g_state
& E1000G_STARTED
)) {
2322 rw_exit(&Adapter
->chip_lock
);
2326 if (icr
& E1000_ICR_RXT0
) {
2328 mblk_t
*tail
= NULL
;
2329 e1000g_rx_ring_t
*rx_ring
;
2331 rx_ring
= Adapter
->rx_ring
;
2332 mutex_enter(&rx_ring
->rx_lock
);
2334 * Sometimes with legacy interrupts, it possible that
2335 * there is a single interrupt for Rx/Tx. In which
2336 * case, if poll flag is set, we shouldn't really
2337 * be doing Rx processing.
2339 if (!rx_ring
->poll_flag
)
2340 mp
= e1000g_receive(rx_ring
, &tail
,
2341 E1000G_CHAIN_NO_LIMIT
);
2342 mutex_exit(&rx_ring
->rx_lock
);
2343 rw_exit(&Adapter
->chip_lock
);
2345 mac_rx_ring(Adapter
->mh
, rx_ring
->mrh
,
2346 mp
, rx_ring
->ring_gen_num
);
2348 rw_exit(&Adapter
->chip_lock
);
2350 if (icr
& E1000_ICR_TXDW
) {
2351 if (!Adapter
->tx_intr_enable
)
2352 e1000g_clear_tx_interrupt(Adapter
);
2354 /* Recycle the tx descriptors */
2355 rw_enter(&Adapter
->chip_lock
, RW_READER
);
2356 (void) e1000g_recycle(tx_ring
);
2357 E1000G_DEBUG_STAT(tx_ring
->stat_recycle_intr
);
2358 rw_exit(&Adapter
->chip_lock
);
2360 if (tx_ring
->resched_needed
&&
2361 (tx_ring
->tbd_avail
> DEFAULT_TX_UPDATE_THRESHOLD
)) {
2362 tx_ring
->resched_needed
= B_FALSE
;
2363 mac_tx_update(Adapter
->mh
);
2364 E1000G_STAT(tx_ring
->stat_reschedule
);
2369 * The Receive Sequence errors RXSEQ and the link status change LSC
2370 * are checked to detect that the cable has been pulled out. For
2371 * the Wiseman 2.0 silicon, the receive sequence errors interrupt
2372 * are an indication that cable is not connected.
2374 if ((icr
& E1000_ICR_RXSEQ
) ||
2375 (icr
& E1000_ICR_LSC
) ||
2376 (icr
& E1000_ICR_GPI_EN1
)) {
2377 boolean_t link_changed
;
2378 timeout_id_t tid
= 0;
2380 stop_watchdog_timer(Adapter
);
2382 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
2385 * Because we got a link-status-change interrupt, force
2386 * e1000_check_for_link() to look at phy
2388 Adapter
->shared
.mac
.get_link_status
= B_TRUE
;
2390 /* e1000g_link_check takes care of link status change */
2391 link_changed
= e1000g_link_check(Adapter
);
2393 /* Get new phy state */
2394 e1000g_get_phy_state(Adapter
);
2397 * If the link timer has not timed out, we'll not notify
2398 * the upper layer with any link state until the link is up.
2400 if (link_changed
&& !Adapter
->link_complete
) {
2401 if (Adapter
->link_state
== LINK_STATE_UP
) {
2402 mutex_enter(&Adapter
->link_lock
);
2403 Adapter
->link_complete
= B_TRUE
;
2404 tid
= Adapter
->link_tid
;
2405 Adapter
->link_tid
= 0;
2406 mutex_exit(&Adapter
->link_lock
);
2408 link_changed
= B_FALSE
;
2411 rw_exit(&Adapter
->chip_lock
);
2415 (void) untimeout(tid
);
2418 * Workaround for esb2. Data stuck in fifo on a link
2419 * down event. Stop receiver here and reset in watchdog.
2421 if ((Adapter
->link_state
== LINK_STATE_DOWN
) &&
2422 (Adapter
->shared
.mac
.type
== e1000_80003es2lan
)) {
2423 uint32_t rctl
= E1000_READ_REG(hw
, E1000_RCTL
);
2424 E1000_WRITE_REG(hw
, E1000_RCTL
,
2425 rctl
& ~E1000_RCTL_EN
);
2426 e1000g_log(Adapter
, CE_WARN
,
2427 "ESB2 receiver disabled");
2428 Adapter
->esb2_workaround
= B_TRUE
;
2430 if (!Adapter
->reset_flag
)
2431 mac_link_update(Adapter
->mh
,
2432 Adapter
->link_state
);
2433 if (Adapter
->link_state
== LINK_STATE_UP
)
2434 Adapter
->reset_flag
= B_FALSE
;
2437 start_watchdog_timer(Adapter
);
2442 e1000g_init_unicst(struct e1000g
*Adapter
)
2444 struct e1000_hw
*hw
;
2447 hw
= &Adapter
->shared
;
2449 if (Adapter
->init_count
== 0) {
2450 /* Initialize the multiple unicast addresses */
2451 Adapter
->unicst_total
= min(hw
->mac
.rar_entry_count
,
2452 MAX_NUM_UNICAST_ADDRESSES
);
2455 * The common code does not correctly calculate the number of
2456 * rar's that could be reserved by firmware for the pch_lpt
2457 * macs. The interface has one primary rar, and 11 additional
2458 * ones. Those 11 additional ones are not always available.
2459 * According to the datasheet, we need to check a few of the
2460 * bits set in the FWSM register. If the value is zero,
2461 * everything is available. If the value is 1, none of the
2462 * additional registers are available. If the value is 2-7, only
2463 * that number are available.
2465 if (hw
->mac
.type
== e1000_pch_lpt
) {
2466 uint32_t locked
, rar
;
2468 locked
= E1000_READ_REG(hw
, E1000_FWSM
) &
2469 E1000_FWSM_WLOCK_MAC_MASK
;
2470 locked
>>= E1000_FWSM_WLOCK_MAC_SHIFT
;
2474 else if (locked
== 1)
2478 Adapter
->unicst_total
= min(rar
,
2479 MAX_NUM_UNICAST_ADDRESSES
);
2482 /* Workaround for an erratum of 82571 chipst */
2483 if ((hw
->mac
.type
== e1000_82571
) &&
2484 (e1000_get_laa_state_82571(hw
) == B_TRUE
))
2485 Adapter
->unicst_total
--;
2487 /* VMware doesn't support multiple mac addresses properly */
2488 if (hw
->subsystem_vendor_id
== 0x15ad)
2489 Adapter
->unicst_total
= 1;
2491 Adapter
->unicst_avail
= Adapter
->unicst_total
;
2493 for (slot
= 0; slot
< Adapter
->unicst_total
; slot
++) {
2494 /* Clear both the flag and MAC address */
2495 Adapter
->unicst_addr
[slot
].reg
.high
= 0;
2496 Adapter
->unicst_addr
[slot
].reg
.low
= 0;
2499 /* Workaround for an erratum of 82571 chipst */
2500 if ((hw
->mac
.type
== e1000_82571
) &&
2501 (e1000_get_laa_state_82571(hw
) == B_TRUE
))
2502 (void) e1000_rar_set(hw
, hw
->mac
.addr
, LAST_RAR_ENTRY
);
2504 /* Re-configure the RAR registers */
2505 for (slot
= 0; slot
< Adapter
->unicst_total
; slot
++)
2506 if (Adapter
->unicst_addr
[slot
].mac
.set
== 1)
2507 (void) e1000_rar_set(hw
,
2508 Adapter
->unicst_addr
[slot
].mac
.addr
, slot
);
2511 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
)
2512 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_DEGRADED
);
2516 e1000g_unicst_set(struct e1000g
*Adapter
, const uint8_t *mac_addr
,
2519 struct e1000_hw
*hw
;
2521 hw
= &Adapter
->shared
;
2524 * The first revision of Wiseman silicon (rev 2.0) has an errata
2525 * that requires the receiver to be in reset when any of the
2526 * receive address registers (RAR regs) are accessed. The first
2527 * rev of Wiseman silicon also requires MWI to be disabled when
2528 * a global reset or a receive reset is issued. So before we
2529 * initialize the RARs, we check the rev of the Wiseman controller
2530 * and work around any necessary HW errata.
2532 if ((hw
->mac
.type
== e1000_82542
) &&
2533 (hw
->revision_id
== E1000_REVISION_2
)) {
2534 e1000_pci_clear_mwi(hw
);
2535 E1000_WRITE_REG(hw
, E1000_RCTL
, E1000_RCTL_RST
);
2538 if (mac_addr
== NULL
) {
2539 E1000_WRITE_REG_ARRAY(hw
, E1000_RA
, slot
<< 1, 0);
2540 E1000_WRITE_FLUSH(hw
);
2541 E1000_WRITE_REG_ARRAY(hw
, E1000_RA
, (slot
<< 1) + 1, 0);
2542 E1000_WRITE_FLUSH(hw
);
2543 /* Clear both the flag and MAC address */
2544 Adapter
->unicst_addr
[slot
].reg
.high
= 0;
2545 Adapter
->unicst_addr
[slot
].reg
.low
= 0;
2547 bcopy(mac_addr
, Adapter
->unicst_addr
[slot
].mac
.addr
,
2549 (void) e1000_rar_set(hw
, (uint8_t *)mac_addr
, slot
);
2550 Adapter
->unicst_addr
[slot
].mac
.set
= 1;
2553 /* Workaround for an erratum of 82571 chipst */
2555 if ((hw
->mac
.type
== e1000_82571
) &&
2556 (e1000_get_laa_state_82571(hw
) == B_TRUE
))
2557 if (mac_addr
== NULL
) {
2558 E1000_WRITE_REG_ARRAY(hw
, E1000_RA
,
2560 E1000_WRITE_FLUSH(hw
);
2561 E1000_WRITE_REG_ARRAY(hw
, E1000_RA
,
2562 (slot
<< 1) + 1, 0);
2563 E1000_WRITE_FLUSH(hw
);
2565 (void) e1000_rar_set(hw
, (uint8_t *)mac_addr
,
2571 * If we are using Wiseman rev 2.0 silicon, we will have previously
2572 * put the receive in reset, and disabled MWI, to work around some
2573 * HW errata. Now we should take the receiver out of reset, and
2574 * re-enabled if MWI if it was previously enabled by the PCI BIOS.
2576 if ((hw
->mac
.type
== e1000_82542
) &&
2577 (hw
->revision_id
== E1000_REVISION_2
)) {
2578 E1000_WRITE_REG(hw
, E1000_RCTL
, 0);
2580 if (hw
->bus
.pci_cmd_word
& CMD_MEM_WRT_INVALIDATE
)
2581 e1000_pci_set_mwi(hw
);
2582 e1000g_rx_setup(Adapter
);
2585 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
2586 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_DEGRADED
);
2594 multicst_add(struct e1000g
*Adapter
, const uint8_t *multiaddr
)
2596 struct e1000_hw
*hw
= &Adapter
->shared
;
2597 struct ether_addr
*newtable
;
2602 if ((multiaddr
[0] & 01) == 0) {
2604 e1000g_log(Adapter
, CE_WARN
, "Illegal multicast address");
2608 if (Adapter
->mcast_count
>= Adapter
->mcast_max_num
) {
2610 e1000g_log(Adapter
, CE_WARN
,
2611 "Adapter requested more than %d mcast addresses",
2612 Adapter
->mcast_max_num
);
2617 if (Adapter
->mcast_count
== Adapter
->mcast_alloc_count
) {
2618 old_len
= Adapter
->mcast_alloc_count
*
2619 sizeof (struct ether_addr
);
2620 new_len
= (Adapter
->mcast_alloc_count
+ MCAST_ALLOC_SIZE
) *
2621 sizeof (struct ether_addr
);
2623 newtable
= kmem_alloc(new_len
, KM_NOSLEEP
);
2624 if (newtable
== NULL
) {
2626 e1000g_log(Adapter
, CE_WARN
,
2627 "Not enough memory to alloc mcast table");
2631 if (Adapter
->mcast_table
!= NULL
) {
2632 bcopy(Adapter
->mcast_table
, newtable
, old_len
);
2633 kmem_free(Adapter
->mcast_table
, old_len
);
2635 Adapter
->mcast_alloc_count
+= MCAST_ALLOC_SIZE
;
2636 Adapter
->mcast_table
= newtable
;
2640 &Adapter
->mcast_table
[Adapter
->mcast_count
], ETHERADDRL
);
2641 Adapter
->mcast_count
++;
2644 * Update the MC table in the hardware
2646 e1000g_clear_interrupt(Adapter
);
2648 e1000_update_mc_addr_list(hw
,
2649 (uint8_t *)Adapter
->mcast_table
, Adapter
->mcast_count
);
2651 e1000g_mask_interrupt(Adapter
);
2653 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
2654 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_DEGRADED
);
2663 multicst_remove(struct e1000g
*Adapter
, const uint8_t *multiaddr
)
2665 struct e1000_hw
*hw
= &Adapter
->shared
;
2666 struct ether_addr
*newtable
;
2671 for (i
= 0; i
< Adapter
->mcast_count
; i
++) {
2672 if (bcmp(multiaddr
, &Adapter
->mcast_table
[i
],
2674 for (i
++; i
< Adapter
->mcast_count
; i
++) {
2675 Adapter
->mcast_table
[i
- 1] =
2676 Adapter
->mcast_table
[i
];
2678 Adapter
->mcast_count
--;
2683 if ((Adapter
->mcast_alloc_count
- Adapter
->mcast_count
) >
2685 old_len
= Adapter
->mcast_alloc_count
*
2686 sizeof (struct ether_addr
);
2687 new_len
= (Adapter
->mcast_alloc_count
- MCAST_ALLOC_SIZE
) *
2688 sizeof (struct ether_addr
);
2690 newtable
= kmem_alloc(new_len
, KM_NOSLEEP
);
2691 if (newtable
!= NULL
) {
2692 bcopy(Adapter
->mcast_table
, newtable
, new_len
);
2693 kmem_free(Adapter
->mcast_table
, old_len
);
2695 Adapter
->mcast_alloc_count
-= MCAST_ALLOC_SIZE
;
2696 Adapter
->mcast_table
= newtable
;
2701 * Update the MC table in the hardware
2703 e1000g_clear_interrupt(Adapter
);
2705 e1000_update_mc_addr_list(hw
,
2706 (uint8_t *)Adapter
->mcast_table
, Adapter
->mcast_count
);
2708 e1000g_mask_interrupt(Adapter
);
2710 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
2711 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_DEGRADED
);
2719 e1000g_release_multicast(struct e1000g
*Adapter
)
2721 if (Adapter
->mcast_table
!= NULL
) {
2722 kmem_free(Adapter
->mcast_table
,
2723 Adapter
->mcast_alloc_count
* sizeof (struct ether_addr
));
2724 Adapter
->mcast_table
= NULL
;
2729 e1000g_m_multicst(void *arg
, boolean_t add
, const uint8_t *addr
)
2731 struct e1000g
*Adapter
= (struct e1000g
*)arg
;
2734 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
2736 if (Adapter
->e1000g_state
& E1000G_SUSPENDED
) {
2741 result
= (add
) ? multicst_add(Adapter
, addr
)
2742 : multicst_remove(Adapter
, addr
);
2745 rw_exit(&Adapter
->chip_lock
);
2751 e1000g_m_promisc(void *arg
, boolean_t on
)
2753 struct e1000g
*Adapter
= (struct e1000g
*)arg
;
2756 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
2758 if (Adapter
->e1000g_state
& E1000G_SUSPENDED
) {
2759 rw_exit(&Adapter
->chip_lock
);
2763 rctl
= E1000_READ_REG(&Adapter
->shared
, E1000_RCTL
);
2767 (E1000_RCTL_UPE
| E1000_RCTL_MPE
| E1000_RCTL_BAM
);
2769 rctl
&= (~(E1000_RCTL_UPE
| E1000_RCTL_MPE
));
2771 E1000_WRITE_REG(&Adapter
->shared
, E1000_RCTL
, rctl
);
2773 Adapter
->e1000g_promisc
= on
;
2775 rw_exit(&Adapter
->chip_lock
);
2777 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
2778 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_DEGRADED
);
2786 * Entry points to enable and disable interrupts at the granularity of
2788 * Turns the poll_mode for the whole adapter on and off to enable or
2789 * override the ring level polling control over the hardware interrupts.
2792 e1000g_rx_group_intr_enable(mac_intr_handle_t arg
)
2794 struct e1000g
*adapter
= (struct e1000g
*)arg
;
2795 e1000g_rx_ring_t
*rx_ring
= adapter
->rx_ring
;
2798 * Later interrupts at the granularity of the this ring will
2799 * invoke mac_rx() with NULL, indicating the need for another
2800 * software classification.
2801 * We have a single ring usable per adapter now, so we only need to
2802 * reset the rx handle for that one.
2803 * When more RX rings can be used, we should update each one of them.
2805 mutex_enter(&rx_ring
->rx_lock
);
2806 rx_ring
->mrh
= NULL
;
2807 adapter
->poll_mode
= B_FALSE
;
2808 mutex_exit(&rx_ring
->rx_lock
);
2813 e1000g_rx_group_intr_disable(mac_intr_handle_t arg
)
2815 struct e1000g
*adapter
= (struct e1000g
*)arg
;
2816 e1000g_rx_ring_t
*rx_ring
= adapter
->rx_ring
;
2818 mutex_enter(&rx_ring
->rx_lock
);
2821 * Later interrupts at the granularity of the this ring will
2822 * invoke mac_rx() with the handle for this ring;
2824 adapter
->poll_mode
= B_TRUE
;
2825 rx_ring
->mrh
= rx_ring
->mrh_init
;
2826 mutex_exit(&rx_ring
->rx_lock
);
2831 * Entry points to enable and disable interrupts at the granularity of
2833 * adapter poll_mode controls whether we actually proceed with hardware
2834 * interrupt toggling.
2837 e1000g_rx_ring_intr_enable(mac_intr_handle_t intrh
)
2839 e1000g_rx_ring_t
*rx_ring
= (e1000g_rx_ring_t
*)intrh
;
2840 struct e1000g
*adapter
= rx_ring
->adapter
;
2841 struct e1000_hw
*hw
= &adapter
->shared
;
2844 rw_enter(&adapter
->chip_lock
, RW_READER
);
2846 if (adapter
->e1000g_state
& E1000G_SUSPENDED
) {
2847 rw_exit(&adapter
->chip_lock
);
2851 mutex_enter(&rx_ring
->rx_lock
);
2852 rx_ring
->poll_flag
= 0;
2853 mutex_exit(&rx_ring
->rx_lock
);
2855 /* Rx interrupt enabling for MSI and legacy */
2856 intr_mask
= E1000_READ_REG(hw
, E1000_IMS
);
2857 intr_mask
|= E1000_IMS_RXT0
;
2858 E1000_WRITE_REG(hw
, E1000_IMS
, intr_mask
);
2859 E1000_WRITE_FLUSH(hw
);
2861 /* Trigger a Rx interrupt to check Rx ring */
2862 E1000_WRITE_REG(hw
, E1000_ICS
, E1000_IMS_RXT0
);
2863 E1000_WRITE_FLUSH(hw
);
2865 rw_exit(&adapter
->chip_lock
);
2870 e1000g_rx_ring_intr_disable(mac_intr_handle_t intrh
)
2872 e1000g_rx_ring_t
*rx_ring
= (e1000g_rx_ring_t
*)intrh
;
2873 struct e1000g
*adapter
= rx_ring
->adapter
;
2874 struct e1000_hw
*hw
= &adapter
->shared
;
2876 rw_enter(&adapter
->chip_lock
, RW_READER
);
2878 if (adapter
->e1000g_state
& E1000G_SUSPENDED
) {
2879 rw_exit(&adapter
->chip_lock
);
2882 mutex_enter(&rx_ring
->rx_lock
);
2883 rx_ring
->poll_flag
= 1;
2884 mutex_exit(&rx_ring
->rx_lock
);
2886 /* Rx interrupt disabling for MSI and legacy */
2887 E1000_WRITE_REG(hw
, E1000_IMC
, E1000_IMS_RXT0
);
2888 E1000_WRITE_FLUSH(hw
);
2890 rw_exit(&adapter
->chip_lock
);
2895 * e1000g_unicst_find - Find the slot for the specified unicast address
2898 e1000g_unicst_find(struct e1000g
*Adapter
, const uint8_t *mac_addr
)
2902 for (slot
= 0; slot
< Adapter
->unicst_total
; slot
++) {
2903 if ((Adapter
->unicst_addr
[slot
].mac
.set
== 1) &&
2904 (bcmp(Adapter
->unicst_addr
[slot
].mac
.addr
,
2905 mac_addr
, ETHERADDRL
) == 0))
2913 * Entry points to add and remove a MAC address to a ring group.
2914 * The caller takes care of adding and removing the MAC addresses
2915 * to the filter via these two routines.
2919 e1000g_addmac(void *arg
, const uint8_t *mac_addr
)
2921 struct e1000g
*Adapter
= (struct e1000g
*)arg
;
2924 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
2926 if (Adapter
->e1000g_state
& E1000G_SUSPENDED
) {
2927 rw_exit(&Adapter
->chip_lock
);
2931 if (e1000g_unicst_find(Adapter
, mac_addr
) != -1) {
2932 /* The same address is already in slot */
2933 rw_exit(&Adapter
->chip_lock
);
2937 if (Adapter
->unicst_avail
== 0) {
2938 /* no slots available */
2939 rw_exit(&Adapter
->chip_lock
);
2943 /* Search for a free slot */
2944 for (slot
= 0; slot
< Adapter
->unicst_total
; slot
++) {
2945 if (Adapter
->unicst_addr
[slot
].mac
.set
== 0)
2948 ASSERT(slot
< Adapter
->unicst_total
);
2950 err
= e1000g_unicst_set(Adapter
, mac_addr
, slot
);
2952 Adapter
->unicst_avail
--;
2954 rw_exit(&Adapter
->chip_lock
);
2960 e1000g_remmac(void *arg
, const uint8_t *mac_addr
)
2962 struct e1000g
*Adapter
= (struct e1000g
*)arg
;
2965 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
2967 if (Adapter
->e1000g_state
& E1000G_SUSPENDED
) {
2968 rw_exit(&Adapter
->chip_lock
);
2972 slot
= e1000g_unicst_find(Adapter
, mac_addr
);
2974 rw_exit(&Adapter
->chip_lock
);
2978 ASSERT(Adapter
->unicst_addr
[slot
].mac
.set
);
2980 /* Clear this slot */
2981 err
= e1000g_unicst_set(Adapter
, NULL
, slot
);
2983 Adapter
->unicst_avail
++;
2985 rw_exit(&Adapter
->chip_lock
);
2991 e1000g_ring_start(mac_ring_driver_t rh
, uint64_t mr_gen_num
)
2993 e1000g_rx_ring_t
*rx_ring
= (e1000g_rx_ring_t
*)rh
;
2995 mutex_enter(&rx_ring
->rx_lock
);
2996 rx_ring
->ring_gen_num
= mr_gen_num
;
2997 mutex_exit(&rx_ring
->rx_lock
);
3002 * Callback funtion for MAC layer to register all rings.
3004 * The hardware supports a single group with currently only one ring
3006 * Though not offering virtualization ability per se, exposing the
3007 * group/ring still enables the polling and interrupt toggling.
3011 e1000g_fill_ring(void *arg
, mac_ring_type_t rtype
, const int grp_index
,
3012 const int ring_index
, mac_ring_info_t
*infop
, mac_ring_handle_t rh
)
3014 struct e1000g
*Adapter
= (struct e1000g
*)arg
;
3015 e1000g_rx_ring_t
*rx_ring
= Adapter
->rx_ring
;
3019 * We advertised only RX group/rings, so the MAC framework shouldn't
3020 * ask for any thing else.
3022 ASSERT(rtype
== MAC_RING_TYPE_RX
&& grp_index
== 0 && ring_index
== 0);
3024 rx_ring
->mrh
= rx_ring
->mrh_init
= rh
;
3025 infop
->mri_driver
= (mac_ring_driver_t
)rx_ring
;
3026 infop
->mri_start
= e1000g_ring_start
;
3027 infop
->mri_stop
= NULL
;
3028 infop
->mri_poll
= e1000g_poll_ring
;
3029 infop
->mri_stat
= e1000g_rx_ring_stat
;
3031 /* Ring level interrupts */
3032 mintr
= &infop
->mri_intr
;
3033 mintr
->mi_handle
= (mac_intr_handle_t
)rx_ring
;
3034 mintr
->mi_enable
= e1000g_rx_ring_intr_enable
;
3035 mintr
->mi_disable
= e1000g_rx_ring_intr_disable
;
3036 if (Adapter
->msi_enable
)
3037 mintr
->mi_ddi_handle
= Adapter
->htable
[0];
3042 e1000g_fill_group(void *arg
, mac_ring_type_t rtype
, const int grp_index
,
3043 mac_group_info_t
*infop
, mac_group_handle_t gh
)
3045 struct e1000g
*Adapter
= (struct e1000g
*)arg
;
3049 * We advertised a single RX ring. Getting a request for anything else
3050 * signifies a bug in the MAC framework.
3052 ASSERT(rtype
== MAC_RING_TYPE_RX
&& grp_index
== 0);
3054 Adapter
->rx_group
= gh
;
3056 infop
->mgi_driver
= (mac_group_driver_t
)Adapter
;
3057 infop
->mgi_start
= NULL
;
3058 infop
->mgi_stop
= NULL
;
3059 infop
->mgi_addmac
= e1000g_addmac
;
3060 infop
->mgi_remmac
= e1000g_remmac
;
3061 infop
->mgi_count
= 1;
3063 /* Group level interrupts */
3064 mintr
= &infop
->mgi_intr
;
3065 mintr
->mi_handle
= (mac_intr_handle_t
)Adapter
;
3066 mintr
->mi_enable
= e1000g_rx_group_intr_enable
;
3067 mintr
->mi_disable
= e1000g_rx_group_intr_disable
;
3071 e1000g_m_getcapab(void *arg
, mac_capab_t cap
, void *cap_data
)
3073 struct e1000g
*Adapter
= (struct e1000g
*)arg
;
3076 case MAC_CAPAB_HCKSUM
: {
3077 uint32_t *txflags
= cap_data
;
3079 if (Adapter
->tx_hcksum_enable
)
3080 *txflags
= HCKSUM_IPHDRCKSUM
|
3081 HCKSUM_INET_PARTIAL
;
3087 case MAC_CAPAB_LSO
: {
3088 mac_capab_lso_t
*cap_lso
= cap_data
;
3090 if (Adapter
->lso_enable
) {
3091 cap_lso
->lso_flags
= LSO_TX_BASIC_TCP_IPV4
;
3092 cap_lso
->lso_basic_tcp_ipv4
.lso_max
=
3098 case MAC_CAPAB_RINGS
: {
3099 mac_capab_rings_t
*cap_rings
= cap_data
;
3101 /* No TX rings exposed yet */
3102 if (cap_rings
->mr_type
!= MAC_RING_TYPE_RX
)
3105 cap_rings
->mr_group_type
= MAC_GROUP_TYPE_STATIC
;
3106 cap_rings
->mr_rnum
= 1;
3107 cap_rings
->mr_gnum
= 1;
3108 cap_rings
->mr_rget
= e1000g_fill_ring
;
3109 cap_rings
->mr_gget
= e1000g_fill_group
;
3119 e1000g_param_locked(mac_prop_id_t pr_num
)
3122 * All en_* parameters are locked (read-only) while
3123 * the device is in any sort of loopback mode ...
3126 case MAC_PROP_EN_1000FDX_CAP
:
3127 case MAC_PROP_EN_1000HDX_CAP
:
3128 case MAC_PROP_EN_100FDX_CAP
:
3129 case MAC_PROP_EN_100HDX_CAP
:
3130 case MAC_PROP_EN_10FDX_CAP
:
3131 case MAC_PROP_EN_10HDX_CAP
:
3132 case MAC_PROP_AUTONEG
:
3133 case MAC_PROP_FLOWCTRL
:
3140 * callback function for set/get of properties
3143 e1000g_m_setprop(void *arg
, const char *pr_name
, mac_prop_id_t pr_num
,
3144 uint_t pr_valsize
, const void *pr_val
)
3146 struct e1000g
*Adapter
= arg
;
3147 struct e1000_hw
*hw
= &Adapter
->shared
;
3148 struct e1000_fc_info
*fc
= &Adapter
->shared
.fc
;
3150 link_flowctrl_t flowctrl
;
3151 uint32_t cur_mtu
, new_mtu
;
3153 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
3155 if (Adapter
->e1000g_state
& E1000G_SUSPENDED
) {
3156 rw_exit(&Adapter
->chip_lock
);
3160 if (Adapter
->loopback_mode
!= E1000G_LB_NONE
&&
3161 e1000g_param_locked(pr_num
)) {
3163 * All en_* parameters are locked (read-only)
3164 * while the device is in any sort of loopback mode.
3166 rw_exit(&Adapter
->chip_lock
);
3171 case MAC_PROP_EN_1000FDX_CAP
:
3172 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3176 Adapter
->param_en_1000fdx
= *(uint8_t *)pr_val
;
3177 Adapter
->param_adv_1000fdx
= *(uint8_t *)pr_val
;
3179 case MAC_PROP_EN_100FDX_CAP
:
3180 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3184 Adapter
->param_en_100fdx
= *(uint8_t *)pr_val
;
3185 Adapter
->param_adv_100fdx
= *(uint8_t *)pr_val
;
3187 case MAC_PROP_EN_100HDX_CAP
:
3188 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3192 Adapter
->param_en_100hdx
= *(uint8_t *)pr_val
;
3193 Adapter
->param_adv_100hdx
= *(uint8_t *)pr_val
;
3195 case MAC_PROP_EN_10FDX_CAP
:
3196 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3200 Adapter
->param_en_10fdx
= *(uint8_t *)pr_val
;
3201 Adapter
->param_adv_10fdx
= *(uint8_t *)pr_val
;
3203 case MAC_PROP_EN_10HDX_CAP
:
3204 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3208 Adapter
->param_en_10hdx
= *(uint8_t *)pr_val
;
3209 Adapter
->param_adv_10hdx
= *(uint8_t *)pr_val
;
3211 case MAC_PROP_AUTONEG
:
3212 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3216 Adapter
->param_adv_autoneg
= *(uint8_t *)pr_val
;
3218 case MAC_PROP_FLOWCTRL
:
3219 fc
->send_xon
= B_TRUE
;
3220 bcopy(pr_val
, &flowctrl
, sizeof (flowctrl
));
3226 case LINK_FLOWCTRL_NONE
:
3227 fc
->requested_mode
= e1000_fc_none
;
3229 case LINK_FLOWCTRL_RX
:
3230 fc
->requested_mode
= e1000_fc_rx_pause
;
3232 case LINK_FLOWCTRL_TX
:
3233 fc
->requested_mode
= e1000_fc_tx_pause
;
3235 case LINK_FLOWCTRL_BI
:
3236 fc
->requested_mode
= e1000_fc_full
;
3241 /* check PCH limits & reset the link */
3242 e1000g_pch_limits(Adapter
);
3243 if (e1000g_reset_link(Adapter
) != DDI_SUCCESS
)
3247 case MAC_PROP_ADV_1000FDX_CAP
:
3248 case MAC_PROP_ADV_1000HDX_CAP
:
3249 case MAC_PROP_ADV_100FDX_CAP
:
3250 case MAC_PROP_ADV_100HDX_CAP
:
3251 case MAC_PROP_ADV_10FDX_CAP
:
3252 case MAC_PROP_ADV_10HDX_CAP
:
3253 case MAC_PROP_EN_1000HDX_CAP
:
3254 case MAC_PROP_STATUS
:
3255 case MAC_PROP_SPEED
:
3256 case MAC_PROP_DUPLEX
:
3257 err
= ENOTSUP
; /* read-only prop. Can't set this. */
3260 /* adapter must be stopped for an MTU change */
3261 if (Adapter
->e1000g_state
& E1000G_STARTED
) {
3266 cur_mtu
= Adapter
->default_mtu
;
3268 /* get new requested MTU */
3269 bcopy(pr_val
, &new_mtu
, sizeof (new_mtu
));
3270 if (new_mtu
== cur_mtu
) {
3275 if ((new_mtu
< DEFAULT_MTU
) ||
3276 (new_mtu
> Adapter
->max_mtu
)) {
3281 /* inform MAC framework of new MTU */
3282 err
= mac_maxsdu_update(Adapter
->mh
, new_mtu
);
3285 Adapter
->default_mtu
= new_mtu
;
3286 Adapter
->max_frame_size
=
3287 e1000g_mtu2maxframe(new_mtu
);
3290 * check PCH limits & set buffer sizes to
3293 e1000g_pch_limits(Adapter
);
3294 e1000g_set_bufsize(Adapter
);
3297 * decrease the number of descriptors and free
3298 * packets for jumbo frames to reduce tx/rx
3299 * resource consumption
3301 if (Adapter
->max_frame_size
>=
3302 (FRAME_SIZE_UPTO_4K
)) {
3303 if (Adapter
->tx_desc_num_flag
== 0)
3304 Adapter
->tx_desc_num
=
3305 DEFAULT_JUMBO_NUM_TX_DESC
;
3307 if (Adapter
->rx_desc_num_flag
== 0)
3308 Adapter
->rx_desc_num
=
3309 DEFAULT_JUMBO_NUM_RX_DESC
;
3311 if (Adapter
->tx_buf_num_flag
== 0)
3312 Adapter
->tx_freelist_num
=
3313 DEFAULT_JUMBO_NUM_TX_BUF
;
3315 if (Adapter
->rx_buf_num_flag
== 0)
3316 Adapter
->rx_freelist_limit
=
3317 DEFAULT_JUMBO_NUM_RX_BUF
;
3319 if (Adapter
->tx_desc_num_flag
== 0)
3320 Adapter
->tx_desc_num
=
3321 DEFAULT_NUM_TX_DESCRIPTOR
;
3323 if (Adapter
->rx_desc_num_flag
== 0)
3324 Adapter
->rx_desc_num
=
3325 DEFAULT_NUM_RX_DESCRIPTOR
;
3327 if (Adapter
->tx_buf_num_flag
== 0)
3328 Adapter
->tx_freelist_num
=
3329 DEFAULT_NUM_TX_FREELIST
;
3331 if (Adapter
->rx_buf_num_flag
== 0)
3332 Adapter
->rx_freelist_limit
=
3333 DEFAULT_NUM_RX_FREELIST
;
3337 case MAC_PROP_PRIVATE
:
3338 err
= e1000g_set_priv_prop(Adapter
, pr_name
,
3339 pr_valsize
, pr_val
);
3345 rw_exit(&Adapter
->chip_lock
);
3350 e1000g_m_getprop(void *arg
, const char *pr_name
, mac_prop_id_t pr_num
,
3351 uint_t pr_valsize
, void *pr_val
)
3353 struct e1000g
*Adapter
= arg
;
3354 struct e1000_fc_info
*fc
= &Adapter
->shared
.fc
;
3356 link_flowctrl_t flowctrl
;
3360 case MAC_PROP_DUPLEX
:
3361 ASSERT(pr_valsize
>= sizeof (link_duplex_t
));
3362 bcopy(&Adapter
->link_duplex
, pr_val
,
3363 sizeof (link_duplex_t
));
3365 case MAC_PROP_SPEED
:
3366 ASSERT(pr_valsize
>= sizeof (uint64_t));
3367 tmp
= Adapter
->link_speed
* 1000000ull;
3368 bcopy(&tmp
, pr_val
, sizeof (tmp
));
3370 case MAC_PROP_AUTONEG
:
3371 *(uint8_t *)pr_val
= Adapter
->param_adv_autoneg
;
3373 case MAC_PROP_FLOWCTRL
:
3374 ASSERT(pr_valsize
>= sizeof (link_flowctrl_t
));
3375 switch (fc
->current_mode
) {
3377 flowctrl
= LINK_FLOWCTRL_NONE
;
3379 case e1000_fc_rx_pause
:
3380 flowctrl
= LINK_FLOWCTRL_RX
;
3382 case e1000_fc_tx_pause
:
3383 flowctrl
= LINK_FLOWCTRL_TX
;
3386 flowctrl
= LINK_FLOWCTRL_BI
;
3389 bcopy(&flowctrl
, pr_val
, sizeof (flowctrl
));
3391 case MAC_PROP_ADV_1000FDX_CAP
:
3392 *(uint8_t *)pr_val
= Adapter
->param_adv_1000fdx
;
3394 case MAC_PROP_EN_1000FDX_CAP
:
3395 *(uint8_t *)pr_val
= Adapter
->param_en_1000fdx
;
3397 case MAC_PROP_ADV_1000HDX_CAP
:
3398 *(uint8_t *)pr_val
= Adapter
->param_adv_1000hdx
;
3400 case MAC_PROP_EN_1000HDX_CAP
:
3401 *(uint8_t *)pr_val
= Adapter
->param_en_1000hdx
;
3403 case MAC_PROP_ADV_100FDX_CAP
:
3404 *(uint8_t *)pr_val
= Adapter
->param_adv_100fdx
;
3406 case MAC_PROP_EN_100FDX_CAP
:
3407 *(uint8_t *)pr_val
= Adapter
->param_en_100fdx
;
3409 case MAC_PROP_ADV_100HDX_CAP
:
3410 *(uint8_t *)pr_val
= Adapter
->param_adv_100hdx
;
3412 case MAC_PROP_EN_100HDX_CAP
:
3413 *(uint8_t *)pr_val
= Adapter
->param_en_100hdx
;
3415 case MAC_PROP_ADV_10FDX_CAP
:
3416 *(uint8_t *)pr_val
= Adapter
->param_adv_10fdx
;
3418 case MAC_PROP_EN_10FDX_CAP
:
3419 *(uint8_t *)pr_val
= Adapter
->param_en_10fdx
;
3421 case MAC_PROP_ADV_10HDX_CAP
:
3422 *(uint8_t *)pr_val
= Adapter
->param_adv_10hdx
;
3424 case MAC_PROP_EN_10HDX_CAP
:
3425 *(uint8_t *)pr_val
= Adapter
->param_en_10hdx
;
3427 case MAC_PROP_ADV_100T4_CAP
:
3428 case MAC_PROP_EN_100T4_CAP
:
3429 *(uint8_t *)pr_val
= Adapter
->param_adv_100t4
;
3431 case MAC_PROP_PRIVATE
:
3432 err
= e1000g_get_priv_prop(Adapter
, pr_name
,
3433 pr_valsize
, pr_val
);
3444 e1000g_m_propinfo(void *arg
, const char *pr_name
, mac_prop_id_t pr_num
,
3445 mac_prop_info_handle_t prh
)
3447 struct e1000g
*Adapter
= arg
;
3448 struct e1000_hw
*hw
= &Adapter
->shared
;
3451 case MAC_PROP_DUPLEX
:
3452 case MAC_PROP_SPEED
:
3453 case MAC_PROP_ADV_1000FDX_CAP
:
3454 case MAC_PROP_ADV_1000HDX_CAP
:
3455 case MAC_PROP_ADV_100FDX_CAP
:
3456 case MAC_PROP_ADV_100HDX_CAP
:
3457 case MAC_PROP_ADV_10FDX_CAP
:
3458 case MAC_PROP_ADV_10HDX_CAP
:
3459 case MAC_PROP_ADV_100T4_CAP
:
3460 case MAC_PROP_EN_100T4_CAP
:
3461 mac_prop_info_set_perm(prh
, MAC_PROP_PERM_READ
);
3464 case MAC_PROP_EN_1000FDX_CAP
:
3465 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3466 mac_prop_info_set_perm(prh
, MAC_PROP_PERM_READ
);
3468 mac_prop_info_set_default_uint8(prh
,
3469 ((Adapter
->phy_ext_status
&
3470 IEEE_ESR_1000T_FD_CAPS
) ||
3471 (Adapter
->phy_ext_status
&
3472 IEEE_ESR_1000X_FD_CAPS
)) ? 1 : 0);
3476 case MAC_PROP_EN_100FDX_CAP
:
3477 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3478 mac_prop_info_set_perm(prh
, MAC_PROP_PERM_READ
);
3480 mac_prop_info_set_default_uint8(prh
,
3481 ((Adapter
->phy_status
& MII_SR_100X_FD_CAPS
) ||
3482 (Adapter
->phy_status
& MII_SR_100T2_FD_CAPS
))
3487 case MAC_PROP_EN_100HDX_CAP
:
3488 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3489 mac_prop_info_set_perm(prh
, MAC_PROP_PERM_READ
);
3491 mac_prop_info_set_default_uint8(prh
,
3492 ((Adapter
->phy_status
& MII_SR_100X_HD_CAPS
) ||
3493 (Adapter
->phy_status
& MII_SR_100T2_HD_CAPS
))
3498 case MAC_PROP_EN_10FDX_CAP
:
3499 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3500 mac_prop_info_set_perm(prh
, MAC_PROP_PERM_READ
);
3502 mac_prop_info_set_default_uint8(prh
,
3503 (Adapter
->phy_status
& MII_SR_10T_FD_CAPS
) ? 1 : 0);
3507 case MAC_PROP_EN_10HDX_CAP
:
3508 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3509 mac_prop_info_set_perm(prh
, MAC_PROP_PERM_READ
);
3511 mac_prop_info_set_default_uint8(prh
,
3512 (Adapter
->phy_status
& MII_SR_10T_HD_CAPS
) ? 1 : 0);
3516 case MAC_PROP_EN_1000HDX_CAP
:
3517 if (hw
->phy
.media_type
!= e1000_media_type_copper
)
3518 mac_prop_info_set_perm(prh
, MAC_PROP_PERM_READ
);
3521 case MAC_PROP_AUTONEG
:
3522 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
3523 mac_prop_info_set_perm(prh
, MAC_PROP_PERM_READ
);
3525 mac_prop_info_set_default_uint8(prh
,
3526 (Adapter
->phy_status
& MII_SR_AUTONEG_CAPS
)
3531 case MAC_PROP_FLOWCTRL
:
3532 mac_prop_info_set_default_link_flowctrl(prh
, LINK_FLOWCTRL_BI
);
3535 case MAC_PROP_MTU
: {
3536 struct e1000_mac_info
*mac
= &Adapter
->shared
.mac
;
3537 struct e1000_phy_info
*phy
= &Adapter
->shared
.phy
;
3540 /* some MAC types do not support jumbo frames */
3541 if ((mac
->type
== e1000_ich8lan
) ||
3542 ((mac
->type
== e1000_ich9lan
) && (phy
->type
==
3546 max
= Adapter
->max_mtu
;
3549 mac_prop_info_set_range_uint32(prh
, DEFAULT_MTU
, max
);
3552 case MAC_PROP_PRIVATE
: {
3556 if (strcmp(pr_name
, "_adv_pause_cap") == 0 ||
3557 strcmp(pr_name
, "_adv_asym_pause_cap") == 0) {
3558 mac_prop_info_set_perm(prh
, MAC_PROP_PERM_READ
);
3560 } else if (strcmp(pr_name
, "_tx_bcopy_threshold") == 0) {
3561 value
= DEFAULT_TX_BCOPY_THRESHOLD
;
3562 } else if (strcmp(pr_name
, "_tx_interrupt_enable") == 0) {
3563 value
= DEFAULT_TX_INTR_ENABLE
;
3564 } else if (strcmp(pr_name
, "_tx_intr_delay") == 0) {
3565 value
= DEFAULT_TX_INTR_DELAY
;
3566 } else if (strcmp(pr_name
, "_tx_intr_abs_delay") == 0) {
3567 value
= DEFAULT_TX_INTR_ABS_DELAY
;
3568 } else if (strcmp(pr_name
, "_rx_bcopy_threshold") == 0) {
3569 value
= DEFAULT_RX_BCOPY_THRESHOLD
;
3570 } else if (strcmp(pr_name
, "_max_num_rcv_packets") == 0) {
3571 value
= DEFAULT_RX_LIMIT_ON_INTR
;
3572 } else if (strcmp(pr_name
, "_rx_intr_delay") == 0) {
3573 value
= DEFAULT_RX_INTR_DELAY
;
3574 } else if (strcmp(pr_name
, "_rx_intr_abs_delay") == 0) {
3575 value
= DEFAULT_RX_INTR_ABS_DELAY
;
3576 } else if (strcmp(pr_name
, "_intr_throttling_rate") == 0) {
3577 value
= DEFAULT_INTR_THROTTLING
;
3578 } else if (strcmp(pr_name
, "_intr_adaptive") == 0) {
3584 (void) snprintf(valstr
, sizeof (valstr
), "%d", value
);
3585 mac_prop_info_set_default_str(prh
, valstr
);
3593 e1000g_set_priv_prop(struct e1000g
*Adapter
, const char *pr_name
,
3594 uint_t pr_valsize
, const void *pr_val
)
3598 struct e1000_hw
*hw
= &Adapter
->shared
;
3600 if (strcmp(pr_name
, "_tx_bcopy_threshold") == 0) {
3601 if (pr_val
== NULL
) {
3605 (void) ddi_strtol(pr_val
, (char **)NULL
, 0, &result
);
3606 if (result
< MIN_TX_BCOPY_THRESHOLD
||
3607 result
> MAX_TX_BCOPY_THRESHOLD
)
3610 Adapter
->tx_bcopy_thresh
= (uint32_t)result
;
3614 if (strcmp(pr_name
, "_tx_interrupt_enable") == 0) {
3615 if (pr_val
== NULL
) {
3619 (void) ddi_strtol(pr_val
, (char **)NULL
, 0, &result
);
3620 if (result
< 0 || result
> 1)
3623 Adapter
->tx_intr_enable
= (result
== 1) ?
3625 if (Adapter
->tx_intr_enable
)
3626 e1000g_mask_tx_interrupt(Adapter
);
3628 e1000g_clear_tx_interrupt(Adapter
);
3629 if (e1000g_check_acc_handle(
3630 Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
3631 ddi_fm_service_impact(Adapter
->dip
,
3632 DDI_SERVICE_DEGRADED
);
3638 if (strcmp(pr_name
, "_tx_intr_delay") == 0) {
3639 if (pr_val
== NULL
) {
3643 (void) ddi_strtol(pr_val
, (char **)NULL
, 0, &result
);
3644 if (result
< MIN_TX_INTR_DELAY
||
3645 result
> MAX_TX_INTR_DELAY
)
3648 Adapter
->tx_intr_delay
= (uint32_t)result
;
3649 E1000_WRITE_REG(hw
, E1000_TIDV
, Adapter
->tx_intr_delay
);
3650 if (e1000g_check_acc_handle(
3651 Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
3652 ddi_fm_service_impact(Adapter
->dip
,
3653 DDI_SERVICE_DEGRADED
);
3659 if (strcmp(pr_name
, "_tx_intr_abs_delay") == 0) {
3660 if (pr_val
== NULL
) {
3664 (void) ddi_strtol(pr_val
, (char **)NULL
, 0, &result
);
3665 if (result
< MIN_TX_INTR_ABS_DELAY
||
3666 result
> MAX_TX_INTR_ABS_DELAY
)
3669 Adapter
->tx_intr_abs_delay
= (uint32_t)result
;
3670 E1000_WRITE_REG(hw
, E1000_TADV
,
3671 Adapter
->tx_intr_abs_delay
);
3672 if (e1000g_check_acc_handle(
3673 Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
3674 ddi_fm_service_impact(Adapter
->dip
,
3675 DDI_SERVICE_DEGRADED
);
3681 if (strcmp(pr_name
, "_rx_bcopy_threshold") == 0) {
3682 if (pr_val
== NULL
) {
3686 (void) ddi_strtol(pr_val
, (char **)NULL
, 0, &result
);
3687 if (result
< MIN_RX_BCOPY_THRESHOLD
||
3688 result
> MAX_RX_BCOPY_THRESHOLD
)
3691 Adapter
->rx_bcopy_thresh
= (uint32_t)result
;
3694 if (strcmp(pr_name
, "_max_num_rcv_packets") == 0) {
3695 if (pr_val
== NULL
) {
3699 (void) ddi_strtol(pr_val
, (char **)NULL
, 0, &result
);
3700 if (result
< MIN_RX_LIMIT_ON_INTR
||
3701 result
> MAX_RX_LIMIT_ON_INTR
)
3704 Adapter
->rx_limit_onintr
= (uint32_t)result
;
3707 if (strcmp(pr_name
, "_rx_intr_delay") == 0) {
3708 if (pr_val
== NULL
) {
3712 (void) ddi_strtol(pr_val
, (char **)NULL
, 0, &result
);
3713 if (result
< MIN_RX_INTR_DELAY
||
3714 result
> MAX_RX_INTR_DELAY
)
3717 Adapter
->rx_intr_delay
= (uint32_t)result
;
3718 E1000_WRITE_REG(hw
, E1000_RDTR
, Adapter
->rx_intr_delay
);
3719 if (e1000g_check_acc_handle(
3720 Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
3721 ddi_fm_service_impact(Adapter
->dip
,
3722 DDI_SERVICE_DEGRADED
);
3728 if (strcmp(pr_name
, "_rx_intr_abs_delay") == 0) {
3729 if (pr_val
== NULL
) {
3733 (void) ddi_strtol(pr_val
, (char **)NULL
, 0, &result
);
3734 if (result
< MIN_RX_INTR_ABS_DELAY
||
3735 result
> MAX_RX_INTR_ABS_DELAY
)
3738 Adapter
->rx_intr_abs_delay
= (uint32_t)result
;
3739 E1000_WRITE_REG(hw
, E1000_RADV
,
3740 Adapter
->rx_intr_abs_delay
);
3741 if (e1000g_check_acc_handle(
3742 Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
3743 ddi_fm_service_impact(Adapter
->dip
,
3744 DDI_SERVICE_DEGRADED
);
3750 if (strcmp(pr_name
, "_intr_throttling_rate") == 0) {
3751 if (pr_val
== NULL
) {
3755 (void) ddi_strtol(pr_val
, (char **)NULL
, 0, &result
);
3756 if (result
< MIN_INTR_THROTTLING
||
3757 result
> MAX_INTR_THROTTLING
)
3760 if (hw
->mac
.type
>= e1000_82540
) {
3761 Adapter
->intr_throttling_rate
=
3763 E1000_WRITE_REG(hw
, E1000_ITR
,
3764 Adapter
->intr_throttling_rate
);
3765 if (e1000g_check_acc_handle(
3766 Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
3767 ddi_fm_service_impact(Adapter
->dip
,
3768 DDI_SERVICE_DEGRADED
);
3776 if (strcmp(pr_name
, "_intr_adaptive") == 0) {
3777 if (pr_val
== NULL
) {
3781 (void) ddi_strtol(pr_val
, (char **)NULL
, 0, &result
);
3782 if (result
< 0 || result
> 1)
3785 if (hw
->mac
.type
>= e1000_82540
) {
3786 Adapter
->intr_adaptive
= (result
== 1) ?
3798 e1000g_get_priv_prop(struct e1000g
*Adapter
, const char *pr_name
,
3799 uint_t pr_valsize
, void *pr_val
)
3804 if (strcmp(pr_name
, "_adv_pause_cap") == 0) {
3805 value
= Adapter
->param_adv_pause
;
3809 if (strcmp(pr_name
, "_adv_asym_pause_cap") == 0) {
3810 value
= Adapter
->param_adv_asym_pause
;
3814 if (strcmp(pr_name
, "_tx_bcopy_threshold") == 0) {
3815 value
= Adapter
->tx_bcopy_thresh
;
3819 if (strcmp(pr_name
, "_tx_interrupt_enable") == 0) {
3820 value
= Adapter
->tx_intr_enable
;
3824 if (strcmp(pr_name
, "_tx_intr_delay") == 0) {
3825 value
= Adapter
->tx_intr_delay
;
3829 if (strcmp(pr_name
, "_tx_intr_abs_delay") == 0) {
3830 value
= Adapter
->tx_intr_abs_delay
;
3834 if (strcmp(pr_name
, "_rx_bcopy_threshold") == 0) {
3835 value
= Adapter
->rx_bcopy_thresh
;
3839 if (strcmp(pr_name
, "_max_num_rcv_packets") == 0) {
3840 value
= Adapter
->rx_limit_onintr
;
3844 if (strcmp(pr_name
, "_rx_intr_delay") == 0) {
3845 value
= Adapter
->rx_intr_delay
;
3849 if (strcmp(pr_name
, "_rx_intr_abs_delay") == 0) {
3850 value
= Adapter
->rx_intr_abs_delay
;
3854 if (strcmp(pr_name
, "_intr_throttling_rate") == 0) {
3855 value
= Adapter
->intr_throttling_rate
;
3859 if (strcmp(pr_name
, "_intr_adaptive") == 0) {
3860 value
= Adapter
->intr_adaptive
;
3866 (void) snprintf(pr_val
, pr_valsize
, "%d", value
);
3872 * e1000g_get_conf - get configurations set in e1000g.conf
3873 * This routine gets user-configured values out of the configuration
3876 * For each configurable value, there is a minimum, a maximum, and a
3878 * If user does not configure a value, use the default.
3879 * If user configures below the minimum, use the minumum.
3880 * If user configures above the maximum, use the maxumum.
3883 e1000g_get_conf(struct e1000g
*Adapter
)
3885 struct e1000_hw
*hw
= &Adapter
->shared
;
3886 boolean_t tbi_compatibility
= B_FALSE
;
3887 boolean_t is_jumbo
= B_FALSE
;
3890 * decrease the number of descriptors and free packets
3891 * for jumbo frames to reduce tx/rx resource consumption
3893 if (Adapter
->max_frame_size
>= FRAME_SIZE_UPTO_4K
) {
3898 * get each configurable property from e1000g.conf
3904 Adapter
->tx_desc_num_flag
=
3905 e1000g_get_prop(Adapter
, "NumTxDescriptors",
3906 MIN_NUM_TX_DESCRIPTOR
, MAX_NUM_TX_DESCRIPTOR
,
3907 is_jumbo
? DEFAULT_JUMBO_NUM_TX_DESC
3908 : DEFAULT_NUM_TX_DESCRIPTOR
, &propval
);
3909 Adapter
->tx_desc_num
= propval
;
3914 Adapter
->rx_desc_num_flag
=
3915 e1000g_get_prop(Adapter
, "NumRxDescriptors",
3916 MIN_NUM_RX_DESCRIPTOR
, MAX_NUM_RX_DESCRIPTOR
,
3917 is_jumbo
? DEFAULT_JUMBO_NUM_RX_DESC
3918 : DEFAULT_NUM_RX_DESCRIPTOR
, &propval
);
3919 Adapter
->rx_desc_num
= propval
;
3924 Adapter
->rx_buf_num_flag
=
3925 e1000g_get_prop(Adapter
, "NumRxFreeList",
3926 MIN_NUM_RX_FREELIST
, MAX_NUM_RX_FREELIST
,
3927 is_jumbo
? DEFAULT_JUMBO_NUM_RX_BUF
3928 : DEFAULT_NUM_RX_FREELIST
, &propval
);
3929 Adapter
->rx_freelist_limit
= propval
;
3934 Adapter
->tx_buf_num_flag
=
3935 e1000g_get_prop(Adapter
, "NumTxPacketList",
3936 MIN_NUM_TX_FREELIST
, MAX_NUM_TX_FREELIST
,
3937 is_jumbo
? DEFAULT_JUMBO_NUM_TX_BUF
3938 : DEFAULT_NUM_TX_FREELIST
, &propval
);
3939 Adapter
->tx_freelist_num
= propval
;
3944 hw
->fc
.send_xon
= B_TRUE
;
3945 (void) e1000g_get_prop(Adapter
, "FlowControl",
3946 e1000_fc_none
, 4, DEFAULT_FLOW_CONTROL
, &propval
);
3947 hw
->fc
.requested_mode
= propval
;
3948 /* 4 is the setting that says "let the eeprom decide" */
3949 if (hw
->fc
.requested_mode
== 4)
3950 hw
->fc
.requested_mode
= e1000_fc_default
;
3953 * Max Num Receive Packets on Interrupt
3955 (void) e1000g_get_prop(Adapter
, "MaxNumReceivePackets",
3956 MIN_RX_LIMIT_ON_INTR
, MAX_RX_LIMIT_ON_INTR
,
3957 DEFAULT_RX_LIMIT_ON_INTR
, &propval
);
3958 Adapter
->rx_limit_onintr
= propval
;
3961 * PHY master slave setting
3963 (void) e1000g_get_prop(Adapter
, "SetMasterSlave",
3964 e1000_ms_hw_default
, e1000_ms_auto
,
3965 e1000_ms_hw_default
, &propval
);
3966 hw
->phy
.ms_type
= propval
;
3969 * Parameter which controls TBI mode workaround, which is only
3970 * needed on certain switches such as Cisco 6500/Foundry
3972 (void) e1000g_get_prop(Adapter
, "TbiCompatibilityEnable",
3973 0, 1, DEFAULT_TBI_COMPAT_ENABLE
, &propval
);
3974 tbi_compatibility
= (propval
== 1);
3975 e1000_set_tbi_compatibility_82543(hw
, tbi_compatibility
);
3980 (void) e1000g_get_prop(Adapter
, "MSIEnable",
3981 0, 1, DEFAULT_MSI_ENABLE
, &propval
);
3982 Adapter
->msi_enable
= (propval
== 1);
3985 * Interrupt Throttling Rate
3987 (void) e1000g_get_prop(Adapter
, "intr_throttling_rate",
3988 MIN_INTR_THROTTLING
, MAX_INTR_THROTTLING
,
3989 DEFAULT_INTR_THROTTLING
, &propval
);
3990 Adapter
->intr_throttling_rate
= propval
;
3993 * Adaptive Interrupt Blanking Enable/Disable
3994 * It is enabled by default
3996 (void) e1000g_get_prop(Adapter
, "intr_adaptive", 0, 1, 1,
3998 Adapter
->intr_adaptive
= (propval
== 1);
4001 * Hardware checksum enable/disable parameter
4003 (void) e1000g_get_prop(Adapter
, "tx_hcksum_enable",
4004 0, 1, DEFAULT_TX_HCKSUM_ENABLE
, &propval
);
4005 Adapter
->tx_hcksum_enable
= (propval
== 1);
4007 * Checksum on/off selection via global parameters.
4009 * If the chip is flagged as not capable of (correctly)
4010 * handling checksumming, we don't enable it on either
4011 * Rx or Tx side. Otherwise, we take this chip's settings
4012 * from the patchable global defaults.
4014 * We advertise our capabilities only if TX offload is
4015 * enabled. On receive, the stack will accept checksummed
4016 * packets anyway, even if we haven't said we can deliver
4019 switch (hw
->mac
.type
) {
4023 case e1000_82545_rev_3
:
4025 case e1000_82546_rev_3
:
4029 case e1000_80003es2lan
:
4032 * For the following Intel PRO/1000 chipsets, we have not
4033 * tested the hardware checksum offload capability, so we
4034 * disable the capability for them.
4038 * e1000_82541_rev_2,
4040 * e1000_82547_rev_2,
4043 Adapter
->tx_hcksum_enable
= B_FALSE
;
4047 * Large Send Offloading(LSO) Enable/Disable
4048 * If the tx hardware checksum is not enabled, LSO should be
4051 (void) e1000g_get_prop(Adapter
, "lso_enable",
4052 0, 1, DEFAULT_LSO_ENABLE
, &propval
);
4053 Adapter
->lso_enable
= (propval
== 1);
4055 switch (hw
->mac
.type
) {
4057 case e1000_82546_rev_3
:
4058 if (Adapter
->lso_enable
)
4059 Adapter
->lso_premature_issue
= B_TRUE
;
4064 case e1000_80003es2lan
:
4067 Adapter
->lso_enable
= B_FALSE
;
4070 if (!Adapter
->tx_hcksum_enable
) {
4071 Adapter
->lso_premature_issue
= B_FALSE
;
4072 Adapter
->lso_enable
= B_FALSE
;
4076 * If mem_workaround_82546 is enabled, the rx buffer allocated by
4077 * e1000_82545, e1000_82546 and e1000_82546_rev_3
4078 * will not cross 64k boundary.
4080 (void) e1000g_get_prop(Adapter
, "mem_workaround_82546",
4081 0, 1, DEFAULT_MEM_WORKAROUND_82546
, &propval
);
4082 Adapter
->mem_workaround_82546
= (propval
== 1);
4085 * Max number of multicast addresses
4087 (void) e1000g_get_prop(Adapter
, "mcast_max_num",
4088 MIN_MCAST_NUM
, MAX_MCAST_NUM
, hw
->mac
.mta_reg_count
* 32,
4090 Adapter
->mcast_max_num
= propval
;
4094 * e1000g_get_prop - routine to read properties
4096 * Get a user-configure property value out of the configuration
4099 * Caller provides name of the property, a default value, a minimum
4100 * value, a maximum value and a pointer to the returned property
4103 * Return B_TRUE if the configured value of the property is not a default
4104 * value, otherwise return B_FALSE.
4107 e1000g_get_prop(struct e1000g
*Adapter
, /* point to per-adapter structure */
4108 char *propname
, /* name of the property */
4109 int minval
, /* minimum acceptable value */
4110 int maxval
, /* maximim acceptable value */
4111 int defval
, /* default value */
4112 int *propvalue
) /* property value return to caller */
4114 int propval
; /* value returned for requested property */
4115 int *props
; /* point to array of properties returned */
4116 uint_t nprops
; /* number of property value returned */
4117 boolean_t ret
= B_TRUE
;
4120 * get the array of properties from the config file
4122 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY
, Adapter
->dip
,
4123 DDI_PROP_DONTPASS
, propname
, &props
, &nprops
) == DDI_PROP_SUCCESS
) {
4124 /* got some properties, test if we got enough */
4125 if (Adapter
->instance
< nprops
) {
4126 propval
= props
[Adapter
->instance
];
4128 /* not enough properties configured */
4130 E1000G_DEBUGLOG_2(Adapter
, E1000G_INFO_LEVEL
,
4131 "Not Enough %s values found in e1000g.conf"
4137 /* free memory allocated for properties */
4138 ddi_prop_free(props
);
4148 if (propval
> maxval
) {
4150 E1000G_DEBUGLOG_2(Adapter
, E1000G_INFO_LEVEL
,
4151 "Too High %s value in e1000g.conf - set to %d\n",
4155 if (propval
< minval
) {
4157 E1000G_DEBUGLOG_2(Adapter
, E1000G_INFO_LEVEL
,
4158 "Too Low %s value in e1000g.conf - set to %d\n",
4162 *propvalue
= propval
;
4167 e1000g_link_check(struct e1000g
*Adapter
)
4169 uint16_t speed
, duplex
, phydata
;
4170 boolean_t link_changed
= B_FALSE
;
4171 struct e1000_hw
*hw
;
4174 hw
= &Adapter
->shared
;
4176 if (e1000g_link_up(Adapter
)) {
4178 * The Link is up, check whether it was marked as down earlier
4180 if (Adapter
->link_state
!= LINK_STATE_UP
) {
4181 (void) e1000_get_speed_and_duplex(hw
, &speed
, &duplex
);
4182 Adapter
->link_speed
= speed
;
4183 Adapter
->link_duplex
= duplex
;
4184 Adapter
->link_state
= LINK_STATE_UP
;
4185 link_changed
= B_TRUE
;
4187 if (Adapter
->link_speed
== SPEED_1000
)
4188 Adapter
->stall_threshold
= TX_STALL_TIME_2S
;
4190 Adapter
->stall_threshold
= TX_STALL_TIME_8S
;
4192 Adapter
->tx_link_down_timeout
= 0;
4194 if ((hw
->mac
.type
== e1000_82571
) ||
4195 (hw
->mac
.type
== e1000_82572
)) {
4196 reg_tarc
= E1000_READ_REG(hw
, E1000_TARC(0));
4197 if (speed
== SPEED_1000
)
4198 reg_tarc
|= (1 << 21);
4200 reg_tarc
&= ~(1 << 21);
4201 E1000_WRITE_REG(hw
, E1000_TARC(0), reg_tarc
);
4204 Adapter
->smartspeed
= 0;
4206 if (Adapter
->link_state
!= LINK_STATE_DOWN
) {
4207 Adapter
->link_speed
= 0;
4208 Adapter
->link_duplex
= 0;
4209 Adapter
->link_state
= LINK_STATE_DOWN
;
4210 link_changed
= B_TRUE
;
4213 * SmartSpeed workaround for Tabor/TanaX, When the
4214 * driver loses link disable auto master/slave
4217 if (hw
->phy
.type
== e1000_phy_igp
) {
4218 (void) e1000_read_phy_reg(hw
,
4219 PHY_1000T_CTRL
, &phydata
);
4220 phydata
|= CR_1000T_MS_ENABLE
;
4221 (void) e1000_write_phy_reg(hw
,
4222 PHY_1000T_CTRL
, phydata
);
4225 e1000g_smartspeed(Adapter
);
4228 if (Adapter
->e1000g_state
& E1000G_STARTED
) {
4229 if (Adapter
->tx_link_down_timeout
<
4230 MAX_TX_LINK_DOWN_TIMEOUT
) {
4231 Adapter
->tx_link_down_timeout
++;
4232 } else if (Adapter
->tx_link_down_timeout
==
4233 MAX_TX_LINK_DOWN_TIMEOUT
) {
4234 e1000g_tx_clean(Adapter
);
4235 Adapter
->tx_link_down_timeout
++;
4240 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
)
4241 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_DEGRADED
);
4243 return (link_changed
);
4247 * e1000g_reset_link - Using the link properties to setup the link
4250 e1000g_reset_link(struct e1000g
*Adapter
)
4252 struct e1000_mac_info
*mac
;
4253 struct e1000_phy_info
*phy
;
4254 struct e1000_hw
*hw
;
4257 mac
= &Adapter
->shared
.mac
;
4258 phy
= &Adapter
->shared
.phy
;
4259 hw
= &Adapter
->shared
;
4262 if (hw
->phy
.media_type
!= e1000_media_type_copper
)
4265 if (Adapter
->param_adv_autoneg
== 1) {
4266 mac
->autoneg
= B_TRUE
;
4267 phy
->autoneg_advertised
= 0;
4270 * 1000hdx is not supported for autonegotiation
4272 if (Adapter
->param_adv_1000fdx
== 1)
4273 phy
->autoneg_advertised
|= ADVERTISE_1000_FULL
;
4275 if (Adapter
->param_adv_100fdx
== 1)
4276 phy
->autoneg_advertised
|= ADVERTISE_100_FULL
;
4278 if (Adapter
->param_adv_100hdx
== 1)
4279 phy
->autoneg_advertised
|= ADVERTISE_100_HALF
;
4281 if (Adapter
->param_adv_10fdx
== 1)
4282 phy
->autoneg_advertised
|= ADVERTISE_10_FULL
;
4284 if (Adapter
->param_adv_10hdx
== 1)
4285 phy
->autoneg_advertised
|= ADVERTISE_10_HALF
;
4287 if (phy
->autoneg_advertised
== 0)
4290 mac
->autoneg
= B_FALSE
;
4293 * For Intel copper cards, 1000fdx and 1000hdx are not
4294 * supported for forced link
4296 if (Adapter
->param_adv_100fdx
== 1)
4297 mac
->forced_speed_duplex
= ADVERTISE_100_FULL
;
4298 else if (Adapter
->param_adv_100hdx
== 1)
4299 mac
->forced_speed_duplex
= ADVERTISE_100_HALF
;
4300 else if (Adapter
->param_adv_10fdx
== 1)
4301 mac
->forced_speed_duplex
= ADVERTISE_10_FULL
;
4302 else if (Adapter
->param_adv_10hdx
== 1)
4303 mac
->forced_speed_duplex
= ADVERTISE_10_HALF
;
4310 e1000g_log(Adapter
, CE_WARN
,
4311 "Invalid link settings. Setup link to "
4312 "support autonegotiation with all link capabilities.");
4313 mac
->autoneg
= B_TRUE
;
4314 phy
->autoneg_advertised
= AUTONEG_ADVERTISE_SPEED_DEFAULT
;
4318 return (e1000_setup_link(&Adapter
->shared
));
4322 e1000g_timer_tx_resched(struct e1000g
*Adapter
)
4324 e1000g_tx_ring_t
*tx_ring
= Adapter
->tx_ring
;
4326 rw_enter(&Adapter
->chip_lock
, RW_READER
);
4328 if (tx_ring
->resched_needed
&&
4329 ((ddi_get_lbolt() - tx_ring
->resched_timestamp
) >
4330 drv_usectohz(1000000)) &&
4331 (Adapter
->e1000g_state
& E1000G_STARTED
) &&
4332 (tx_ring
->tbd_avail
>= DEFAULT_TX_NO_RESOURCE
)) {
4333 tx_ring
->resched_needed
= B_FALSE
;
4334 mac_tx_update(Adapter
->mh
);
4335 E1000G_STAT(tx_ring
->stat_reschedule
);
4336 E1000G_STAT(tx_ring
->stat_timer_reschedule
);
4339 rw_exit(&Adapter
->chip_lock
);
4343 e1000g_local_timer(void *ws
)
4345 struct e1000g
*Adapter
= (struct e1000g
*)ws
;
4346 struct e1000_hw
*hw
;
4347 e1000g_ether_addr_t ether_addr
;
4348 boolean_t link_changed
;
4350 hw
= &Adapter
->shared
;
4352 if (Adapter
->e1000g_state
& E1000G_ERROR
) {
4353 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
4354 Adapter
->e1000g_state
&= ~E1000G_ERROR
;
4355 rw_exit(&Adapter
->chip_lock
);
4357 Adapter
->reset_count
++;
4358 if (e1000g_global_reset(Adapter
)) {
4359 ddi_fm_service_impact(Adapter
->dip
,
4360 DDI_SERVICE_RESTORED
);
4361 e1000g_timer_tx_resched(Adapter
);
4363 ddi_fm_service_impact(Adapter
->dip
,
4368 if (e1000g_stall_check(Adapter
)) {
4369 E1000G_DEBUGLOG_0(Adapter
, E1000G_INFO_LEVEL
,
4370 "Tx stall detected. Activate automatic recovery.\n");
4371 e1000g_fm_ereport(Adapter
, DDI_FM_DEVICE_STALL
);
4372 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_LOST
);
4373 Adapter
->reset_count
++;
4374 if (e1000g_reset_adapter(Adapter
)) {
4375 ddi_fm_service_impact(Adapter
->dip
,
4376 DDI_SERVICE_RESTORED
);
4377 e1000g_timer_tx_resched(Adapter
);
4382 link_changed
= B_FALSE
;
4383 rw_enter(&Adapter
->chip_lock
, RW_READER
);
4384 if (Adapter
->link_complete
)
4385 link_changed
= e1000g_link_check(Adapter
);
4386 rw_exit(&Adapter
->chip_lock
);
4389 if (!Adapter
->reset_flag
&&
4390 (Adapter
->e1000g_state
& E1000G_STARTED
) &&
4391 !(Adapter
->e1000g_state
& E1000G_SUSPENDED
))
4392 mac_link_update(Adapter
->mh
, Adapter
->link_state
);
4393 if (Adapter
->link_state
== LINK_STATE_UP
)
4394 Adapter
->reset_flag
= B_FALSE
;
4397 * Workaround for esb2. Data stuck in fifo on a link
4398 * down event. Reset the adapter to recover it.
4400 if (Adapter
->esb2_workaround
) {
4401 Adapter
->esb2_workaround
= B_FALSE
;
4402 (void) e1000g_reset_adapter(Adapter
);
4407 * With 82571 controllers, any locally administered address will
4408 * be overwritten when there is a reset on the other port.
4409 * Detect this circumstance and correct it.
4411 if ((hw
->mac
.type
== e1000_82571
) &&
4412 (e1000_get_laa_state_82571(hw
) == B_TRUE
)) {
4413 ether_addr
.reg
.low
= E1000_READ_REG_ARRAY(hw
, E1000_RA
, 0);
4414 ether_addr
.reg
.high
= E1000_READ_REG_ARRAY(hw
, E1000_RA
, 1);
4416 ether_addr
.reg
.low
= ntohl(ether_addr
.reg
.low
);
4417 ether_addr
.reg
.high
= ntohl(ether_addr
.reg
.high
);
4419 if ((ether_addr
.mac
.addr
[5] != hw
->mac
.addr
[0]) ||
4420 (ether_addr
.mac
.addr
[4] != hw
->mac
.addr
[1]) ||
4421 (ether_addr
.mac
.addr
[3] != hw
->mac
.addr
[2]) ||
4422 (ether_addr
.mac
.addr
[2] != hw
->mac
.addr
[3]) ||
4423 (ether_addr
.mac
.addr
[1] != hw
->mac
.addr
[4]) ||
4424 (ether_addr
.mac
.addr
[0] != hw
->mac
.addr
[5])) {
4425 (void) e1000_rar_set(hw
, hw
->mac
.addr
, 0);
4430 * Long TTL workaround for 82541/82547
4432 (void) e1000_igp_ttl_workaround_82547(hw
);
4435 * Check for Adaptive IFS settings If there are lots of collisions
4436 * change the value in steps...
4437 * These properties should only be set for 10/100
4439 if ((hw
->phy
.media_type
== e1000_media_type_copper
) &&
4440 ((Adapter
->link_speed
== SPEED_100
) ||
4441 (Adapter
->link_speed
== SPEED_10
))) {
4442 e1000_update_adaptive(hw
);
4445 * Set Timer Interrupts
4447 E1000_WRITE_REG(hw
, E1000_ICS
, E1000_IMS_RXT0
);
4449 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
)
4450 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_DEGRADED
);
4452 e1000g_timer_tx_resched(Adapter
);
4454 restart_watchdog_timer(Adapter
);
4458 * The function e1000g_link_timer() is called when the timer for link setup
4459 * is expired, which indicates the completion of the link setup. The link
4460 * state will not be updated until the link setup is completed. And the
4461 * link state will not be sent to the upper layer through mac_link_update()
4462 * in this function. It will be updated in the local timer routine or the
4463 * interrupt service routine after the interface is started (plumbed).
4466 e1000g_link_timer(void *arg
)
4468 struct e1000g
*Adapter
= (struct e1000g
*)arg
;
4470 mutex_enter(&Adapter
->link_lock
);
4471 Adapter
->link_complete
= B_TRUE
;
4472 Adapter
->link_tid
= 0;
4473 mutex_exit(&Adapter
->link_lock
);
4477 * e1000g_force_speed_duplex - read forced speed/duplex out of e1000g.conf
4479 * This function read the forced speed and duplex for 10/100 Mbps speeds
4480 * and also for 1000 Mbps speeds from the e1000g.conf file
4483 e1000g_force_speed_duplex(struct e1000g
*Adapter
)
4487 struct e1000_mac_info
*mac
= &Adapter
->shared
.mac
;
4488 struct e1000_phy_info
*phy
= &Adapter
->shared
.phy
;
4491 * get value out of config file
4493 (void) e1000g_get_prop(Adapter
, "ForceSpeedDuplex",
4494 GDIAG_10_HALF
, GDIAG_ANY
, GDIAG_ANY
, &forced
);
4499 * Disable Auto Negotiation
4501 mac
->autoneg
= B_FALSE
;
4502 mac
->forced_speed_duplex
= ADVERTISE_10_HALF
;
4506 * Disable Auto Negotiation
4508 mac
->autoneg
= B_FALSE
;
4509 mac
->forced_speed_duplex
= ADVERTISE_10_FULL
;
4511 case GDIAG_100_HALF
:
4513 * Disable Auto Negotiation
4515 mac
->autoneg
= B_FALSE
;
4516 mac
->forced_speed_duplex
= ADVERTISE_100_HALF
;
4518 case GDIAG_100_FULL
:
4520 * Disable Auto Negotiation
4522 mac
->autoneg
= B_FALSE
;
4523 mac
->forced_speed_duplex
= ADVERTISE_100_FULL
;
4525 case GDIAG_1000_FULL
:
4527 * The gigabit spec requires autonegotiation. Therefore,
4528 * when the user wants to force the speed to 1000Mbps, we
4529 * enable AutoNeg, but only allow the harware to advertise
4530 * 1000Mbps. This is different from 10/100 operation, where
4531 * we are allowed to link without any negotiation.
4533 mac
->autoneg
= B_TRUE
;
4534 phy
->autoneg_advertised
= ADVERTISE_1000_FULL
;
4536 default: /* obey the setting of AutoNegAdvertised */
4537 mac
->autoneg
= B_TRUE
;
4538 (void) e1000g_get_prop(Adapter
, "AutoNegAdvertised",
4539 0, AUTONEG_ADVERTISE_SPEED_DEFAULT
,
4540 AUTONEG_ADVERTISE_SPEED_DEFAULT
, &propval
);
4541 phy
->autoneg_advertised
= (uint16_t)propval
;
4547 * e1000g_get_max_frame_size - get jumbo frame setting from e1000g.conf
4549 * This function reads MaxFrameSize from e1000g.conf
4552 e1000g_get_max_frame_size(struct e1000g
*Adapter
)
4557 * get value out of config file
4559 (void) e1000g_get_prop(Adapter
, "MaxFrameSize", 0, 3, 0,
4562 switch (max_frame
) {
4564 Adapter
->default_mtu
= ETHERMTU
;
4567 Adapter
->default_mtu
= FRAME_SIZE_UPTO_4K
-
4568 sizeof (struct ether_vlan_header
) - ETHERFCSL
;
4571 Adapter
->default_mtu
= FRAME_SIZE_UPTO_8K
-
4572 sizeof (struct ether_vlan_header
) - ETHERFCSL
;
4575 Adapter
->default_mtu
= FRAME_SIZE_UPTO_16K
-
4576 sizeof (struct ether_vlan_header
) - ETHERFCSL
;
4579 Adapter
->default_mtu
= ETHERMTU
;
4584 * If the user configed MTU is larger than the deivce's maximum MTU,
4585 * the MTU is set to the deivce's maximum value.
4587 if (Adapter
->default_mtu
> Adapter
->max_mtu
)
4588 Adapter
->default_mtu
= Adapter
->max_mtu
;
4590 Adapter
->max_frame_size
= e1000g_mtu2maxframe(Adapter
->default_mtu
);
4594 * e1000g_pch_limits - Apply limits of the PCH silicon type
4596 * At any frame size larger than the ethernet default,
4597 * prevent linking at 10/100 speeds.
4600 e1000g_pch_limits(struct e1000g
*Adapter
)
4602 struct e1000_hw
*hw
= &Adapter
->shared
;
4604 /* only applies to PCH silicon type */
4605 if (hw
->mac
.type
!= e1000_pchlan
&& hw
->mac
.type
!= e1000_pch2lan
)
4608 /* only applies to frames larger than ethernet default */
4609 if (Adapter
->max_frame_size
> DEFAULT_FRAME_SIZE
) {
4610 hw
->mac
.autoneg
= B_TRUE
;
4611 hw
->phy
.autoneg_advertised
= ADVERTISE_1000_FULL
;
4613 Adapter
->param_adv_autoneg
= 1;
4614 Adapter
->param_adv_1000fdx
= 1;
4616 Adapter
->param_adv_100fdx
= 0;
4617 Adapter
->param_adv_100hdx
= 0;
4618 Adapter
->param_adv_10fdx
= 0;
4619 Adapter
->param_adv_10hdx
= 0;
4621 e1000g_param_sync(Adapter
);
4626 * e1000g_mtu2maxframe - convert given MTU to maximum frame size
4629 e1000g_mtu2maxframe(uint32_t mtu
)
4633 maxframe
= mtu
+ sizeof (struct ether_vlan_header
) + ETHERFCSL
;
4639 arm_watchdog_timer(struct e1000g
*Adapter
)
4641 Adapter
->watchdog_tid
=
4642 timeout(e1000g_local_timer
,
4643 (void *)Adapter
, 1 * drv_usectohz(1000000));
4645 #pragma inline(arm_watchdog_timer)
4648 enable_watchdog_timer(struct e1000g
*Adapter
)
4650 mutex_enter(&Adapter
->watchdog_lock
);
4652 if (!Adapter
->watchdog_timer_enabled
) {
4653 Adapter
->watchdog_timer_enabled
= B_TRUE
;
4654 Adapter
->watchdog_timer_started
= B_TRUE
;
4655 arm_watchdog_timer(Adapter
);
4658 mutex_exit(&Adapter
->watchdog_lock
);
4662 disable_watchdog_timer(struct e1000g
*Adapter
)
4666 mutex_enter(&Adapter
->watchdog_lock
);
4668 Adapter
->watchdog_timer_enabled
= B_FALSE
;
4669 Adapter
->watchdog_timer_started
= B_FALSE
;
4670 tid
= Adapter
->watchdog_tid
;
4671 Adapter
->watchdog_tid
= 0;
4673 mutex_exit(&Adapter
->watchdog_lock
);
4676 (void) untimeout(tid
);
4680 start_watchdog_timer(struct e1000g
*Adapter
)
4682 mutex_enter(&Adapter
->watchdog_lock
);
4684 if (Adapter
->watchdog_timer_enabled
) {
4685 if (!Adapter
->watchdog_timer_started
) {
4686 Adapter
->watchdog_timer_started
= B_TRUE
;
4687 arm_watchdog_timer(Adapter
);
4691 mutex_exit(&Adapter
->watchdog_lock
);
4695 restart_watchdog_timer(struct e1000g
*Adapter
)
4697 mutex_enter(&Adapter
->watchdog_lock
);
4699 if (Adapter
->watchdog_timer_started
)
4700 arm_watchdog_timer(Adapter
);
4702 mutex_exit(&Adapter
->watchdog_lock
);
4706 stop_watchdog_timer(struct e1000g
*Adapter
)
4710 mutex_enter(&Adapter
->watchdog_lock
);
4712 Adapter
->watchdog_timer_started
= B_FALSE
;
4713 tid
= Adapter
->watchdog_tid
;
4714 Adapter
->watchdog_tid
= 0;
4716 mutex_exit(&Adapter
->watchdog_lock
);
4719 (void) untimeout(tid
);
4723 stop_link_timer(struct e1000g
*Adapter
)
4727 /* Disable the link timer */
4728 mutex_enter(&Adapter
->link_lock
);
4730 tid
= Adapter
->link_tid
;
4731 Adapter
->link_tid
= 0;
4733 mutex_exit(&Adapter
->link_lock
);
4736 (void) untimeout(tid
);
4740 stop_82547_timer(e1000g_tx_ring_t
*tx_ring
)
4744 /* Disable the tx timer for 82547 chipset */
4745 mutex_enter(&tx_ring
->tx_lock
);
4747 tx_ring
->timer_enable_82547
= B_FALSE
;
4748 tid
= tx_ring
->timer_id_82547
;
4749 tx_ring
->timer_id_82547
= 0;
4751 mutex_exit(&tx_ring
->tx_lock
);
4754 (void) untimeout(tid
);
4758 e1000g_clear_interrupt(struct e1000g
*Adapter
)
4760 E1000_WRITE_REG(&Adapter
->shared
, E1000_IMC
,
4761 0xffffffff & ~E1000_IMS_RXSEQ
);
4765 e1000g_mask_interrupt(struct e1000g
*Adapter
)
4767 E1000_WRITE_REG(&Adapter
->shared
, E1000_IMS
,
4768 IMS_ENABLE_MASK
& ~E1000_IMS_TXDW
);
4770 if (Adapter
->tx_intr_enable
)
4771 e1000g_mask_tx_interrupt(Adapter
);
4775 * This routine is called by e1000g_quiesce(), therefore must not block.
4778 e1000g_clear_all_interrupts(struct e1000g
*Adapter
)
4780 E1000_WRITE_REG(&Adapter
->shared
, E1000_IMC
, 0xffffffff);
4784 e1000g_mask_tx_interrupt(struct e1000g
*Adapter
)
4786 E1000_WRITE_REG(&Adapter
->shared
, E1000_IMS
, E1000_IMS_TXDW
);
4790 e1000g_clear_tx_interrupt(struct e1000g
*Adapter
)
4792 E1000_WRITE_REG(&Adapter
->shared
, E1000_IMC
, E1000_IMS_TXDW
);
4796 e1000g_smartspeed(struct e1000g
*Adapter
)
4798 struct e1000_hw
*hw
= &Adapter
->shared
;
4799 uint16_t phy_status
;
4803 * If we're not T-or-T, or we're not autoneg'ing, or we're not
4804 * advertising 1000Full, we don't even use the workaround
4806 if ((hw
->phy
.type
!= e1000_phy_igp
) ||
4808 !(hw
->phy
.autoneg_advertised
& ADVERTISE_1000_FULL
))
4812 * True if this is the first call of this function or after every
4813 * 30 seconds of not having link
4815 if (Adapter
->smartspeed
== 0) {
4817 * If Master/Slave config fault is asserted twice, we
4818 * assume back-to-back
4820 (void) e1000_read_phy_reg(hw
, PHY_1000T_STATUS
, &phy_status
);
4821 if (!(phy_status
& SR_1000T_MS_CONFIG_FAULT
))
4824 (void) e1000_read_phy_reg(hw
, PHY_1000T_STATUS
, &phy_status
);
4825 if (!(phy_status
& SR_1000T_MS_CONFIG_FAULT
))
4828 * We're assuming back-2-back because our status register
4829 * insists! there's a fault in the master/slave
4830 * relationship that was "negotiated"
4832 (void) e1000_read_phy_reg(hw
, PHY_1000T_CTRL
, &phy_ctrl
);
4834 * Is the phy configured for manual configuration of
4837 if (phy_ctrl
& CR_1000T_MS_ENABLE
) {
4839 * Yes. Then disable manual configuration (enable
4840 * auto configuration) of master/slave
4842 phy_ctrl
&= ~CR_1000T_MS_ENABLE
;
4843 (void) e1000_write_phy_reg(hw
,
4844 PHY_1000T_CTRL
, phy_ctrl
);
4846 * Effectively starting the clock
4848 Adapter
->smartspeed
++;
4850 * Restart autonegotiation
4852 if (!e1000_phy_setup_autoneg(hw
) &&
4853 !e1000_read_phy_reg(hw
, PHY_CONTROL
, &phy_ctrl
)) {
4854 phy_ctrl
|= (MII_CR_AUTO_NEG_EN
|
4855 MII_CR_RESTART_AUTO_NEG
);
4856 (void) e1000_write_phy_reg(hw
,
4857 PHY_CONTROL
, phy_ctrl
);
4862 * Has 6 seconds transpired still without link? Remember,
4863 * you should reset the smartspeed counter once you obtain
4866 } else if (Adapter
->smartspeed
== E1000_SMARTSPEED_DOWNSHIFT
) {
4868 * Yes. Remember, we did at the start determine that
4869 * there's a master/slave configuration fault, so we're
4870 * still assuming there's someone on the other end, but we
4871 * just haven't yet been able to talk to it. We then
4872 * re-enable auto configuration of master/slave to see if
4873 * we're running 2/3 pair cables.
4876 * If still no link, perhaps using 2/3 pair cable
4878 (void) e1000_read_phy_reg(hw
, PHY_1000T_CTRL
, &phy_ctrl
);
4879 phy_ctrl
|= CR_1000T_MS_ENABLE
;
4880 (void) e1000_write_phy_reg(hw
, PHY_1000T_CTRL
, phy_ctrl
);
4882 * Restart autoneg with phy enabled for manual
4883 * configuration of master/slave
4885 if (!e1000_phy_setup_autoneg(hw
) &&
4886 !e1000_read_phy_reg(hw
, PHY_CONTROL
, &phy_ctrl
)) {
4888 (MII_CR_AUTO_NEG_EN
| MII_CR_RESTART_AUTO_NEG
);
4889 (void) e1000_write_phy_reg(hw
, PHY_CONTROL
, phy_ctrl
);
4892 * Hopefully, there are no more faults and we've obtained
4897 * Restart process after E1000_SMARTSPEED_MAX iterations (30
4900 if (Adapter
->smartspeed
++ == E1000_SMARTSPEED_MAX
)
4901 Adapter
->smartspeed
= 0;
4905 is_valid_mac_addr(uint8_t *mac_addr
)
4907 const uint8_t addr_test1
[6] = { 0, 0, 0, 0, 0, 0 };
4908 const uint8_t addr_test2
[6] =
4909 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
4911 if (!(bcmp(addr_test1
, mac_addr
, ETHERADDRL
)) ||
4912 !(bcmp(addr_test2
, mac_addr
, ETHERADDRL
)))
4919 * e1000g_stall_check - check for tx stall
4921 * This function checks if the adapter is stalled (in transmit).
4923 * It is called each time the watchdog timeout is invoked.
4924 * If the transmit descriptor reclaim continuously fails,
4925 * the watchdog value will increment by 1. If the watchdog
4926 * value exceeds the threshold, the adapter is assumed to
4927 * have stalled and need to be reset.
4930 e1000g_stall_check(struct e1000g
*Adapter
)
4932 e1000g_tx_ring_t
*tx_ring
;
4934 tx_ring
= Adapter
->tx_ring
;
4936 if (Adapter
->link_state
!= LINK_STATE_UP
)
4939 (void) e1000g_recycle(tx_ring
);
4941 if (Adapter
->stall_flag
)
4948 static enum ioc_reply
4949 e1000g_pp_ioctl(struct e1000g
*e1000gp
, struct iocblk
*iocp
, mblk_t
*mp
)
4951 void (*ppfn
)(struct e1000g
*e1000gp
, e1000g_peekpoke_t
*ppd
);
4952 e1000g_peekpoke_t
*ppd
;
4957 switch (iocp
->ioc_cmd
) {
4959 case E1000G_IOC_REG_PEEK
:
4963 case E1000G_IOC_REG_POKE
:
4968 E1000G_DEBUGLOG_1(e1000gp
, E1000G_INFO_LEVEL
,
4969 "e1000g_diag_ioctl: invalid ioctl command 0x%X\n",
4975 * Validate format of ioctl
4977 if (iocp
->ioc_count
!= sizeof (e1000g_peekpoke_t
))
4979 if (mp
->b_cont
== NULL
)
4982 ppd
= (e1000g_peekpoke_t
*)(uintptr_t)mp
->b_cont
->b_rptr
;
4985 * Validate request parameters
4987 switch (ppd
->pp_acc_space
) {
4990 E1000G_DEBUGLOG_1(e1000gp
, E1000G_INFO_LEVEL
,
4991 "e1000g_diag_ioctl: invalid access space 0x%X\n",
4995 case E1000G_PP_SPACE_REG
:
4997 * Memory-mapped I/O space
4999 ASSERT(ppd
->pp_acc_size
== 4);
5000 if (ppd
->pp_acc_size
!= 4)
5003 if ((ppd
->pp_acc_offset
% ppd
->pp_acc_size
) != 0)
5008 ppfn
= peek
? e1000g_ioc_peek_reg
: e1000g_ioc_poke_reg
;
5011 case E1000G_PP_SPACE_E1000G
:
5013 * E1000g data structure!
5015 mem_va
= (uintptr_t)e1000gp
;
5016 maxoff
= sizeof (struct e1000g
);
5017 ppfn
= peek
? e1000g_ioc_peek_mem
: e1000g_ioc_poke_mem
;
5022 if (ppd
->pp_acc_offset
>= maxoff
)
5025 if (ppd
->pp_acc_offset
+ ppd
->pp_acc_size
> maxoff
)
5031 ppd
->pp_acc_offset
+= mem_va
;
5032 (*ppfn
)(e1000gp
, ppd
);
5033 return (peek
? IOC_REPLY
: IOC_ACK
);
5037 e1000g_ioc_peek_reg(struct e1000g
*e1000gp
, e1000g_peekpoke_t
*ppd
)
5039 ddi_acc_handle_t handle
;
5042 handle
= e1000gp
->osdep
.reg_handle
;
5043 regaddr
= (uint32_t *)((uintptr_t)e1000gp
->shared
.hw_addr
+
5044 (uintptr_t)ppd
->pp_acc_offset
);
5046 ppd
->pp_acc_data
= ddi_get32(handle
, regaddr
);
5050 e1000g_ioc_poke_reg(struct e1000g
*e1000gp
, e1000g_peekpoke_t
*ppd
)
5052 ddi_acc_handle_t handle
;
5056 handle
= e1000gp
->osdep
.reg_handle
;
5057 regaddr
= (uint32_t *)((uintptr_t)e1000gp
->shared
.hw_addr
+
5058 (uintptr_t)ppd
->pp_acc_offset
);
5059 value
= (uint32_t)ppd
->pp_acc_data
;
5061 ddi_put32(handle
, regaddr
, value
);
5065 e1000g_ioc_peek_mem(struct e1000g
*e1000gp
, e1000g_peekpoke_t
*ppd
)
5070 vaddr
= (void *)(uintptr_t)ppd
->pp_acc_offset
;
5072 switch (ppd
->pp_acc_size
) {
5074 value
= *(uint8_t *)vaddr
;
5078 value
= *(uint16_t *)vaddr
;
5082 value
= *(uint32_t *)vaddr
;
5086 value
= *(uint64_t *)vaddr
;
5090 E1000G_DEBUGLOG_4(e1000gp
, E1000G_INFO_LEVEL
,
5091 "e1000g_ioc_peek_mem($%p, $%p) peeked 0x%llx from $%p\n",
5092 (void *)e1000gp
, (void *)ppd
, value
, vaddr
);
5094 ppd
->pp_acc_data
= value
;
5098 e1000g_ioc_poke_mem(struct e1000g
*e1000gp
, e1000g_peekpoke_t
*ppd
)
5103 vaddr
= (void *)(uintptr_t)ppd
->pp_acc_offset
;
5104 value
= ppd
->pp_acc_data
;
5106 E1000G_DEBUGLOG_4(e1000gp
, E1000G_INFO_LEVEL
,
5107 "e1000g_ioc_poke_mem($%p, $%p) poking 0x%llx at $%p\n",
5108 (void *)e1000gp
, (void *)ppd
, value
, vaddr
);
5110 switch (ppd
->pp_acc_size
) {
5112 *(uint8_t *)vaddr
= (uint8_t)value
;
5116 *(uint16_t *)vaddr
= (uint16_t)value
;
5120 *(uint32_t *)vaddr
= (uint32_t)value
;
5124 *(uint64_t *)vaddr
= (uint64_t)value
;
5133 static lb_property_t lb_normal
=
5134 { normal
, "normal", E1000G_LB_NONE
};
5135 static lb_property_t lb_external1000
=
5136 { external
, "1000Mbps", E1000G_LB_EXTERNAL_1000
};
5137 static lb_property_t lb_external100
=
5138 { external
, "100Mbps", E1000G_LB_EXTERNAL_100
};
5139 static lb_property_t lb_external10
=
5140 { external
, "10Mbps", E1000G_LB_EXTERNAL_10
};
5141 static lb_property_t lb_phy
=
5142 { internal
, "PHY", E1000G_LB_INTERNAL_PHY
};
5144 static enum ioc_reply
5145 e1000g_loopback_ioctl(struct e1000g
*Adapter
, struct iocblk
*iocp
, mblk_t
*mp
)
5148 lb_property_t
*lbpp
;
5149 struct e1000_hw
*hw
;
5154 hw
= &Adapter
->shared
;
5156 if (mp
->b_cont
== NULL
)
5159 if (!e1000g_check_loopback_support(hw
)) {
5160 e1000g_log(NULL
, CE_WARN
,
5161 "Loopback is not supported on e1000g%d", Adapter
->instance
);
5165 switch (iocp
->ioc_cmd
) {
5169 case LB_GET_INFO_SIZE
:
5170 size
= sizeof (lb_info_sz_t
);
5171 if (iocp
->ioc_count
!= size
)
5174 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
5175 e1000g_get_phy_state(Adapter
);
5178 * Workaround for hardware faults. In order to get a stable
5179 * state of phy, we will wait for a specific interval and
5180 * try again. The time delay is an experiential value based
5184 e1000g_get_phy_state(Adapter
);
5185 rw_exit(&Adapter
->chip_lock
);
5187 value
= sizeof (lb_normal
);
5188 if ((Adapter
->phy_ext_status
& IEEE_ESR_1000T_FD_CAPS
) ||
5189 (Adapter
->phy_ext_status
& IEEE_ESR_1000X_FD_CAPS
) ||
5190 (hw
->phy
.media_type
== e1000_media_type_fiber
) ||
5191 (hw
->phy
.media_type
== e1000_media_type_internal_serdes
)) {
5192 value
+= sizeof (lb_phy
);
5193 switch (hw
->mac
.type
) {
5196 case e1000_80003es2lan
:
5197 value
+= sizeof (lb_external1000
);
5201 if ((Adapter
->phy_status
& MII_SR_100X_FD_CAPS
) ||
5202 (Adapter
->phy_status
& MII_SR_100T2_FD_CAPS
))
5203 value
+= sizeof (lb_external100
);
5204 if (Adapter
->phy_status
& MII_SR_10T_FD_CAPS
)
5205 value
+= sizeof (lb_external10
);
5207 lbsp
= (lb_info_sz_t
*)(uintptr_t)mp
->b_cont
->b_rptr
;
5212 value
= sizeof (lb_normal
);
5213 if ((Adapter
->phy_ext_status
& IEEE_ESR_1000T_FD_CAPS
) ||
5214 (Adapter
->phy_ext_status
& IEEE_ESR_1000X_FD_CAPS
) ||
5215 (hw
->phy
.media_type
== e1000_media_type_fiber
) ||
5216 (hw
->phy
.media_type
== e1000_media_type_internal_serdes
)) {
5217 value
+= sizeof (lb_phy
);
5218 switch (hw
->mac
.type
) {
5221 case e1000_80003es2lan
:
5222 value
+= sizeof (lb_external1000
);
5226 if ((Adapter
->phy_status
& MII_SR_100X_FD_CAPS
) ||
5227 (Adapter
->phy_status
& MII_SR_100T2_FD_CAPS
))
5228 value
+= sizeof (lb_external100
);
5229 if (Adapter
->phy_status
& MII_SR_10T_FD_CAPS
)
5230 value
+= sizeof (lb_external10
);
5233 if (iocp
->ioc_count
!= size
)
5237 lbpp
= (lb_property_t
*)(uintptr_t)mp
->b_cont
->b_rptr
;
5238 lbpp
[value
++] = lb_normal
;
5239 if ((Adapter
->phy_ext_status
& IEEE_ESR_1000T_FD_CAPS
) ||
5240 (Adapter
->phy_ext_status
& IEEE_ESR_1000X_FD_CAPS
) ||
5241 (hw
->phy
.media_type
== e1000_media_type_fiber
) ||
5242 (hw
->phy
.media_type
== e1000_media_type_internal_serdes
)) {
5243 lbpp
[value
++] = lb_phy
;
5244 switch (hw
->mac
.type
) {
5247 case e1000_80003es2lan
:
5248 lbpp
[value
++] = lb_external1000
;
5252 if ((Adapter
->phy_status
& MII_SR_100X_FD_CAPS
) ||
5253 (Adapter
->phy_status
& MII_SR_100T2_FD_CAPS
))
5254 lbpp
[value
++] = lb_external100
;
5255 if (Adapter
->phy_status
& MII_SR_10T_FD_CAPS
)
5256 lbpp
[value
++] = lb_external10
;
5260 size
= sizeof (uint32_t);
5261 if (iocp
->ioc_count
!= size
)
5264 lbmp
= (uint32_t *)(uintptr_t)mp
->b_cont
->b_rptr
;
5265 *lbmp
= Adapter
->loopback_mode
;
5270 if (iocp
->ioc_count
!= sizeof (uint32_t))
5273 lbmp
= (uint32_t *)(uintptr_t)mp
->b_cont
->b_rptr
;
5274 if (!e1000g_set_loopback_mode(Adapter
, *lbmp
))
5279 iocp
->ioc_count
= size
;
5280 iocp
->ioc_error
= 0;
5282 if (e1000g_check_acc_handle(Adapter
->osdep
.reg_handle
) != DDI_FM_OK
) {
5283 ddi_fm_service_impact(Adapter
->dip
, DDI_SERVICE_DEGRADED
);
5291 e1000g_check_loopback_support(struct e1000_hw
*hw
)
5293 switch (hw
->mac
.type
) {
5296 case e1000_82545_rev_3
:
5298 case e1000_82546_rev_3
:
5300 case e1000_82541_rev_2
:
5302 case e1000_82547_rev_2
:
5307 case e1000_80003es2lan
:
5309 case e1000_ich10lan
:
5316 e1000g_set_loopback_mode(struct e1000g
*Adapter
, uint32_t mode
)
5318 struct e1000_hw
*hw
;
5322 if (mode
== Adapter
->loopback_mode
)
5325 hw
= &Adapter
->shared
;
5328 Adapter
->loopback_mode
= mode
;
5330 if (mode
== E1000G_LB_NONE
) {
5331 /* Reset the chip */
5332 hw
->phy
.autoneg_wait_to_complete
= B_TRUE
;
5333 (void) e1000g_reset_adapter(Adapter
);
5334 hw
->phy
.autoneg_wait_to_complete
= B_FALSE
;
5340 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
5344 rw_exit(&Adapter
->chip_lock
);
5347 case E1000G_LB_EXTERNAL_1000
:
5348 e1000g_set_external_loopback_1000(Adapter
);
5351 case E1000G_LB_EXTERNAL_100
:
5352 e1000g_set_external_loopback_100(Adapter
);
5355 case E1000G_LB_EXTERNAL_10
:
5356 e1000g_set_external_loopback_10(Adapter
);
5359 case E1000G_LB_INTERNAL_PHY
:
5360 e1000g_set_internal_loopback(Adapter
);
5366 rw_exit(&Adapter
->chip_lock
);
5368 /* Wait for link up */
5369 for (i
= (PHY_FORCE_LIMIT
* 2); i
> 0; i
--)
5372 rw_enter(&Adapter
->chip_lock
, RW_WRITER
);
5374 link_up
= e1000g_link_up(Adapter
);
5376 rw_exit(&Adapter
->chip_lock
);
5379 E1000G_DEBUGLOG_0(Adapter
, E1000G_INFO_LEVEL
,
5380 "Failed to get the link up");
5382 /* Reset the link */
5383 E1000G_DEBUGLOG_0(Adapter
, E1000G_INFO_LEVEL
,
5384 "Reset the link ...");
5385 (void) e1000g_reset_adapter(Adapter
);
5390 * Reset driver to loopback none when set loopback failed
5391 * for the second time.
5393 Adapter
->loopback_mode
= E1000G_LB_NONE
;
5395 /* Reset the chip */
5396 hw
->phy
.autoneg_wait_to_complete
= B_TRUE
;
5397 (void) e1000g_reset_adapter(Adapter
);
5398 hw
->phy
.autoneg_wait_to_complete
= B_FALSE
;
5400 E1000G_DEBUGLOG_0(Adapter
, E1000G_INFO_LEVEL
,
5401 "Set loopback mode failed, reset to loopback none");
5410 * The following loopback settings are from Intel's technical
5411 * document - "How To Loopback". All the register settings and
5412 * time delay values are directly inherited from the document
5413 * without more explanations available.
5416 e1000g_set_internal_loopback(struct e1000g
*Adapter
)
5418 struct e1000_hw
*hw
;
5425 hw
= &Adapter
->shared
;
5427 /* Disable Smart Power Down */
5428 phy_spd_state(hw
, B_FALSE
);
5430 (void) e1000_read_phy_reg(hw
, PHY_CONTROL
, &phy_ctrl
);
5431 phy_ctrl
&= ~(MII_CR_AUTO_NEG_EN
| MII_CR_SPEED_100
| MII_CR_SPEED_10
);
5432 phy_ctrl
|= MII_CR_FULL_DUPLEX
| MII_CR_SPEED_1000
;
5434 switch (hw
->mac
.type
) {
5437 case e1000_82545_rev_3
:
5439 case e1000_82546_rev_3
:
5441 /* Auto-MDI/MDIX off */
5442 (void) e1000_write_phy_reg(hw
, M88E1000_PHY_SPEC_CTRL
, 0x0808);
5443 /* Reset PHY to update Auto-MDI/MDIX */
5444 (void) e1000_write_phy_reg(hw
, PHY_CONTROL
,
5445 phy_ctrl
| MII_CR_RESET
| MII_CR_AUTO_NEG_EN
);
5446 /* Reset PHY to auto-neg off and force 1000 */
5447 (void) e1000_write_phy_reg(hw
, PHY_CONTROL
,
5448 phy_ctrl
| MII_CR_RESET
);
5450 * Disable PHY receiver for 82540/545/546 and 82573 Family.
5451 * See comments above e1000g_set_internal_loopback() for the
5454 (void) e1000_write_phy_reg(hw
, 29, 0x001F);
5455 (void) e1000_write_phy_reg(hw
, 30, 0x8FFC);
5456 (void) e1000_write_phy_reg(hw
, 29, 0x001A);
5457 (void) e1000_write_phy_reg(hw
, 30, 0x8FF0);
5459 case e1000_80003es2lan
:
5461 (void) e1000_write_phy_reg(hw
, GG82563_PHY_KMRN_MODE_CTRL
,
5463 /* Sets PCS loopback at 1Gbs */
5464 (void) e1000_write_phy_reg(hw
, GG82563_PHY_MAC_SPEC_CTRL
,
5470 * The following registers should be set for e1000_phy_bm phy type.
5471 * e1000_82574, e1000_ich10lan and some e1000_ich9lan use this phy.
5472 * For others, we do not need to set these registers.
5474 if (hw
->phy
.type
== e1000_phy_bm
) {
5475 /* Set Default MAC Interface speed to 1GB */
5476 (void) e1000_read_phy_reg(hw
, PHY_REG(2, 21), &phy_reg
);
5479 (void) e1000_write_phy_reg(hw
, PHY_REG(2, 21), phy_reg
);
5480 /* Assert SW reset for above settings to take effect */
5481 (void) e1000_phy_commit(hw
);
5483 /* Force Full Duplex */
5484 (void) e1000_read_phy_reg(hw
, PHY_REG(769, 16), &phy_reg
);
5485 (void) e1000_write_phy_reg(hw
, PHY_REG(769, 16),
5487 /* Set Link Up (in force link) */
5488 (void) e1000_read_phy_reg(hw
, PHY_REG(776, 16), &phy_reg
);
5489 (void) e1000_write_phy_reg(hw
, PHY_REG(776, 16),
5492 (void) e1000_read_phy_reg(hw
, PHY_REG(769, 16), &phy_reg
);
5493 (void) e1000_write_phy_reg(hw
, PHY_REG(769, 16),
5495 /* Set Early Link Enable */
5496 (void) e1000_read_phy_reg(hw
, PHY_REG(769, 20), &phy_reg
);
5497 (void) e1000_write_phy_reg(hw
, PHY_REG(769, 20),
5502 (void) e1000_write_phy_reg(hw
, PHY_CONTROL
, phy_ctrl
| MII_CR_LOOPBACK
);
5506 /* Now set up the MAC to the same speed/duplex as the PHY. */
5507 ctrl
= E1000_READ_REG(hw
, E1000_CTRL
);
5508 ctrl
&= ~E1000_CTRL_SPD_SEL
; /* Clear the speed sel bits */
5509 ctrl
|= (E1000_CTRL_FRCSPD
| /* Set the Force Speed Bit */
5510 E1000_CTRL_FRCDPX
| /* Set the Force Duplex Bit */
5511 E1000_CTRL_SPD_1000
| /* Force Speed to 1000 */
5512 E1000_CTRL_FD
); /* Force Duplex to FULL */
5514 switch (hw
->mac
.type
) {
5517 case e1000_82545_rev_3
:
5519 case e1000_82546_rev_3
:
5521 * For some serdes we'll need to commit the writes now
5522 * so that the status is updated on link
5524 if (hw
->phy
.media_type
== e1000_media_type_internal_serdes
) {
5525 E1000_WRITE_REG(hw
, E1000_CTRL
, ctrl
);
5527 ctrl
= E1000_READ_REG(hw
, E1000_CTRL
);
5530 if (hw
->phy
.media_type
== e1000_media_type_copper
) {
5531 /* Invert Loss of Signal */
5532 ctrl
|= E1000_CTRL_ILOS
;
5534 /* Set ILOS on fiber nic if half duplex is detected */
5535 status
= E1000_READ_REG(hw
, E1000_STATUS
);
5536 if ((status
& E1000_STATUS_FD
) == 0)
5537 ctrl
|= E1000_CTRL_ILOS
| E1000_CTRL_SLU
;
5544 * The fiber/SerDes versions of this adapter do not contain an
5545 * accessible PHY. Therefore, loopback beyond MAC must be done
5546 * using SerDes analog loopback.
5548 if (hw
->phy
.media_type
!= e1000_media_type_copper
) {
5549 /* Disable autoneg by setting bit 31 of TXCW to zero */
5550 txcw
= E1000_READ_REG(hw
, E1000_TXCW
);
5551 txcw
&= ~((uint32_t)1 << 31);
5552 E1000_WRITE_REG(hw
, E1000_TXCW
, txcw
);
5555 * Write 0x410 to Serdes Control register
5556 * to enable Serdes analog loopback
5558 E1000_WRITE_REG(hw
, E1000_SCTL
, 0x0410);
5562 status
= E1000_READ_REG(hw
, E1000_STATUS
);
5563 /* Set ILOS on fiber nic if half duplex is detected */
5564 if ((hw
->phy
.media_type
== e1000_media_type_fiber
) &&
5565 ((status
& E1000_STATUS_FD
) == 0 ||
5566 (status
& E1000_STATUS_LU
) == 0))
5567 ctrl
|= E1000_CTRL_ILOS
| E1000_CTRL_SLU
;
5568 else if (hw
->phy
.media_type
== e1000_media_type_internal_serdes
)
5569 ctrl
|= E1000_CTRL_SLU
;
5573 ctrl
|= E1000_CTRL_ILOS
;
5576 case e1000_ich10lan
:
5577 ctrl
|= E1000_CTRL_SLU
;
5580 if (hw
->phy
.type
== e1000_phy_bm
)
5581 ctrl
|= E1000_CTRL_SLU
| E1000_CTRL_ILOS
;
5583 E1000_WRITE_REG(hw
, E1000_CTRL
, ctrl
);
5587 e1000g_set_external_loopback_1000(struct e1000g
*Adapter
)
5589 struct e1000_hw
*hw
;
5597 hw
= &Adapter
->shared
;
5599 /* Disable Smart Power Down */
5600 phy_spd_state(hw
, B_FALSE
);
5602 switch (hw
->mac
.type
) {
5605 switch (hw
->phy
.media_type
) {
5606 case e1000_media_type_copper
:
5607 /* Force link up (Must be done before the PHY writes) */
5608 ctrl
= E1000_READ_REG(hw
, E1000_CTRL
);
5609 ctrl
|= E1000_CTRL_SLU
; /* Force Link Up */
5610 E1000_WRITE_REG(hw
, E1000_CTRL
, ctrl
);
5612 rctl
= E1000_READ_REG(hw
, E1000_RCTL
);
5613 rctl
|= (E1000_RCTL_EN
|
5618 E1000_RCTL_BAM
); /* 0x803E */
5619 E1000_WRITE_REG(hw
, E1000_RCTL
, rctl
);
5621 ctrl_ext
= E1000_READ_REG(hw
, E1000_CTRL_EXT
);
5622 ctrl_ext
|= (E1000_CTRL_EXT_SDP4_DATA
|
5623 E1000_CTRL_EXT_SDP6_DATA
|
5624 E1000_CTRL_EXT_SDP3_DATA
|
5625 E1000_CTRL_EXT_SDP4_DIR
|
5626 E1000_CTRL_EXT_SDP6_DIR
|
5627 E1000_CTRL_EXT_SDP3_DIR
); /* 0x0DD0 */
5628 E1000_WRITE_REG(hw
, E1000_CTRL_EXT
, ctrl_ext
);
5631 * This sequence tunes the PHY's SDP and no customer
5632 * settable values. For background, see comments above
5633 * e1000g_set_internal_loopback().
5635 (void) e1000_write_phy_reg(hw
, 0x0, 0x140);
5637 (void) e1000_write_phy_reg(hw
, 0x9, 0x1A00);
5638 (void) e1000_write_phy_reg(hw
, 0x12, 0xC10);
5639 (void) e1000_write_phy_reg(hw
, 0x12, 0x1C10);
5640 (void) e1000_write_phy_reg(hw
, 0x1F37, 0x76);
5641 (void) e1000_write_phy_reg(hw
, 0x1F33, 0x1);
5642 (void) e1000_write_phy_reg(hw
, 0x1F33, 0x0);
5644 (void) e1000_write_phy_reg(hw
, 0x1F35, 0x65);
5645 (void) e1000_write_phy_reg(hw
, 0x1837, 0x3F7C);
5646 (void) e1000_write_phy_reg(hw
, 0x1437, 0x3FDC);
5647 (void) e1000_write_phy_reg(hw
, 0x1237, 0x3F7C);
5648 (void) e1000_write_phy_reg(hw
, 0x1137, 0x3FDC);
5652 case e1000_media_type_fiber
:
5653 case e1000_media_type_internal_serdes
:
5654 status
= E1000_READ_REG(hw
, E1000_STATUS
);
5655 if (((status
& E1000_STATUS_LU
) == 0) ||
5656 (hw
->phy
.media_type
==
5657 e1000_media_type_internal_serdes
)) {
5658 ctrl
= E1000_READ_REG(hw
, E1000_CTRL
);
5659 ctrl
|= E1000_CTRL_ILOS
| E1000_CTRL_SLU
;
5660 E1000_WRITE_REG(hw
, E1000_CTRL
, ctrl
);
5663 /* Disable autoneg by setting bit 31 of TXCW to zero */
5664 txcw
= E1000_READ_REG(hw
, E1000_TXCW
);
5665 txcw
&= ~((uint32_t)1 << 31);
5666 E1000_WRITE_REG(hw
, E1000_TXCW
, txcw
);
5669 * Write 0x410 to Serdes Control register
5670 * to enable Serdes analog loopback
5672 E1000_WRITE_REG(hw
, E1000_SCTL
, 0x0410);
5680 case e1000_80003es2lan
:
5682 case e1000_ich10lan
:
5683 (void) e1000_read_phy_reg(hw
, GG82563_REG(6, 16), &phydata
);
5684 (void) e1000_write_phy_reg(hw
, GG82563_REG(6, 16),
5685 phydata
| (1 << 5));
5686 Adapter
->param_adv_autoneg
= 1;
5687 Adapter
->param_adv_1000fdx
= 1;
5688 (void) e1000g_reset_link(Adapter
);
5694 e1000g_set_external_loopback_100(struct e1000g
*Adapter
)
5696 struct e1000_hw
*hw
;
5700 hw
= &Adapter
->shared
;
5702 /* Disable Smart Power Down */
5703 phy_spd_state(hw
, B_FALSE
);
5705 phy_ctrl
= (MII_CR_FULL_DUPLEX
|
5708 /* Force 100/FD, reset PHY */
5709 (void) e1000_write_phy_reg(hw
, PHY_CONTROL
,
5710 phy_ctrl
| MII_CR_RESET
); /* 0xA100 */
5714 (void) e1000_write_phy_reg(hw
, PHY_CONTROL
,
5715 phy_ctrl
); /* 0x2100 */
5718 /* Now setup the MAC to the same speed/duplex as the PHY. */
5719 ctrl
= E1000_READ_REG(hw
, E1000_CTRL
);
5720 ctrl
&= ~E1000_CTRL_SPD_SEL
; /* Clear the speed sel bits */
5721 ctrl
|= (E1000_CTRL_SLU
| /* Force Link Up */
5722 E1000_CTRL_FRCSPD
| /* Set the Force Speed Bit */
5723 E1000_CTRL_FRCDPX
| /* Set the Force Duplex Bit */
5724 E1000_CTRL_SPD_100
| /* Force Speed to 100 */
5725 E1000_CTRL_FD
); /* Force Duplex to FULL */
5727 E1000_WRITE_REG(hw
, E1000_CTRL
, ctrl
);
5731 e1000g_set_external_loopback_10(struct e1000g
*Adapter
)
5733 struct e1000_hw
*hw
;
5737 hw
= &Adapter
->shared
;
5739 /* Disable Smart Power Down */
5740 phy_spd_state(hw
, B_FALSE
);
5742 phy_ctrl
= (MII_CR_FULL_DUPLEX
|
5745 /* Force 10/FD, reset PHY */
5746 (void) e1000_write_phy_reg(hw
, PHY_CONTROL
,
5747 phy_ctrl
| MII_CR_RESET
); /* 0x8100 */
5751 (void) e1000_write_phy_reg(hw
, PHY_CONTROL
,
5752 phy_ctrl
); /* 0x0100 */
5755 /* Now setup the MAC to the same speed/duplex as the PHY. */
5756 ctrl
= E1000_READ_REG(hw
, E1000_CTRL
);
5757 ctrl
&= ~E1000_CTRL_SPD_SEL
; /* Clear the speed sel bits */
5758 ctrl
|= (E1000_CTRL_SLU
| /* Force Link Up */
5759 E1000_CTRL_FRCSPD
| /* Set the Force Speed Bit */
5760 E1000_CTRL_FRCDPX
| /* Set the Force Duplex Bit */
5761 E1000_CTRL_SPD_10
| /* Force Speed to 10 */
5762 E1000_CTRL_FD
); /* Force Duplex to FULL */
5764 E1000_WRITE_REG(hw
, E1000_CTRL
, ctrl
);
5769 e1000g_find_mac_address(struct e1000g
*Adapter
)
5771 struct e1000_hw
*hw
= &Adapter
->shared
;
5773 struct ether_addr sysaddr
;
5776 boolean_t found
= B_FALSE
;
5779 * The "vendor's factory-set address" may already have
5780 * been extracted from the chip, but if the property
5781 * "local-mac-address" is set we use that instead.
5783 * We check whether it looks like an array of 6
5784 * bytes (which it should, if OBP set it). If we can't
5785 * make sense of it this way, we'll ignore it.
5787 err
= ddi_prop_lookup_byte_array(DDI_DEV_T_ANY
, Adapter
->dip
,
5788 DDI_PROP_DONTPASS
, "local-mac-address", &bytes
, &nelts
);
5789 if (err
== DDI_PROP_SUCCESS
) {
5790 if (nelts
== ETHERADDRL
) {
5792 hw
->mac
.addr
[nelts
] = bytes
[nelts
];
5795 ddi_prop_free(bytes
);
5799 * Look up the OBP property "local-mac-address?". If the user has set
5800 * 'local-mac-address? = false', use "the system address" instead.
5802 if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY
, Adapter
->dip
, 0,
5803 "local-mac-address?", &bytes
, &nelts
) == DDI_PROP_SUCCESS
) {
5804 if (strncmp("false", (caddr_t
)bytes
, (size_t)nelts
) == 0) {
5805 if (localetheraddr(NULL
, &sysaddr
) != 0) {
5806 bcopy(&sysaddr
, hw
->mac
.addr
, ETHERADDRL
);
5810 ddi_prop_free(bytes
);
5814 * Finally(!), if there's a valid "mac-address" property (created
5815 * if we netbooted from this interface), we must use this instead
5816 * of any of the above to ensure that the NFS/install server doesn't
5817 * get confused by the address changing as Solaris takes over!
5819 err
= ddi_prop_lookup_byte_array(DDI_DEV_T_ANY
, Adapter
->dip
,
5820 DDI_PROP_DONTPASS
, "mac-address", &bytes
, &nelts
);
5821 if (err
== DDI_PROP_SUCCESS
) {
5822 if (nelts
== ETHERADDRL
) {
5824 hw
->mac
.addr
[nelts
] = bytes
[nelts
];
5827 ddi_prop_free(bytes
);
5831 bcopy(hw
->mac
.addr
, hw
->mac
.perm_addr
,
5840 e1000g_add_intrs(struct e1000g
*Adapter
)
5842 dev_info_t
*devinfo
;
5846 devinfo
= Adapter
->dip
;
5848 /* Get supported interrupt types */
5849 rc
= ddi_intr_get_supported_types(devinfo
, &intr_types
);
5851 if (rc
!= DDI_SUCCESS
) {
5852 E1000G_DEBUGLOG_1(Adapter
, E1000G_WARN_LEVEL
,
5853 "Get supported interrupt types failed: %d\n", rc
);
5854 return (DDI_FAILURE
);
5858 * Based on Intel Technical Advisory document (TA-160), there are some
5859 * cases where some older Intel PCI-X NICs may "advertise" to the OS
5860 * that it supports MSI, but in fact has problems.
5861 * So we should only enable MSI for PCI-E NICs and disable MSI for old
5864 if (Adapter
->shared
.mac
.type
< e1000_82571
)
5865 Adapter
->msi_enable
= B_FALSE
;
5867 if ((intr_types
& DDI_INTR_TYPE_MSI
) && Adapter
->msi_enable
) {
5868 rc
= e1000g_intr_add(Adapter
, DDI_INTR_TYPE_MSI
);
5870 if (rc
!= DDI_SUCCESS
) {
5872 E1000G_DEBUGLOG_0(Adapter
, E1000G_WARN_LEVEL
,
5873 "Add MSI failed, trying Legacy interrupts\n");
5875 Adapter
->intr_type
= DDI_INTR_TYPE_MSI
;
5879 if ((Adapter
->intr_type
== 0) &&
5880 (intr_types
& DDI_INTR_TYPE_FIXED
)) {
5881 rc
= e1000g_intr_add(Adapter
, DDI_INTR_TYPE_FIXED
);
5883 if (rc
!= DDI_SUCCESS
) {
5884 E1000G_DEBUGLOG_0(Adapter
, E1000G_WARN_LEVEL
,
5885 "Add Legacy interrupts failed\n");
5886 return (DDI_FAILURE
);
5889 Adapter
->intr_type
= DDI_INTR_TYPE_FIXED
;
5892 if (Adapter
->intr_type
== 0) {
5893 E1000G_DEBUGLOG_0(Adapter
, E1000G_WARN_LEVEL
,
5894 "No interrupts registered\n");
5895 return (DDI_FAILURE
);
5898 return (DDI_SUCCESS
);
5902 * e1000g_intr_add() handles MSI/Legacy interrupts
5905 e1000g_intr_add(struct e1000g
*Adapter
, int intr_type
)
5907 dev_info_t
*devinfo
;
5908 int count
, avail
, actual
;
5909 int x
, y
, rc
, inum
= 0;
5911 ddi_intr_handler_t
*intr_handler
;
5913 devinfo
= Adapter
->dip
;
5915 /* get number of interrupts */
5916 rc
= ddi_intr_get_nintrs(devinfo
, intr_type
, &count
);
5917 if ((rc
!= DDI_SUCCESS
) || (count
== 0)) {
5918 E1000G_DEBUGLOG_2(Adapter
, E1000G_WARN_LEVEL
,
5919 "Get interrupt number failed. Return: %d, count: %d\n",
5921 return (DDI_FAILURE
);
5924 /* get number of available interrupts */
5925 rc
= ddi_intr_get_navail(devinfo
, intr_type
, &avail
);
5926 if ((rc
!= DDI_SUCCESS
) || (avail
== 0)) {
5927 E1000G_DEBUGLOG_2(Adapter
, E1000G_WARN_LEVEL
,
5928 "Get interrupt available number failed. "
5929 "Return: %d, available: %d\n", rc
, avail
);
5930 return (DDI_FAILURE
);
5933 if (avail
< count
) {
5935 E1000G_DEBUGLOG_2(Adapter
, E1000G_WARN_LEVEL
,
5936 "Interrupts count: %d, available: %d\n",
5940 /* Allocate an array of interrupt handles */
5941 Adapter
->intr_size
= count
* sizeof (ddi_intr_handle_t
);
5942 Adapter
->htable
= kmem_alloc(Adapter
->intr_size
, KM_SLEEP
);
5944 /* Set NORMAL behavior for both MSI and FIXED interrupt */
5945 flag
= DDI_INTR_ALLOC_NORMAL
;
5947 /* call ddi_intr_alloc() */
5948 rc
= ddi_intr_alloc(devinfo
, Adapter
->htable
, intr_type
, inum
,
5949 count
, &actual
, flag
);
5951 if ((rc
!= DDI_SUCCESS
) || (actual
== 0)) {
5952 E1000G_DEBUGLOG_1(Adapter
, E1000G_WARN_LEVEL
,
5953 "Allocate interrupts failed: %d\n", rc
);
5955 kmem_free(Adapter
->htable
, Adapter
->intr_size
);
5956 return (DDI_FAILURE
);
5959 if (actual
< count
) {
5961 E1000G_DEBUGLOG_2(Adapter
, E1000G_WARN_LEVEL
,
5962 "Interrupts requested: %d, received: %d\n",
5966 Adapter
->intr_cnt
= actual
;
5968 /* Get priority for first msi, assume remaining are all the same */
5969 rc
= ddi_intr_get_pri(Adapter
->htable
[0], &Adapter
->intr_pri
);
5971 if (rc
!= DDI_SUCCESS
) {
5972 E1000G_DEBUGLOG_1(Adapter
, E1000G_WARN_LEVEL
,
5973 "Get interrupt priority failed: %d\n", rc
);
5975 /* Free already allocated intr */
5976 for (y
= 0; y
< actual
; y
++)
5977 (void) ddi_intr_free(Adapter
->htable
[y
]);
5979 kmem_free(Adapter
->htable
, Adapter
->intr_size
);
5980 return (DDI_FAILURE
);
5984 * In Legacy Interrupt mode, for PCI-Express adapters, we should
5985 * use the interrupt service routine e1000g_intr_pciexpress()
5986 * to avoid interrupt stealing when sharing interrupt with other
5989 if (Adapter
->shared
.mac
.type
< e1000_82571
)
5990 intr_handler
= (ddi_intr_handler_t
*)e1000g_intr
;
5992 intr_handler
= (ddi_intr_handler_t
*)e1000g_intr_pciexpress
;
5994 /* Call ddi_intr_add_handler() */
5995 for (x
= 0; x
< actual
; x
++) {
5996 rc
= ddi_intr_add_handler(Adapter
->htable
[x
],
5997 intr_handler
, (caddr_t
)Adapter
, NULL
);
5999 if (rc
!= DDI_SUCCESS
) {
6000 E1000G_DEBUGLOG_1(Adapter
, E1000G_WARN_LEVEL
,
6001 "Add interrupt handler failed: %d\n", rc
);
6003 /* Remove already added handler */
6004 for (y
= 0; y
< x
; y
++)
6005 (void) ddi_intr_remove_handler(
6006 Adapter
->htable
[y
]);
6008 /* Free already allocated intr */
6009 for (y
= 0; y
< actual
; y
++)
6010 (void) ddi_intr_free(Adapter
->htable
[y
]);
6012 kmem_free(Adapter
->htable
, Adapter
->intr_size
);
6013 return (DDI_FAILURE
);
6017 rc
= ddi_intr_get_cap(Adapter
->htable
[0], &Adapter
->intr_cap
);
6019 if (rc
!= DDI_SUCCESS
) {
6020 E1000G_DEBUGLOG_1(Adapter
, E1000G_WARN_LEVEL
,
6021 "Get interrupt cap failed: %d\n", rc
);
6023 /* Free already allocated intr */
6024 for (y
= 0; y
< actual
; y
++) {
6025 (void) ddi_intr_remove_handler(Adapter
->htable
[y
]);
6026 (void) ddi_intr_free(Adapter
->htable
[y
]);
6029 kmem_free(Adapter
->htable
, Adapter
->intr_size
);
6030 return (DDI_FAILURE
);
6033 return (DDI_SUCCESS
);
6037 e1000g_rem_intrs(struct e1000g
*Adapter
)
6042 for (x
= 0; x
< Adapter
->intr_cnt
; x
++) {
6043 rc
= ddi_intr_remove_handler(Adapter
->htable
[x
]);
6044 if (rc
!= DDI_SUCCESS
) {
6045 E1000G_DEBUGLOG_1(Adapter
, E1000G_WARN_LEVEL
,
6046 "Remove intr handler failed: %d\n", rc
);
6047 return (DDI_FAILURE
);
6050 rc
= ddi_intr_free(Adapter
->htable
[x
]);
6051 if (rc
!= DDI_SUCCESS
) {
6052 E1000G_DEBUGLOG_1(Adapter
, E1000G_WARN_LEVEL
,
6053 "Free intr failed: %d\n", rc
);
6054 return (DDI_FAILURE
);
6058 kmem_free(Adapter
->htable
, Adapter
->intr_size
);
6060 return (DDI_SUCCESS
);
6064 e1000g_enable_intrs(struct e1000g
*Adapter
)
6069 /* Enable interrupts */
6070 if (Adapter
->intr_cap
& DDI_INTR_FLAG_BLOCK
) {
6071 /* Call ddi_intr_block_enable() for MSI */
6072 rc
= ddi_intr_block_enable(Adapter
->htable
,
6074 if (rc
!= DDI_SUCCESS
) {
6075 E1000G_DEBUGLOG_1(Adapter
, E1000G_WARN_LEVEL
,
6076 "Enable block intr failed: %d\n", rc
);
6077 return (DDI_FAILURE
);
6080 /* Call ddi_intr_enable() for Legacy/MSI non block enable */
6081 for (x
= 0; x
< Adapter
->intr_cnt
; x
++) {
6082 rc
= ddi_intr_enable(Adapter
->htable
[x
]);
6083 if (rc
!= DDI_SUCCESS
) {
6084 E1000G_DEBUGLOG_1(Adapter
, E1000G_WARN_LEVEL
,
6085 "Enable intr failed: %d\n", rc
);
6086 return (DDI_FAILURE
);
6091 return (DDI_SUCCESS
);
6095 e1000g_disable_intrs(struct e1000g
*Adapter
)
6100 /* Disable all interrupts */
6101 if (Adapter
->intr_cap
& DDI_INTR_FLAG_BLOCK
) {
6102 rc
= ddi_intr_block_disable(Adapter
->htable
,
6104 if (rc
!= DDI_SUCCESS
) {
6105 E1000G_DEBUGLOG_1(Adapter
, E1000G_WARN_LEVEL
,
6106 "Disable block intr failed: %d\n", rc
);
6107 return (DDI_FAILURE
);
6110 for (x
= 0; x
< Adapter
->intr_cnt
; x
++) {
6111 rc
= ddi_intr_disable(Adapter
->htable
[x
]);
6112 if (rc
!= DDI_SUCCESS
) {
6113 E1000G_DEBUGLOG_1(Adapter
, E1000G_WARN_LEVEL
,
6114 "Disable intr failed: %d\n", rc
);
6115 return (DDI_FAILURE
);
6120 return (DDI_SUCCESS
);
6124 * e1000g_get_phy_state - get the state of PHY registers, save in the adapter
6127 e1000g_get_phy_state(struct e1000g
*Adapter
)
6129 struct e1000_hw
*hw
= &Adapter
->shared
;
6131 if (hw
->phy
.media_type
== e1000_media_type_copper
) {
6132 (void) e1000_read_phy_reg(hw
, PHY_CONTROL
, &Adapter
->phy_ctrl
);
6133 (void) e1000_read_phy_reg(hw
, PHY_STATUS
, &Adapter
->phy_status
);
6134 (void) e1000_read_phy_reg(hw
, PHY_AUTONEG_ADV
,
6135 &Adapter
->phy_an_adv
);
6136 (void) e1000_read_phy_reg(hw
, PHY_AUTONEG_EXP
,
6137 &Adapter
->phy_an_exp
);
6138 (void) e1000_read_phy_reg(hw
, PHY_EXT_STATUS
,
6139 &Adapter
->phy_ext_status
);
6140 (void) e1000_read_phy_reg(hw
, PHY_1000T_CTRL
,
6141 &Adapter
->phy_1000t_ctrl
);
6142 (void) e1000_read_phy_reg(hw
, PHY_1000T_STATUS
,
6143 &Adapter
->phy_1000t_status
);
6144 (void) e1000_read_phy_reg(hw
, PHY_LP_ABILITY
,
6145 &Adapter
->phy_lp_able
);
6147 Adapter
->param_autoneg_cap
=
6148 (Adapter
->phy_status
& MII_SR_AUTONEG_CAPS
) ? 1 : 0;
6149 Adapter
->param_pause_cap
=
6150 (Adapter
->phy_an_adv
& NWAY_AR_PAUSE
) ? 1 : 0;
6151 Adapter
->param_asym_pause_cap
=
6152 (Adapter
->phy_an_adv
& NWAY_AR_ASM_DIR
) ? 1 : 0;
6153 Adapter
->param_1000fdx_cap
=
6154 ((Adapter
->phy_ext_status
& IEEE_ESR_1000T_FD_CAPS
) ||
6155 (Adapter
->phy_ext_status
& IEEE_ESR_1000X_FD_CAPS
)) ? 1 : 0;
6156 Adapter
->param_1000hdx_cap
=
6157 ((Adapter
->phy_ext_status
& IEEE_ESR_1000T_HD_CAPS
) ||
6158 (Adapter
->phy_ext_status
& IEEE_ESR_1000X_HD_CAPS
)) ? 1 : 0;
6159 Adapter
->param_100t4_cap
=
6160 (Adapter
->phy_status
& MII_SR_100T4_CAPS
) ? 1 : 0;
6161 Adapter
->param_100fdx_cap
=
6162 ((Adapter
->phy_status
& MII_SR_100X_FD_CAPS
) ||
6163 (Adapter
->phy_status
& MII_SR_100T2_FD_CAPS
)) ? 1 : 0;
6164 Adapter
->param_100hdx_cap
=
6165 ((Adapter
->phy_status
& MII_SR_100X_HD_CAPS
) ||
6166 (Adapter
->phy_status
& MII_SR_100T2_HD_CAPS
)) ? 1 : 0;
6167 Adapter
->param_10fdx_cap
=
6168 (Adapter
->phy_status
& MII_SR_10T_FD_CAPS
) ? 1 : 0;
6169 Adapter
->param_10hdx_cap
=
6170 (Adapter
->phy_status
& MII_SR_10T_HD_CAPS
) ? 1 : 0;
6172 Adapter
->param_adv_autoneg
= hw
->mac
.autoneg
;
6173 Adapter
->param_adv_pause
=
6174 (Adapter
->phy_an_adv
& NWAY_AR_PAUSE
) ? 1 : 0;
6175 Adapter
->param_adv_asym_pause
=
6176 (Adapter
->phy_an_adv
& NWAY_AR_ASM_DIR
) ? 1 : 0;
6177 Adapter
->param_adv_1000hdx
=
6178 (Adapter
->phy_1000t_ctrl
& CR_1000T_HD_CAPS
) ? 1 : 0;
6179 Adapter
->param_adv_100t4
=
6180 (Adapter
->phy_an_adv
& NWAY_AR_100T4_CAPS
) ? 1 : 0;
6181 if (Adapter
->param_adv_autoneg
== 1) {
6182 Adapter
->param_adv_1000fdx
=
6183 (Adapter
->phy_1000t_ctrl
& CR_1000T_FD_CAPS
)
6185 Adapter
->param_adv_100fdx
=
6186 (Adapter
->phy_an_adv
& NWAY_AR_100TX_FD_CAPS
)
6188 Adapter
->param_adv_100hdx
=
6189 (Adapter
->phy_an_adv
& NWAY_AR_100TX_HD_CAPS
)
6191 Adapter
->param_adv_10fdx
=
6192 (Adapter
->phy_an_adv
& NWAY_AR_10T_FD_CAPS
) ? 1 : 0;
6193 Adapter
->param_adv_10hdx
=
6194 (Adapter
->phy_an_adv
& NWAY_AR_10T_HD_CAPS
) ? 1 : 0;
6197 Adapter
->param_lp_autoneg
=
6198 (Adapter
->phy_an_exp
& NWAY_ER_LP_NWAY_CAPS
) ? 1 : 0;
6199 Adapter
->param_lp_pause
=
6200 (Adapter
->phy_lp_able
& NWAY_LPAR_PAUSE
) ? 1 : 0;
6201 Adapter
->param_lp_asym_pause
=
6202 (Adapter
->phy_lp_able
& NWAY_LPAR_ASM_DIR
) ? 1 : 0;
6203 Adapter
->param_lp_1000fdx
=
6204 (Adapter
->phy_1000t_status
& SR_1000T_LP_FD_CAPS
) ? 1 : 0;
6205 Adapter
->param_lp_1000hdx
=
6206 (Adapter
->phy_1000t_status
& SR_1000T_LP_HD_CAPS
) ? 1 : 0;
6207 Adapter
->param_lp_100t4
=
6208 (Adapter
->phy_lp_able
& NWAY_LPAR_100T4_CAPS
) ? 1 : 0;
6209 Adapter
->param_lp_100fdx
=
6210 (Adapter
->phy_lp_able
& NWAY_LPAR_100TX_FD_CAPS
) ? 1 : 0;
6211 Adapter
->param_lp_100hdx
=
6212 (Adapter
->phy_lp_able
& NWAY_LPAR_100TX_HD_CAPS
) ? 1 : 0;
6213 Adapter
->param_lp_10fdx
=
6214 (Adapter
->phy_lp_able
& NWAY_LPAR_10T_FD_CAPS
) ? 1 : 0;
6215 Adapter
->param_lp_10hdx
=
6216 (Adapter
->phy_lp_able
& NWAY_LPAR_10T_HD_CAPS
) ? 1 : 0;
6219 * 1Gig Fiber adapter only offers 1Gig Full Duplex. Meaning,
6220 * it can only work with 1Gig Full Duplex Link Partner.
6222 Adapter
->param_autoneg_cap
= 0;
6223 Adapter
->param_pause_cap
= 1;
6224 Adapter
->param_asym_pause_cap
= 1;
6225 Adapter
->param_1000fdx_cap
= 1;
6226 Adapter
->param_1000hdx_cap
= 0;
6227 Adapter
->param_100t4_cap
= 0;
6228 Adapter
->param_100fdx_cap
= 0;
6229 Adapter
->param_100hdx_cap
= 0;
6230 Adapter
->param_10fdx_cap
= 0;
6231 Adapter
->param_10hdx_cap
= 0;
6233 Adapter
->param_adv_autoneg
= 0;
6234 Adapter
->param_adv_pause
= 1;
6235 Adapter
->param_adv_asym_pause
= 1;
6236 Adapter
->param_adv_1000fdx
= 1;
6237 Adapter
->param_adv_1000hdx
= 0;
6238 Adapter
->param_adv_100t4
= 0;
6239 Adapter
->param_adv_100fdx
= 0;
6240 Adapter
->param_adv_100hdx
= 0;
6241 Adapter
->param_adv_10fdx
= 0;
6242 Adapter
->param_adv_10hdx
= 0;
6244 Adapter
->param_lp_autoneg
= 0;
6245 Adapter
->param_lp_pause
= 0;
6246 Adapter
->param_lp_asym_pause
= 0;
6247 Adapter
->param_lp_1000fdx
= 0;
6248 Adapter
->param_lp_1000hdx
= 0;
6249 Adapter
->param_lp_100t4
= 0;
6250 Adapter
->param_lp_100fdx
= 0;
6251 Adapter
->param_lp_100hdx
= 0;
6252 Adapter
->param_lp_10fdx
= 0;
6253 Adapter
->param_lp_10hdx
= 0;
6262 e1000g_check_acc_handle(ddi_acc_handle_t handle
)
6266 ddi_fm_acc_err_get(handle
, &de
, DDI_FME_VERSION
);
6267 ddi_fm_acc_err_clear(handle
, DDI_FME_VERSION
);
6268 return (de
.fme_status
);
6272 e1000g_check_dma_handle(ddi_dma_handle_t handle
)
6276 ddi_fm_dma_err_get(handle
, &de
, DDI_FME_VERSION
);
6277 return (de
.fme_status
);
6281 * The IO fault service error handling callback function
6285 e1000g_fm_error_cb(dev_info_t
*dip
, ddi_fm_error_t
*err
, const void *impl_data
)
6288 * as the driver can always deal with an error in any dma or
6289 * access handle, we can just return the fme_status value.
6291 pci_ereport_post(dip
, err
, NULL
);
6292 return (err
->fme_status
);
6296 e1000g_fm_init(struct e1000g
*Adapter
)
6298 ddi_iblock_cookie_t iblk
;
6301 /* Only register with IO Fault Services if we have some capability */
6302 if (Adapter
->fm_capabilities
& DDI_FM_ACCCHK_CAPABLE
) {
6303 e1000g_regs_acc_attr
.devacc_attr_access
= DDI_FLAGERR_ACC
;
6305 e1000g_regs_acc_attr
.devacc_attr_access
= DDI_DEFAULT_ACC
;
6308 if (Adapter
->fm_capabilities
& DDI_FM_DMACHK_CAPABLE
) {
6314 (void) e1000g_set_fma_flags(fma_dma_flag
);
6316 if (Adapter
->fm_capabilities
) {
6318 /* Register capabilities with IO Fault Services */
6319 ddi_fm_init(Adapter
->dip
, &Adapter
->fm_capabilities
, &iblk
);
6322 * Initialize pci ereport capabilities if ereport capable
6324 if (DDI_FM_EREPORT_CAP(Adapter
->fm_capabilities
) ||
6325 DDI_FM_ERRCB_CAP(Adapter
->fm_capabilities
))
6326 pci_ereport_setup(Adapter
->dip
);
6329 * Register error callback if error callback capable
6331 if (DDI_FM_ERRCB_CAP(Adapter
->fm_capabilities
))
6332 ddi_fm_handler_register(Adapter
->dip
,
6333 e1000g_fm_error_cb
, (void*) Adapter
);
6338 e1000g_fm_fini(struct e1000g
*Adapter
)
6340 /* Only unregister FMA capabilities if we registered some */
6341 if (Adapter
->fm_capabilities
) {
6344 * Release any resources allocated by pci_ereport_setup()
6346 if (DDI_FM_EREPORT_CAP(Adapter
->fm_capabilities
) ||
6347 DDI_FM_ERRCB_CAP(Adapter
->fm_capabilities
))
6348 pci_ereport_teardown(Adapter
->dip
);
6351 * Un-register error callback if error callback capable
6353 if (DDI_FM_ERRCB_CAP(Adapter
->fm_capabilities
))
6354 ddi_fm_handler_unregister(Adapter
->dip
);
6356 /* Unregister from IO Fault Services */
6357 mutex_enter(&e1000g_rx_detach_lock
);
6358 ddi_fm_fini(Adapter
->dip
);
6359 if (Adapter
->priv_dip
!= NULL
) {
6360 DEVI(Adapter
->priv_dip
)->devi_fmhdl
= NULL
;
6362 mutex_exit(&e1000g_rx_detach_lock
);
6367 e1000g_fm_ereport(struct e1000g
*Adapter
, char *detail
)
6370 char buf
[FM_MAX_CLASS
];
6372 (void) snprintf(buf
, FM_MAX_CLASS
, "%s.%s", DDI_FM_DEVICE
, detail
);
6373 ena
= fm_ena_generate(0, FM_ENA_FMT1
);
6374 if (DDI_FM_EREPORT_CAP(Adapter
->fm_capabilities
)) {
6375 ddi_fm_ereport_post(Adapter
->dip
, buf
, ena
, DDI_NOSLEEP
,
6376 FM_VERSION
, DATA_TYPE_UINT8
, FM_EREPORT_VERS0
, NULL
);
6381 * quiesce(9E) entry point.
6383 * This function is called when the system is single-threaded at high
6384 * PIL with preemption disabled. Therefore, this function must not be
6387 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
6388 * DDI_FAILURE indicates an error condition and should almost never happen.
6391 e1000g_quiesce(dev_info_t
*devinfo
)
6393 struct e1000g
*Adapter
;
6395 Adapter
= (struct e1000g
*)ddi_get_driver_private(devinfo
);
6397 if (Adapter
== NULL
)
6398 return (DDI_FAILURE
);
6400 e1000g_clear_all_interrupts(Adapter
);
6402 (void) e1000_reset_hw(&Adapter
->shared
);
6404 /* Setup our HW Tx Head & Tail descriptor pointers */
6405 E1000_WRITE_REG(&Adapter
->shared
, E1000_TDH(0), 0);
6406 E1000_WRITE_REG(&Adapter
->shared
, E1000_TDT(0), 0);
6408 /* Setup our HW Rx Head & Tail descriptor pointers */
6409 E1000_WRITE_REG(&Adapter
->shared
, E1000_RDH(0), 0);
6410 E1000_WRITE_REG(&Adapter
->shared
, E1000_RDT(0), 0);
6412 return (DDI_SUCCESS
);
6416 * synchronize the adv* and en* parameters.
6418 * See comments in <sys/dld.h> for details of the *_en_*
6419 * parameters. The usage of ndd for setting adv parameters will
6420 * synchronize all the en parameters with the e1000g parameters,
6421 * implicitly disabling any settings made via dladm.
6424 e1000g_param_sync(struct e1000g
*Adapter
)
6426 Adapter
->param_en_1000fdx
= Adapter
->param_adv_1000fdx
;
6427 Adapter
->param_en_1000hdx
= Adapter
->param_adv_1000hdx
;
6428 Adapter
->param_en_100fdx
= Adapter
->param_adv_100fdx
;
6429 Adapter
->param_en_100hdx
= Adapter
->param_adv_100hdx
;
6430 Adapter
->param_en_10fdx
= Adapter
->param_adv_10fdx
;
6431 Adapter
->param_en_10hdx
= Adapter
->param_adv_10hdx
;
6435 * e1000g_get_driver_control - tell manageability firmware that the driver
6439 e1000g_get_driver_control(struct e1000_hw
*hw
)
6444 /* tell manageability firmware the driver has taken over */
6445 switch (hw
->mac
.type
) {
6447 swsm
= E1000_READ_REG(hw
, E1000_SWSM
);
6448 E1000_WRITE_REG(hw
, E1000_SWSM
, swsm
| E1000_SWSM_DRV_LOAD
);
6453 case e1000_80003es2lan
:
6456 case e1000_ich10lan
:
6459 ctrl_ext
= E1000_READ_REG(hw
, E1000_CTRL_EXT
);
6460 E1000_WRITE_REG(hw
, E1000_CTRL_EXT
,
6461 ctrl_ext
| E1000_CTRL_EXT_DRV_LOAD
);
6464 /* no manageability firmware: do nothing */
6470 * e1000g_release_driver_control - tell manageability firmware that the driver
6471 * has released control.
6474 e1000g_release_driver_control(struct e1000_hw
*hw
)
6479 /* tell manageability firmware the driver has released control */
6480 switch (hw
->mac
.type
) {
6482 swsm
= E1000_READ_REG(hw
, E1000_SWSM
);
6483 E1000_WRITE_REG(hw
, E1000_SWSM
, swsm
& ~E1000_SWSM_DRV_LOAD
);
6488 case e1000_80003es2lan
:
6491 case e1000_ich10lan
:
6494 ctrl_ext
= E1000_READ_REG(hw
, E1000_CTRL_EXT
);
6495 E1000_WRITE_REG(hw
, E1000_CTRL_EXT
,
6496 ctrl_ext
& ~E1000_CTRL_EXT_DRV_LOAD
);
6499 /* no manageability firmware: do nothing */
6505 * Restore e1000g promiscuous mode.
6508 e1000g_restore_promisc(struct e1000g
*Adapter
)
6510 if (Adapter
->e1000g_promisc
) {
6513 rctl
= E1000_READ_REG(&Adapter
->shared
, E1000_RCTL
);
6514 rctl
|= (E1000_RCTL_UPE
| E1000_RCTL_MPE
| E1000_RCTL_BAM
);
6515 E1000_WRITE_REG(&Adapter
->shared
, E1000_RCTL
, rctl
);