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