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) 2007-2010 Intel Corporation. All rights reserved.
  24  */
  25 
  26 /*
  27  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Copyright 2012 Nexenta Systems, Inc. All rights reserved.
  29  */
  30 
  31 #include "ixgbe_sw.h"
  32 
  33 /*
  34  * Bring the device out of the reset/quiesced state that it
  35  * was in when the interface was registered.
  36  */
  37 int
  38 ixgbe_m_start(void *arg)
  39 {
  40         ixgbe_t *ixgbe = (ixgbe_t *)arg;
  41 
  42         mutex_enter(&ixgbe->gen_lock);
  43 
  44         if (ixgbe->ixgbe_state & IXGBE_SUSPENDED) {
  45                 mutex_exit(&ixgbe->gen_lock);
  46                 return (ECANCELED);
  47         }
  48 
  49         if (ixgbe_start(ixgbe, B_TRUE) != IXGBE_SUCCESS) {
  50                 mutex_exit(&ixgbe->gen_lock);
  51                 return (EIO);
  52         }
  53 
  54         atomic_or_32(&ixgbe->ixgbe_state, IXGBE_STARTED);
  55 
  56         mutex_exit(&ixgbe->gen_lock);
  57 
  58         /*
  59          * Enable and start the watchdog timer
  60          */
  61         ixgbe_enable_watchdog_timer(ixgbe);
  62 
  63         return (0);
  64 }
  65 
  66 /*
  67  * Stop the device and put it in a reset/quiesced state such
  68  * that the interface can be unregistered.
  69  */
  70 void
  71 ixgbe_m_stop(void *arg)
  72 {
  73         ixgbe_t *ixgbe = (ixgbe_t *)arg;
  74 
  75         mutex_enter(&ixgbe->gen_lock);
  76 
  77         if (ixgbe->ixgbe_state & IXGBE_SUSPENDED) {
  78                 mutex_exit(&ixgbe->gen_lock);
  79                 return;
  80         }
  81 
  82         atomic_and_32(&ixgbe->ixgbe_state, ~IXGBE_STARTED);
  83 
  84         ixgbe_stop(ixgbe, B_TRUE);
  85 
  86         mutex_exit(&ixgbe->gen_lock);
  87 
  88         /*
  89          * Disable and stop the watchdog timer
  90          */
  91         ixgbe_disable_watchdog_timer(ixgbe);
  92 }
  93 
  94 /*
  95  * Set the promiscuity of the device.
  96  */
  97 int
  98 ixgbe_m_promisc(void *arg, boolean_t on)
  99 {
 100         ixgbe_t *ixgbe = (ixgbe_t *)arg;
 101         uint32_t reg_val;
 102         struct ixgbe_hw *hw = &ixgbe->hw;
 103 
 104         mutex_enter(&ixgbe->gen_lock);
 105 
 106         if (ixgbe->ixgbe_state & IXGBE_SUSPENDED) {
 107                 mutex_exit(&ixgbe->gen_lock);
 108                 return (ECANCELED);
 109         }
 110         reg_val = IXGBE_READ_REG(hw, IXGBE_FCTRL);
 111 
 112         if (on)
 113                 reg_val |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE);
 114         else
 115                 reg_val &= (~(IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE));
 116 
 117         IXGBE_WRITE_REG(&ixgbe->hw, IXGBE_FCTRL, reg_val);
 118 
 119         mutex_exit(&ixgbe->gen_lock);
 120 
 121         return (0);
 122 }
 123 
 124 /*
 125  * Add/remove the addresses to/from the set of multicast
 126  * addresses for which the device will receive packets.
 127  */
 128 int
 129 ixgbe_m_multicst(void *arg, boolean_t add, const uint8_t *mcst_addr)
 130 {
 131         ixgbe_t *ixgbe = (ixgbe_t *)arg;
 132         int result;
 133 
 134         mutex_enter(&ixgbe->gen_lock);
 135 
 136         if (ixgbe->ixgbe_state & IXGBE_SUSPENDED) {
 137                 mutex_exit(&ixgbe->gen_lock);
 138                 return (ECANCELED);
 139         }
 140 
 141         result = (add) ? ixgbe_multicst_add(ixgbe, mcst_addr)
 142             : ixgbe_multicst_remove(ixgbe, mcst_addr);
 143 
 144         mutex_exit(&ixgbe->gen_lock);
 145 
 146         return (result);
 147 }
 148 
 149 /*
 150  * Pass on M_IOCTL messages passed to the DLD, and support
 151  * private IOCTLs for debugging and ndd.
 152  */
 153 void
 154 ixgbe_m_ioctl(void *arg, queue_t *q, mblk_t *mp)
 155 {
 156         ixgbe_t *ixgbe = (ixgbe_t *)arg;
 157         struct iocblk *iocp;
 158         enum ioc_reply status;
 159 
 160         iocp = (struct iocblk *)(uintptr_t)mp->b_rptr;
 161         iocp->ioc_error = 0;
 162 
 163         mutex_enter(&ixgbe->gen_lock);
 164         if (ixgbe->ixgbe_state & IXGBE_SUSPENDED) {
 165                 mutex_exit(&ixgbe->gen_lock);
 166                 miocnak(q, mp, 0, EINVAL);
 167                 return;
 168         }
 169         mutex_exit(&ixgbe->gen_lock);
 170 
 171         switch (iocp->ioc_cmd) {
 172         case LB_GET_INFO_SIZE:
 173         case LB_GET_INFO:
 174         case LB_GET_MODE:
 175         case LB_SET_MODE:
 176                 status = ixgbe_loopback_ioctl(ixgbe, iocp, mp);
 177                 break;
 178 
 179         default:
 180                 status = IOC_INVAL;
 181                 break;
 182         }
 183 
 184         /*
 185          * Decide how to reply
 186          */
 187         switch (status) {
 188         default:
 189         case IOC_INVAL:
 190                 /*
 191                  * Error, reply with a NAK and EINVAL or the specified error
 192                  */
 193                 miocnak(q, mp, 0, iocp->ioc_error == 0 ?
 194                     EINVAL : iocp->ioc_error);
 195                 break;
 196 
 197         case IOC_DONE:
 198                 /*
 199                  * OK, reply already sent
 200                  */
 201                 break;
 202 
 203         case IOC_ACK:
 204                 /*
 205                  * OK, reply with an ACK
 206                  */
 207                 miocack(q, mp, 0, 0);
 208                 break;
 209 
 210         case IOC_REPLY:
 211                 /*
 212                  * OK, send prepared reply as ACK or NAK
 213                  */
 214                 mp->b_datap->db_type = iocp->ioc_error == 0 ?
 215                     M_IOCACK : M_IOCNAK;
 216                 qreply(q, mp);
 217                 break;
 218         }
 219 }
 220 
 221 /*
 222  * Obtain the MAC's capabilities and associated data from
 223  * the driver.
 224  */
 225 boolean_t
 226 ixgbe_m_getcapab(void *arg, mac_capab_t cap, void *cap_data)
 227 {
 228         ixgbe_t *ixgbe = (ixgbe_t *)arg;
 229 
 230         switch (cap) {
 231         case MAC_CAPAB_HCKSUM: {
 232                 uint32_t *tx_hcksum_flags = cap_data;
 233 
 234                 /*
 235                  * We advertise our capabilities only if tx hcksum offload is
 236                  * enabled.  On receive, the stack will accept checksummed
 237                  * packets anyway, even if we haven't said we can deliver
 238                  * them.
 239                  */
 240                 if (!ixgbe->tx_hcksum_enable)
 241                         return (B_FALSE);
 242 
 243                 *tx_hcksum_flags = HCKSUM_INET_PARTIAL | HCKSUM_IPHDRCKSUM;
 244                 break;
 245         }
 246         case MAC_CAPAB_LSO: {
 247                 mac_capab_lso_t *cap_lso = cap_data;
 248 
 249                 if (ixgbe->lso_enable) {
 250                         cap_lso->lso_flags = LSO_TX_BASIC_TCP_IPV4;
 251                         cap_lso->lso_basic_tcp_ipv4.lso_max = IXGBE_LSO_MAXLEN;
 252                         break;
 253                 } else {
 254                         return (B_FALSE);
 255                 }
 256         }
 257         case MAC_CAPAB_RINGS: {
 258                 mac_capab_rings_t *cap_rings = cap_data;
 259 
 260                 switch (cap_rings->mr_type) {
 261                 case MAC_RING_TYPE_RX:
 262                         cap_rings->mr_group_type = MAC_GROUP_TYPE_STATIC;
 263                         cap_rings->mr_rnum = ixgbe->num_rx_rings;
 264                         cap_rings->mr_gnum = ixgbe->num_rx_groups;
 265                         cap_rings->mr_rget = ixgbe_fill_ring;
 266                         cap_rings->mr_gget = ixgbe_fill_group;
 267                         cap_rings->mr_gaddring = NULL;
 268                         cap_rings->mr_gremring = NULL;
 269                         break;
 270                 case MAC_RING_TYPE_TX:
 271                         cap_rings->mr_group_type = MAC_GROUP_TYPE_STATIC;
 272                         cap_rings->mr_rnum = ixgbe->num_tx_rings;
 273                         cap_rings->mr_gnum = 0;
 274                         cap_rings->mr_rget = ixgbe_fill_ring;
 275                         cap_rings->mr_gget = NULL;
 276                         break;
 277                 default:
 278                         break;
 279                 }
 280                 break;
 281         }
 282         default:
 283                 return (B_FALSE);
 284         }
 285         return (B_TRUE);
 286 }
 287 
 288 int
 289 ixgbe_m_setprop(void *arg, const char *pr_name, mac_prop_id_t pr_num,
 290     uint_t pr_valsize, const void *pr_val)
 291 {
 292         ixgbe_t *ixgbe = (ixgbe_t *)arg;
 293         struct ixgbe_hw *hw = &ixgbe->hw;
 294         int err = 0;
 295         uint32_t flow_control;
 296         uint32_t cur_mtu, new_mtu;
 297         uint32_t rx_size;
 298         uint32_t tx_size;
 299 
 300         mutex_enter(&ixgbe->gen_lock);
 301         if (ixgbe->ixgbe_state & IXGBE_SUSPENDED) {
 302                 mutex_exit(&ixgbe->gen_lock);
 303                 return (ECANCELED);
 304         }
 305 
 306         if (ixgbe->loopback_mode != IXGBE_LB_NONE &&
 307             ixgbe_param_locked(pr_num)) {
 308                 /*
 309                  * All en_* parameters are locked (read-only)
 310                  * while the device is in any sort of loopback mode.
 311                  */
 312                 mutex_exit(&ixgbe->gen_lock);
 313                 return (EBUSY);
 314         }
 315 
 316         switch (pr_num) {
 317         case MAC_PROP_EN_10GFDX_CAP:
 318                 /* read/write on copper, read-only on serdes */
 319                 if (ixgbe->hw.phy.media_type != ixgbe_media_type_copper) {
 320                         err = ENOTSUP;
 321                         break;
 322                 } else {
 323                         ixgbe->param_en_10000fdx_cap = *(uint8_t *)pr_val;
 324                         ixgbe->param_adv_10000fdx_cap = *(uint8_t *)pr_val;
 325                         goto setup_link;
 326                 }
 327         case MAC_PROP_EN_1000FDX_CAP:
 328                 /* read/write on copper, read-only on serdes */
 329                 if (ixgbe->hw.phy.media_type != ixgbe_media_type_copper) {
 330                         err = ENOTSUP;
 331                         break;
 332                 } else {
 333                         ixgbe->param_en_1000fdx_cap = *(uint8_t *)pr_val;
 334                         ixgbe->param_adv_1000fdx_cap = *(uint8_t *)pr_val;
 335                         goto setup_link;
 336                 }
 337         case MAC_PROP_EN_100FDX_CAP:
 338                 /* read/write on copper, read-only on serdes */
 339                 if (ixgbe->hw.phy.media_type != ixgbe_media_type_copper) {
 340                         err = ENOTSUP;
 341                         break;
 342                 } else {
 343                         ixgbe->param_en_100fdx_cap = *(uint8_t *)pr_val;
 344                         ixgbe->param_adv_100fdx_cap = *(uint8_t *)pr_val;
 345                         goto setup_link;
 346                 }
 347         case MAC_PROP_AUTONEG:
 348                 /* read/write on copper, read-only on serdes */
 349                 if (ixgbe->hw.phy.media_type != ixgbe_media_type_copper) {
 350                         err = ENOTSUP;
 351                         break;
 352                 } else {
 353                         ixgbe->param_adv_autoneg_cap = *(uint8_t *)pr_val;
 354                         goto setup_link;
 355                 }
 356         case MAC_PROP_FLOWCTRL:
 357                 bcopy(pr_val, &flow_control, sizeof (flow_control));
 358 
 359                 switch (flow_control) {
 360                 default:
 361                         err = EINVAL;
 362                         break;
 363                 case LINK_FLOWCTRL_NONE:
 364                         hw->fc.requested_mode = ixgbe_fc_none;
 365                         break;
 366                 case LINK_FLOWCTRL_RX:
 367                         hw->fc.requested_mode = ixgbe_fc_rx_pause;
 368                         break;
 369                 case LINK_FLOWCTRL_TX:
 370                         hw->fc.requested_mode = ixgbe_fc_tx_pause;
 371                         break;
 372                 case LINK_FLOWCTRL_BI:
 373                         hw->fc.requested_mode = ixgbe_fc_full;
 374                         break;
 375                 }
 376 setup_link:
 377                 if (err == 0) {
 378                         if (ixgbe_driver_setup_link(ixgbe, B_TRUE) !=
 379                             IXGBE_SUCCESS)
 380                                 err = EINVAL;
 381                 }
 382                 break;
 383         case MAC_PROP_ADV_10GFDX_CAP:
 384         case MAC_PROP_ADV_1000FDX_CAP:
 385         case MAC_PROP_ADV_100FDX_CAP:
 386         case MAC_PROP_STATUS:
 387         case MAC_PROP_SPEED:
 388         case MAC_PROP_DUPLEX:
 389                 err = ENOTSUP; /* read-only prop. Can't set this. */
 390                 break;
 391         case MAC_PROP_MTU:
 392                 cur_mtu = ixgbe->default_mtu;
 393                 bcopy(pr_val, &new_mtu, sizeof (new_mtu));
 394                 if (new_mtu == cur_mtu) {
 395                         err = 0;
 396                         break;
 397                 }
 398 
 399                 if (new_mtu < DEFAULT_MTU || new_mtu > ixgbe->capab->max_mtu) {
 400                         err = EINVAL;
 401                         break;
 402                 }
 403 
 404                 if (ixgbe->ixgbe_state & IXGBE_STARTED) {
 405                         err = EBUSY;
 406                         break;
 407                 }
 408 
 409                 err = mac_maxsdu_update(ixgbe->mac_hdl, new_mtu);
 410                 if (err == 0) {
 411                         ixgbe->default_mtu = new_mtu;
 412                         ixgbe->max_frame_size = ixgbe->default_mtu +
 413                             sizeof (struct ether_vlan_header) + ETHERFCSL;
 414 
 415                         /*
 416                          * Set rx buffer size
 417                          */
 418                         rx_size = ixgbe->max_frame_size + IPHDR_ALIGN_ROOM;
 419                         ixgbe->rx_buf_size = ((rx_size >> 10) + ((rx_size &
 420                             (((uint32_t)1 << 10) - 1)) > 0 ? 1 : 0)) << 10;
 421 
 422                         /*
 423                          * Set tx buffer size
 424                          */
 425                         tx_size = ixgbe->max_frame_size;
 426                         ixgbe->tx_buf_size = ((tx_size >> 10) + ((tx_size &
 427                             (((uint32_t)1 << 10) - 1)) > 0 ? 1 : 0)) << 10;
 428                 }
 429                 break;
 430         case MAC_PROP_PRIVATE:
 431                 err = ixgbe_set_priv_prop(ixgbe, pr_name, pr_valsize, pr_val);
 432                 break;
 433         default:
 434                 err = EINVAL;
 435                 break;
 436         }
 437         mutex_exit(&ixgbe->gen_lock);
 438         return (err);
 439 }
 440 
 441 int
 442 ixgbe_m_getprop(void *arg, const char *pr_name, mac_prop_id_t pr_num,
 443     uint_t pr_valsize, void *pr_val)
 444 {
 445         ixgbe_t *ixgbe = (ixgbe_t *)arg;
 446         struct ixgbe_hw *hw = &ixgbe->hw;
 447         int err = 0;
 448         uint32_t flow_control;
 449         uint64_t tmp = 0;
 450 
 451         switch (pr_num) {
 452         case MAC_PROP_DUPLEX:
 453                 ASSERT(pr_valsize >= sizeof (link_duplex_t));
 454                 bcopy(&ixgbe->link_duplex, pr_val,
 455                     sizeof (link_duplex_t));
 456                 break;
 457         case MAC_PROP_SPEED:
 458                 ASSERT(pr_valsize >= sizeof (uint64_t));
 459                 tmp = ixgbe->link_speed * 1000000ull;
 460                 bcopy(&tmp, pr_val, sizeof (tmp));
 461                 break;
 462         case MAC_PROP_AUTONEG:
 463                 *(uint8_t *)pr_val = ixgbe->param_adv_autoneg_cap;
 464                 break;
 465         case MAC_PROP_FLOWCTRL:
 466                 ASSERT(pr_valsize >= sizeof (uint32_t));
 467 
 468                 switch (hw->fc.requested_mode) {
 469                         case ixgbe_fc_none:
 470                                 flow_control = LINK_FLOWCTRL_NONE;
 471                                 break;
 472                         case ixgbe_fc_rx_pause:
 473                                 flow_control = LINK_FLOWCTRL_RX;
 474                                 break;
 475                         case ixgbe_fc_tx_pause:
 476                                 flow_control = LINK_FLOWCTRL_TX;
 477                                 break;
 478                         case ixgbe_fc_full:
 479                                 flow_control = LINK_FLOWCTRL_BI;
 480                                 break;
 481                 }
 482                 bcopy(&flow_control, pr_val, sizeof (flow_control));
 483                 break;
 484         case MAC_PROP_ADV_10GFDX_CAP:
 485                 *(uint8_t *)pr_val = ixgbe->param_adv_10000fdx_cap;
 486                 break;
 487         case MAC_PROP_EN_10GFDX_CAP:
 488                 *(uint8_t *)pr_val = ixgbe->param_en_10000fdx_cap;
 489                 break;
 490         case MAC_PROP_ADV_1000FDX_CAP:
 491                 *(uint8_t *)pr_val = ixgbe->param_adv_1000fdx_cap;
 492                 break;
 493         case MAC_PROP_EN_1000FDX_CAP:
 494                 *(uint8_t *)pr_val = ixgbe->param_en_1000fdx_cap;
 495                 break;
 496         case MAC_PROP_ADV_100FDX_CAP:
 497                 *(uint8_t *)pr_val = ixgbe->param_adv_100fdx_cap;
 498                 break;
 499         case MAC_PROP_EN_100FDX_CAP:
 500                 *(uint8_t *)pr_val = ixgbe->param_en_100fdx_cap;
 501                 break;
 502         case MAC_PROP_PRIVATE:
 503                 err = ixgbe_get_priv_prop(ixgbe, pr_name,
 504                     pr_valsize, pr_val);
 505                 break;
 506         default:
 507                 err = EINVAL;
 508                 break;
 509         }
 510         return (err);
 511 }
 512 
 513 void
 514 ixgbe_m_propinfo(void *arg, const char *pr_name, mac_prop_id_t pr_num,
 515     mac_prop_info_handle_t prh)
 516 {
 517         ixgbe_t *ixgbe = (ixgbe_t *)arg;
 518         uint_t perm;
 519 
 520         switch (pr_num) {
 521         case MAC_PROP_DUPLEX:
 522         case MAC_PROP_SPEED:
 523                 mac_prop_info_set_perm(prh, MAC_PROP_PERM_READ);
 524                 break;
 525 
 526         case MAC_PROP_ADV_100FDX_CAP:
 527         case MAC_PROP_ADV_1000FDX_CAP:
 528         case MAC_PROP_ADV_10GFDX_CAP:
 529                 mac_prop_info_set_perm(prh, MAC_PROP_PERM_READ);
 530                 mac_prop_info_set_default_uint8(prh, 1);
 531                 break;
 532 
 533         case MAC_PROP_AUTONEG:
 534         case MAC_PROP_EN_10GFDX_CAP:
 535         case MAC_PROP_EN_1000FDX_CAP:
 536         case MAC_PROP_EN_100FDX_CAP:
 537                 perm = (ixgbe->hw.phy.media_type == ixgbe_media_type_copper) ?
 538                     MAC_PROP_PERM_RW : MAC_PROP_PERM_READ;
 539                 mac_prop_info_set_perm(prh, perm);
 540                 mac_prop_info_set_default_uint8(prh, 1);
 541                 break;
 542 
 543         case MAC_PROP_FLOWCTRL:
 544                 mac_prop_info_set_default_link_flowctrl(prh,
 545                     LINK_FLOWCTRL_NONE);
 546                 break;
 547 
 548         case MAC_PROP_MTU:
 549                 mac_prop_info_set_range_uint32(prh,
 550                     DEFAULT_MTU, ixgbe->capab->max_mtu);
 551                 break;
 552 
 553         case MAC_PROP_PRIVATE: {
 554                 char valstr[64];
 555                 int value;
 556 
 557                 bzero(valstr, sizeof (valstr));
 558 
 559                 if (strcmp(pr_name, "_adv_pause_cap") == 0 ||
 560                     strcmp(pr_name, "_adv_asym_pause_cap") == 0) {
 561                         mac_prop_info_set_perm(prh, MAC_PROP_PERM_READ);
 562                         return;
 563                 }
 564 
 565                 if (strcmp(pr_name, "_tx_copy_thresh") == 0) {
 566                         value = DEFAULT_TX_COPY_THRESHOLD;
 567                 } else if (strcmp(pr_name, "_tx_recycle_thresh") == 0) {
 568                         value = DEFAULT_TX_RECYCLE_THRESHOLD;
 569                 } else if (strcmp(pr_name, "_tx_overload_thresh") == 0) {
 570                         value = DEFAULT_TX_OVERLOAD_THRESHOLD;
 571                 } else if (strcmp(pr_name, "_tx_resched_thresh") == 0) {
 572                         value = DEFAULT_TX_RESCHED_THRESHOLD;
 573                 } else  if (strcmp(pr_name, "_rx_copy_thresh") == 0) {
 574                         value = DEFAULT_RX_COPY_THRESHOLD;
 575                 } else  if (strcmp(pr_name, "_rx_limit_per_intr") == 0) {
 576                         value = DEFAULT_RX_LIMIT_PER_INTR;
 577                 }       if (strcmp(pr_name, "_intr_throttling") == 0) {
 578                         value = ixgbe->capab->def_intr_throttle;
 579                 } else {
 580                         return;
 581                 }
 582 
 583                 (void) snprintf(valstr, sizeof (valstr), "%x", value);
 584         }
 585         }
 586 }
 587 
 588 boolean_t
 589 ixgbe_param_locked(mac_prop_id_t pr_num)
 590 {
 591         /*
 592          * All en_* parameters are locked (read-only) while
 593          * the device is in any sort of loopback mode ...
 594          */
 595         switch (pr_num) {
 596                 case MAC_PROP_EN_10GFDX_CAP:
 597                 case MAC_PROP_EN_1000FDX_CAP:
 598                 case MAC_PROP_EN_100FDX_CAP:
 599                 case MAC_PROP_AUTONEG:
 600                 case MAC_PROP_FLOWCTRL:
 601                         return (B_TRUE);
 602         }
 603         return (B_FALSE);
 604 }
 605 
 606 /* ARGSUSED */
 607 int
 608 ixgbe_set_priv_prop(ixgbe_t *ixgbe, const char *pr_name,
 609     uint_t pr_valsize, const void *pr_val)
 610 {
 611         int err = 0;
 612         long result;
 613         struct ixgbe_hw *hw = &ixgbe->hw;
 614         int i;
 615 
 616         if (strcmp(pr_name, "_tx_copy_thresh") == 0) {
 617                 if (pr_val == NULL) {
 618                         err = EINVAL;
 619                         return (err);
 620                 }
 621                 (void) ddi_strtol(pr_val, (char **)NULL, 0, &result);
 622                 if (result < MIN_TX_COPY_THRESHOLD ||
 623                     result > MAX_TX_COPY_THRESHOLD)
 624                         err = EINVAL;
 625                 else {
 626                         ixgbe->tx_copy_thresh = (uint32_t)result;
 627                 }
 628                 return (err);
 629         }
 630         if (strcmp(pr_name, "_tx_recycle_thresh") == 0) {
 631                 if (pr_val == NULL) {
 632                         err = EINVAL;
 633                         return (err);
 634                 }
 635                 (void) ddi_strtol(pr_val, (char **)NULL, 0, &result);
 636                 if (result < MIN_TX_RECYCLE_THRESHOLD ||
 637                     result > MAX_TX_RECYCLE_THRESHOLD)
 638                         err = EINVAL;
 639                 else {
 640                         ixgbe->tx_recycle_thresh = (uint32_t)result;
 641                 }
 642                 return (err);
 643         }
 644         if (strcmp(pr_name, "_tx_overload_thresh") == 0) {
 645                 if (pr_val == NULL) {
 646                         err = EINVAL;
 647                         return (err);
 648                 }
 649                 (void) ddi_strtol(pr_val, (char **)NULL, 0, &result);
 650                 if (result < MIN_TX_OVERLOAD_THRESHOLD ||
 651                     result > MAX_TX_OVERLOAD_THRESHOLD)
 652                         err = EINVAL;
 653                 else {
 654                         ixgbe->tx_overload_thresh = (uint32_t)result;
 655                 }
 656                 return (err);
 657         }
 658         if (strcmp(pr_name, "_tx_resched_thresh") == 0) {
 659                 if (pr_val == NULL) {
 660                         err = EINVAL;
 661                         return (err);
 662                 }
 663                 (void) ddi_strtol(pr_val, (char **)NULL, 0, &result);
 664                 if (result < MIN_TX_RESCHED_THRESHOLD ||
 665                     result > MAX_TX_RESCHED_THRESHOLD)
 666                         err = EINVAL;
 667                 else {
 668                         ixgbe->tx_resched_thresh = (uint32_t)result;
 669                 }
 670                 return (err);
 671         }
 672         if (strcmp(pr_name, "_rx_copy_thresh") == 0) {
 673                 if (pr_val == NULL) {
 674                         err = EINVAL;
 675                         return (err);
 676                 }
 677                 (void) ddi_strtol(pr_val, (char **)NULL, 0, &result);
 678                 if (result < MIN_RX_COPY_THRESHOLD ||
 679                     result > MAX_RX_COPY_THRESHOLD)
 680                         err = EINVAL;
 681                 else {
 682                         ixgbe->rx_copy_thresh = (uint32_t)result;
 683                 }
 684                 return (err);
 685         }
 686         if (strcmp(pr_name, "_rx_limit_per_intr") == 0) {
 687                 if (pr_val == NULL) {
 688                         err = EINVAL;
 689                         return (err);
 690                 }
 691                 (void) ddi_strtol(pr_val, (char **)NULL, 0, &result);
 692                 if (result < MIN_RX_LIMIT_PER_INTR ||
 693                     result > MAX_RX_LIMIT_PER_INTR)
 694                         err = EINVAL;
 695                 else {
 696                         ixgbe->rx_limit_per_intr = (uint32_t)result;
 697                 }
 698                 return (err);
 699         }
 700         if (strcmp(pr_name, "_intr_throttling") == 0) {
 701                 if (pr_val == NULL) {
 702                         err = EINVAL;
 703                         return (err);
 704                 }
 705                 (void) ddi_strtol(pr_val, (char **)NULL, 0, &result);
 706 
 707                 if (result < ixgbe->capab->min_intr_throttle ||
 708                     result > ixgbe->capab->max_intr_throttle)
 709                         err = EINVAL;
 710                 else {
 711                         ixgbe->intr_throttling[0] = (uint32_t)result;
 712 
 713                         /*
 714                          * 82599 and X540 require the interrupt throttling
 715                          * rate is a multiple of 8. This is enforced by the
 716                          * register definiton.
 717                          */
 718                         if (hw->mac.type == ixgbe_mac_82599EB ||
 719                             hw->mac.type == ixgbe_mac_X540) {
 720                                 ixgbe->intr_throttling[0] =
 721                                     ixgbe->intr_throttling[0] & 0xFF8;
 722                         }
 723 
 724                         for (i = 0; i < MAX_INTR_VECTOR; i++)
 725                                 ixgbe->intr_throttling[i] =
 726                                     ixgbe->intr_throttling[0];
 727 
 728                         /* Set interrupt throttling rate */
 729                         for (i = 0; i < ixgbe->intr_cnt; i++)
 730                                 IXGBE_WRITE_REG(hw, IXGBE_EITR(i),
 731                                     ixgbe->intr_throttling[i]);
 732                 }
 733                 return (err);
 734         }
 735         return (ENOTSUP);
 736 }
 737 
 738 int
 739 ixgbe_get_priv_prop(ixgbe_t *ixgbe, const char *pr_name,
 740     uint_t pr_valsize, void *pr_val)
 741 {
 742         int err = ENOTSUP;
 743         int value;
 744 
 745         if (strcmp(pr_name, "_adv_pause_cap") == 0) {
 746                 value = ixgbe->param_adv_pause_cap;
 747                 err = 0;
 748                 goto done;
 749         }
 750         if (strcmp(pr_name, "_adv_asym_pause_cap") == 0) {
 751                 value = ixgbe->param_adv_asym_pause_cap;
 752                 err = 0;
 753                 goto done;
 754         }
 755         if (strcmp(pr_name, "_tx_copy_thresh") == 0) {
 756                 value = ixgbe->tx_copy_thresh;
 757                 err = 0;
 758                 goto done;
 759         }
 760         if (strcmp(pr_name, "_tx_recycle_thresh") == 0) {
 761                 value = ixgbe->tx_recycle_thresh;
 762                 err = 0;
 763                 goto done;
 764         }
 765         if (strcmp(pr_name, "_tx_overload_thresh") == 0) {
 766                 value = ixgbe->tx_overload_thresh;
 767                 err = 0;
 768                 goto done;
 769         }
 770         if (strcmp(pr_name, "_tx_resched_thresh") == 0) {
 771                 value = ixgbe->tx_resched_thresh;
 772                 err = 0;
 773                 goto done;
 774         }
 775         if (strcmp(pr_name, "_rx_copy_thresh") == 0) {
 776                 value = ixgbe->rx_copy_thresh;
 777                 err = 0;
 778                 goto done;
 779         }
 780         if (strcmp(pr_name, "_rx_limit_per_intr") == 0) {
 781                 value = ixgbe->rx_limit_per_intr;
 782                 err = 0;
 783                 goto done;
 784         }
 785         if (strcmp(pr_name, "_intr_throttling") == 0) {
 786                 value = ixgbe->intr_throttling[0];
 787                 err = 0;
 788                 goto done;
 789         }
 790 done:
 791         if (err == 0) {
 792                 (void) snprintf(pr_val, pr_valsize, "%d", value);
 793         }
 794         return (err);
 795 }