void iegbe_check_options(struct iegbe_adapter *adapter) { int bd = adapter->bd_number; if(bd >= E1000_MAX_NIC) { DPRINTK(PROBE, NOTICE, "Warning: no configuration for board #%i\n", bd); DPRINTK(PROBE, NOTICE, "Using defaults for all values\n"); #ifndef module_param_array bd = E1000_MAX_NIC; #endif } { /* Transmit Descriptor Count */ struct iegbe_option opt = { .type = range_option, .name = "Transmit Descriptors", .err = "using default of " __MODULE_STRING(E1000_DEFAULT_TXD), .def = E1000_DEFAULT_TXD, .arg = { .r = { .min = E1000_MIN_TXD }} }; struct iegbe_tx_ring *tx_ring = adapter->tx_ring; int i; iegbe_mac_type mac_type = adapter->hw.mac_type; opt.arg.r.max = mac_type < iegbe_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD; #ifdef module_param_array if(num_TxDescriptors > bd) { #endif tx_ring->count = TxDescriptors[bd]; iegbe_validate_option(&tx_ring->count, &opt, adapter); E1000_ROUNDUP(tx_ring->count, REQ_TX_DESCRIPTOR_MULTIPLE); #ifdef module_param_array } else { tx_ring->count = opt.def; } #endif for (i = 0; i < adapter->num_tx_queues; i++) tx_ring[i].count = tx_ring->count; } { /* Receive Descriptor Count */ struct iegbe_option opt = { .type = range_option, .name = "Receive Descriptors", .err = "using default of " __MODULE_STRING(E1000_DEFAULT_RXD), .def = E1000_DEFAULT_RXD, .arg = { .r = { .min = E1000_MIN_RXD }} }; struct iegbe_rx_ring *rx_ring = adapter->rx_ring; int i; iegbe_mac_type mac_type = adapter->hw.mac_type; opt.arg.r.max = mac_type < iegbe_82544 ? E1000_MAX_RXD : E1000_MAX_82544_RXD; #ifdef module_param_array if(num_RxDescriptors > bd) { #endif rx_ring->count = RxDescriptors[bd]; iegbe_validate_option(&rx_ring->count, &opt, adapter); E1000_ROUNDUP(rx_ring->count, REQ_RX_DESCRIPTOR_MULTIPLE); #ifdef module_param_array } else { rx_ring->count = opt.def; } #endif for (i = 0; i < adapter->num_rx_queues; i++) rx_ring[i].count = rx_ring->count; } { /* Checksum Offload Enable/Disable */ struct iegbe_option opt = { .type = enable_option, .name = "Checksum Offload", .err = "defaulting to Enabled", .def = OPTION_ENABLED }; #ifdef module_param_array if(num_XsumRX > bd) { #endif int rx_csum = XsumRX[bd]; iegbe_validate_option(&rx_csum, &opt, adapter); adapter->rx_csum = rx_csum; #ifdef module_param_array } else { adapter->rx_csum = opt.def; } #endif } { /* Flow Control */ struct iegbe_opt_list fc_list[] = {{ iegbe_fc_none, "Flow Control Disabled" }, { iegbe_fc_rx_pause,"Flow Control Receive Only" }, { iegbe_fc_tx_pause,"Flow Control Transmit Only" }, { iegbe_fc_full, "Flow Control Enabled" }, { iegbe_fc_default, "Flow Control Hardware Default" }}; struct iegbe_option opt = { .type = list_option, .name = "Flow Control", .err = "reading default settings from EEPROM", .def = iegbe_fc_default, .arg = { .l = { .nr = ARRAY_SIZE(fc_list), .p = fc_list }} }; #ifdef module_param_array if(num_FlowControl > bd) { #endif int fc = FlowControl[bd]; iegbe_validate_option(&fc, &opt, adapter); adapter->hw.fc = adapter->hw.original_fc = fc; #ifdef module_param_array } else { adapter->hw.fc = adapter->hw.original_fc = opt.def; } #endif } { /* Transmit Interrupt Delay */ struct iegbe_option opt = { .type = range_option, .name = "Transmit Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_TIDV), .def = DEFAULT_TIDV, .arg = { .r = { .min = MIN_TXDELAY, .max = MAX_TXDELAY }} }; #ifdef module_param_array if(num_TxIntDelay > bd) { #endif adapter->tx_int_delay = TxIntDelay[bd]; iegbe_validate_option(&adapter->tx_int_delay, &opt, adapter); #ifdef module_param_array } else { adapter->tx_int_delay = opt.def; } #endif } { /* Transmit Absolute Interrupt Delay */ struct iegbe_option opt = { .type = range_option, .name = "Transmit Absolute Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_TADV), .def = DEFAULT_TADV, .arg = { .r = { .min = MIN_TXABSDELAY, .max = MAX_TXABSDELAY }} }; #ifdef module_param_array if(num_TxAbsIntDelay > bd) { #endif adapter->tx_abs_int_delay = TxAbsIntDelay[bd]; iegbe_validate_option(&adapter->tx_abs_int_delay, &opt, adapter); #ifdef module_param_array } else { adapter->tx_abs_int_delay = opt.def; } #endif } { /* Receive Interrupt Delay */ struct iegbe_option opt = { .type = range_option, .name = "Receive Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_RDTR), .def = DEFAULT_RDTR, .arg = { .r = { .min = MIN_RXDELAY, .max = MAX_RXDELAY }} }; #ifdef module_param_array if(num_RxIntDelay > bd) { #endif adapter->rx_int_delay = RxIntDelay[bd]; iegbe_validate_option(&adapter->rx_int_delay, &opt, adapter); #ifdef module_param_array } else { adapter->rx_int_delay = opt.def; } #endif } { /* Receive Absolute Interrupt Delay */ struct iegbe_option opt = { .type = range_option, .name = "Receive Absolute Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_RADV), .def = DEFAULT_RADV, .arg = { .r = { .min = MIN_RXABSDELAY, .max = MAX_RXABSDELAY }} }; #ifdef module_param_array if(num_RxAbsIntDelay > bd) { #endif adapter->rx_abs_int_delay = RxAbsIntDelay[bd]; iegbe_validate_option(&adapter->rx_abs_int_delay, &opt, adapter); #ifdef module_param_array } else { adapter->rx_abs_int_delay = opt.def; } #endif } { /* Interrupt Throttling Rate */ struct iegbe_option opt = { .type = range_option, .name = "Interrupt Throttling Rate (ints/sec)", .err = "using default of " __MODULE_STRING(DEFAULT_ITR), .def = DEFAULT_ITR, .arg = { .r = { .min = MIN_ITR, .max = MAX_ITR }} }; #ifdef module_param_array if(num_InterruptThrottleRate > bd) { #endif adapter->itr = InterruptThrottleRate[bd]; switch(adapter->itr) { case 0: DPRINTK(PROBE, INFO, "%s turned off\n", opt.name); break; case 1: DPRINTK(PROBE, INFO, "%s set to dynamic mode\n", opt.name); break; default: iegbe_validate_option(&adapter->itr, &opt, adapter); break; } #ifdef module_param_array } else { adapter->itr = opt.def; } #endif } switch(adapter->hw.media_type) { case iegbe_media_type_fiber: case iegbe_media_type_internal_serdes: iegbe_check_fiber_options(adapter); break; case iegbe_media_type_copper: iegbe_check_copper_options(adapter); break; case iegbe_media_type_oem: if(iegbe_oem_phy_is_copper(&adapter->hw)) { iegbe_check_copper_options(adapter); }else { iegbe_check_fiber_options(adapter); } break; default: BUG(); } } /** * iegbe_check_fiber_options - Range Checking for Link Options, Fiber Version * @adapter: board private structure * * Handles speed and duplex options on fiber adapters **/ static void iegbe_check_fiber_options(struct iegbe_adapter *adapter) { int bd = adapter->bd_number; #ifndef module_param_array bd = bd > E1000_MAX_NIC ? E1000_MAX_NIC : bd; if((Speed[bd] != OPTION_UNSET)) { #else if(num_Speed > bd) { #endif DPRINTK(PROBE, INFO, "Speed not valid for fiber adapters, " "parameter ignored\n"); } #ifndef module_param_array if((Duplex[bd] != OPTION_UNSET)) { #else if(num_Duplex > bd) { #endif DPRINTK(PROBE, INFO, "Duplex not valid for fiber adapters, " "parameter ignored\n"); } #ifndef module_param_array if((AutoNeg[bd] != OPTION_UNSET) && (AutoNeg[bd] != 0x20)) { #else if((num_AutoNeg > bd) && (AutoNeg[bd] != 0x20)) { #endif DPRINTK(PROBE, INFO, "AutoNeg other than 1000/Full is " "not valid for fiber adapters, " "parameter ignored\n"); } } /** * iegbe_check_copper_options - Range Checking for Link Options, Copper Version * @adapter: board private structure * * Handles speed and duplex options on copper adapters **/ static void iegbe_check_copper_options(struct iegbe_adapter *adapter) { int speed, dplx; int bd = adapter->bd_number; #ifndef module_param_array bd = bd > E1000_MAX_NIC ? E1000_MAX_NIC : bd; #endif { /* Speed */ struct iegbe_opt_list speed_list[] = {{ 0, "" }, { SPEED_10, "" }, { SPEED_100, "" }, { SPEED_1000, "" }}; struct iegbe_option opt = { .type = list_option, .name = "Speed", .err = "parameter ignored", .def = 0, .arg = { .l = { .nr = ARRAY_SIZE(speed_list), .p = speed_list }} }; #ifdef module_param_array if(num_Speed > bd) { #endif speed = Speed[bd]; iegbe_validate_option(&speed, &opt, adapter); #ifdef module_param_array } else { speed = opt.def; } #endif } { /* Duplex */ struct iegbe_opt_list dplx_list[] = {{ 0, "" }, { HALF_DUPLEX, "" }, { FULL_DUPLEX, "" }}; struct iegbe_option opt = { .type = list_option, .name = "Duplex", .err = "parameter ignored", .def = 0, .arg = { .l = { .nr = ARRAY_SIZE(dplx_list), .p = dplx_list }} }; #ifdef module_param_array if(num_Duplex > bd) { #endif dplx = Duplex[bd]; iegbe_validate_option(&dplx, &opt, adapter); #ifdef module_param_array } else { dplx = opt.def; } #endif } #ifdef module_param_array if((num_AutoNeg > bd) && (speed != 0 || dplx != 0)) { #else if(AutoNeg[bd] != OPTION_UNSET && (speed != 0 || dplx != 0)) { #endif DPRINTK(PROBE, INFO, "AutoNeg specified along with Speed or Duplex, " "parameter ignored\n"); adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; } else { struct iegbe_opt_list an_list[] = #define AA "AutoNeg advertising " {{ 0x01, AA "10/HD" }, { 0x02, AA "10/FD" }, { 0x03, AA "10/FD, 10/HD" }, { 0x04, AA "100/HD" }, { 0x05, AA "100/HD, 10/HD" }, { 0x06, AA "100/HD, 10/FD" }, { 0x07, AA "100/HD, 10/FD, 10/HD" }, { 0x08, AA "100/FD" }, { 0x09, AA "100/FD, 10/HD" }, { 0x0a, AA "100/FD, 10/FD" }, { 0x0b, AA "100/FD, 10/FD, 10/HD" }, { 0x0c, AA "100/FD, 100/HD" }, { 0x0d, AA "100/FD, 100/HD, 10/HD" }, { 0x0e, AA "100/FD, 100/HD, 10/FD" }, { 0x0f, AA "100/FD, 100/HD, 10/FD, 10/HD" }, { 0x20, AA "1000/FD" }, { 0x21, AA "1000/FD, 10/HD" }, { 0x22, AA "1000/FD, 10/FD" }, { 0x23, AA "1000/FD, 10/FD, 10/HD" }, { 0x24, AA "1000/FD, 100/HD" }, { 0x25, AA "1000/FD, 100/HD, 10/HD" }, { 0x26, AA "1000/FD, 100/HD, 10/FD" }, { 0x27, AA "1000/FD, 100/HD, 10/FD, 10/HD" }, { 0x28, AA "1000/FD, 100/FD" }, { 0x29, AA "1000/FD, 100/FD, 10/HD" }, { 0x2a, AA "1000/FD, 100/FD, 10/FD" }, { 0x2b, AA "1000/FD, 100/FD, 10/FD, 10/HD" }, { 0x2c, AA "1000/FD, 100/FD, 100/HD" }, { 0x2d, AA "1000/FD, 100/FD, 100/HD, 10/HD" }, { 0x2e, AA "1000/FD, 100/FD, 100/HD, 10/FD" }, { 0x2f, AA "1000/FD, 100/FD, 100/HD, 10/FD, 10/HD" }}; struct iegbe_option opt = { .type = list_option, .name = "AutoNeg", .err = "parameter ignored", .def = AUTONEG_ADV_DEFAULT, .arg = { .l = { .nr = ARRAY_SIZE(an_list), .p = an_list }} }; int an = AutoNeg[bd]; iegbe_validate_option(&an, &opt, adapter); adapter->hw.autoneg_advertised = an; } switch (speed + dplx) { case 0: adapter->hw.autoneg = adapter->fc_autoneg = 1; #ifdef module_param_array if((num_Speed > bd) && (speed != 0 || dplx != 0)) { #else if(Speed[bd] != OPTION_UNSET || Duplex[bd] != OPTION_UNSET) { #endif DPRINTK(PROBE, INFO, "Speed and duplex autonegotiation enabled\n"); } break; case HALF_DUPLEX: DPRINTK(PROBE, INFO, "Half Duplex specified without Speed\n"); DPRINTK(PROBE, INFO, "Using Autonegotiation at " "Half Duplex only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_10_HALF | ADVERTISE_100_HALF; break; case FULL_DUPLEX: DPRINTK(PROBE, INFO, "Full Duplex specified without Speed\n"); DPRINTK(PROBE, INFO, "Using Autonegotiation at " "Full Duplex only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_10_FULL | ADVERTISE_100_FULL | ADVERTISE_1000_FULL; break; case SPEED_10: DPRINTK(PROBE, INFO, "10 Mbps Speed specified " "without Duplex\n"); DPRINTK(PROBE, INFO, "Using Autonegotiation at 10 Mbps only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_10_HALF | ADVERTISE_10_FULL; break; case SPEED_10 + HALF_DUPLEX: DPRINTK(PROBE, INFO, "Forcing to 10 Mbps Half Duplex\n"); adapter->hw.autoneg = adapter->fc_autoneg = 0; adapter->hw.forced_speed_duplex = iegbe_10_half; adapter->hw.autoneg_advertised = 0; break; case SPEED_10 + FULL_DUPLEX: DPRINTK(PROBE, INFO, "Forcing to 10 Mbps Full Duplex\n"); adapter->hw.autoneg = adapter->fc_autoneg = 0; adapter->hw.forced_speed_duplex = iegbe_10_full; adapter->hw.autoneg_advertised = 0; break; case SPEED_100: DPRINTK(PROBE, INFO, "100 Mbps Speed specified " "without Duplex\n"); DPRINTK(PROBE, INFO, "Using Autonegotiation at " "100 Mbps only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_100_HALF | ADVERTISE_100_FULL; break; case SPEED_100 + HALF_DUPLEX: DPRINTK(PROBE, INFO, "Forcing to 100 Mbps Half Duplex\n"); adapter->hw.autoneg = adapter->fc_autoneg = 0; adapter->hw.forced_speed_duplex = iegbe_100_half; adapter->hw.autoneg_advertised = 0; break; case SPEED_100 + FULL_DUPLEX: DPRINTK(PROBE, INFO, "Forcing to 100 Mbps Full Duplex\n"); adapter->hw.autoneg = adapter->fc_autoneg = 0; adapter->hw.forced_speed_duplex = iegbe_100_full; adapter->hw.autoneg_advertised = 0; break; case SPEED_1000: DPRINTK(PROBE, INFO, "1000 Mbps Speed specified without " "Duplex\n"); DPRINTK(PROBE, INFO, "Using Autonegotiation at 1000 Mbps " "Full Duplex only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL; break; case SPEED_1000 + HALF_DUPLEX: DPRINTK(PROBE, INFO, "Half Duplex is not supported at 1000 Mbps\n"); DPRINTK(PROBE, INFO, "Using Autonegotiation at 1000 Mbps " "Full Duplex only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL; break; case SPEED_1000 + FULL_DUPLEX: DPRINTK(PROBE, INFO, "Using Autonegotiation at 1000 Mbps Full Duplex only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL; break; default: BUG(); } /* Speed, AutoNeg and MDI/MDI-X must all play nice */ if(iegbe_validate_mdi_setting(&(adapter->hw)) < 0) { DPRINTK(PROBE, INFO, "Speed, AutoNeg and MDI-X specifications are " "incompatible. Setting MDI-X to a compatible value.\n"); } }
static int e1000_setup_desc_rings(struct e1000_adapter *adapter) { struct e1000_desc_ring *txdr = &adapter->test_tx_ring; struct e1000_desc_ring *rxdr = &adapter->test_rx_ring; struct pci_dev *pdev = adapter->pdev; uint32_t rctl; int size, i, ret_val; /* Setup Tx descriptor ring and Tx buffers */ txdr->count = 80; size = txdr->count * sizeof(struct e1000_buffer); if(!(txdr->buffer_info = kmalloc(size, GFP_KERNEL))) { ret_val = 1; goto err_nomem; } memset(txdr->buffer_info, 0, size); txdr->size = txdr->count * sizeof(struct e1000_tx_desc); E1000_ROUNDUP(txdr->size, 4096); if(!(txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma))) { ret_val = 2; goto err_nomem; } memset(txdr->desc, 0, txdr->size); txdr->next_to_use = txdr->next_to_clean = 0; E1000_WRITE_REG(&adapter->hw, TDBAL, ((uint64_t) txdr->dma & 0x00000000FFFFFFFF)); E1000_WRITE_REG(&adapter->hw, TDBAH, ((uint64_t) txdr->dma >> 32)); E1000_WRITE_REG(&adapter->hw, TDLEN, txdr->count * sizeof(struct e1000_tx_desc)); E1000_WRITE_REG(&adapter->hw, TDH, 0); E1000_WRITE_REG(&adapter->hw, TDT, 0); E1000_WRITE_REG(&adapter->hw, TCTL, E1000_TCTL_PSP | E1000_TCTL_EN | E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT | E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT); for(i = 0; i < txdr->count; i++) { struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*txdr, i); struct sk_buff *skb; unsigned int size = 1024; if(!(skb = alloc_skb(size, GFP_KERNEL))) { ret_val = 3; goto err_nomem; } skb_put(skb, size); txdr->buffer_info[i].skb = skb; txdr->buffer_info[i].length = skb->len; txdr->buffer_info[i].dma = pci_map_single(pdev, skb->data, skb->len, PCI_DMA_TODEVICE); tx_desc->buffer_addr = cpu_to_le64(txdr->buffer_info[i].dma); tx_desc->lower.data = cpu_to_le32(skb->len); tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RPS); tx_desc->upper.data = 0; } /* Setup Rx descriptor ring and Rx buffers */ rxdr->count = 80; size = rxdr->count * sizeof(struct e1000_buffer); if(!(rxdr->buffer_info = kmalloc(size, GFP_KERNEL))) { ret_val = 4; goto err_nomem; } memset(rxdr->buffer_info, 0, size); rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc); if(!(rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma))) { ret_val = 5; goto err_nomem; } memset(rxdr->desc, 0, rxdr->size); rxdr->next_to_use = rxdr->next_to_clean = 0; rctl = E1000_READ_REG(&adapter->hw, RCTL); E1000_WRITE_REG(&adapter->hw, RCTL, rctl & ~E1000_RCTL_EN); E1000_WRITE_REG(&adapter->hw, RDBAL, ((uint64_t) rxdr->dma & 0xFFFFFFFF)); E1000_WRITE_REG(&adapter->hw, RDBAH, ((uint64_t) rxdr->dma >> 32)); E1000_WRITE_REG(&adapter->hw, RDLEN, rxdr->size); E1000_WRITE_REG(&adapter->hw, RDH, 0); E1000_WRITE_REG(&adapter->hw, RDT, 0); rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 | E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF | (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); E1000_WRITE_REG(&adapter->hw, RCTL, rctl); for(i = 0; i < rxdr->count; i++) { struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rxdr, i); struct sk_buff *skb; if(!(skb = alloc_skb(E1000_RXBUFFER_2048 + NET_IP_ALIGN, GFP_KERNEL))) { ret_val = 6; goto err_nomem; } skb_reserve(skb, NET_IP_ALIGN); rxdr->buffer_info[i].skb = skb; rxdr->buffer_info[i].length = E1000_RXBUFFER_2048; rxdr->buffer_info[i].dma = pci_map_single(pdev, skb->data, E1000_RXBUFFER_2048, PCI_DMA_FROMDEVICE); rx_desc->buffer_addr = cpu_to_le64(rxdr->buffer_info[i].dma); memset(skb->data, 0x00, skb->len); } return 0; err_nomem: e1000_free_desc_rings(adapter); return ret_val; }
void __devinit e1000_check_options(struct e1000_adapter *adapter) { int bd = adapter->bd_number; if (bd >= E1000_MAX_NIC) { DPRINTK(PROBE, NOTICE, "Warning: no configuration for board #%i\n", bd); DPRINTK(PROBE, NOTICE, "Using defaults for all values\n"); } { /* Transmit Descriptor Count */ struct e1000_option opt = { .type = range_option, .name = "Transmit Descriptors", .err = "using default of " __MODULE_STRING(E1000_DEFAULT_TXD), .def = E1000_DEFAULT_TXD, .arg = { .r = { .min = E1000_MIN_TXD }} }; struct e1000_tx_ring *tx_ring = adapter->tx_ring; int i; e1000_mac_type mac_type = adapter->hw.mac_type; opt.arg.r.max = mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD; if (num_TxDescriptors > bd) { tx_ring->count = TxDescriptors[bd]; e1000_validate_option(&tx_ring->count, &opt, adapter); E1000_ROUNDUP(tx_ring->count, REQ_TX_DESCRIPTOR_MULTIPLE); } else { tx_ring->count = opt.def; } for (i = 0; i < adapter->num_tx_queues; i++) tx_ring[i].count = tx_ring->count; } { /* Receive Descriptor Count */ struct e1000_option opt = { .type = range_option, .name = "Receive Descriptors", .err = "using default of " __MODULE_STRING(E1000_DEFAULT_RXD), .def = E1000_DEFAULT_RXD, .arg = { .r = { .min = E1000_MIN_RXD }} }; struct e1000_rx_ring *rx_ring = adapter->rx_ring; int i; e1000_mac_type mac_type = adapter->hw.mac_type; opt.arg.r.max = mac_type < e1000_82544 ? E1000_MAX_RXD : E1000_MAX_82544_RXD; if (num_RxDescriptors > bd) { rx_ring->count = RxDescriptors[bd]; e1000_validate_option(&rx_ring->count, &opt, adapter); E1000_ROUNDUP(rx_ring->count, REQ_RX_DESCRIPTOR_MULTIPLE); } else { rx_ring->count = opt.def; } for (i = 0; i < adapter->num_rx_queues; i++) rx_ring[i].count = rx_ring->count; } { /* Checksum Offload Enable/Disable */ struct e1000_option opt = { .type = enable_option, .name = "Checksum Offload", .err = "defaulting to Enabled", .def = OPTION_ENABLED }; if (num_XsumRX > bd) { int rx_csum = XsumRX[bd]; e1000_validate_option(&rx_csum, &opt, adapter); adapter->rx_csum = rx_csum; } else { adapter->rx_csum = opt.def; } } { /* Flow Control */ struct e1000_opt_list fc_list[] = { { E1000_FC_NONE, "Flow Control Disabled" }, { E1000_FC_RX_PAUSE,"Flow Control Receive Only" }, { E1000_FC_TX_PAUSE,"Flow Control Transmit Only" }, { E1000_FC_FULL, "Flow Control Enabled" }, { E1000_FC_DEFAULT, "Flow Control Hardware Default" } }; struct e1000_option opt = { .type = list_option, .name = "Flow Control", .err = "reading default settings from EEPROM", .def = E1000_FC_DEFAULT, .arg = { .l = { .nr = ARRAY_SIZE(fc_list), .p = fc_list } } }; if (num_FlowControl > bd) { int fc = FlowControl[bd]; e1000_validate_option(&fc, &opt, adapter); adapter->hw.fc = adapter->hw.original_fc = fc; } else { adapter->hw.fc = adapter->hw.original_fc = opt.def; } } { /* Transmit Interrupt Delay */ struct e1000_option opt = { .type = range_option, .name = "Transmit Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_TIDV), .def = DEFAULT_TIDV, .arg = { .r = { .min = MIN_TXDELAY, .max = MAX_TXDELAY } } }; if (num_TxIntDelay > bd) { adapter->tx_int_delay = TxIntDelay[bd]; e1000_validate_option(&adapter->tx_int_delay, &opt, adapter); } else { adapter->tx_int_delay = opt.def; } } { /* Transmit Absolute Interrupt Delay */ struct e1000_option opt = { .type = range_option, .name = "Transmit Absolute Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_TADV), .def = DEFAULT_TADV, .arg = { .r = { .min = MIN_TXABSDELAY, .max = MAX_TXABSDELAY } } }; if (num_TxAbsIntDelay > bd) { adapter->tx_abs_int_delay = TxAbsIntDelay[bd]; e1000_validate_option(&adapter->tx_abs_int_delay, &opt, adapter); } else { adapter->tx_abs_int_delay = opt.def; } } { /* Receive Interrupt Delay */ struct e1000_option opt = { .type = range_option, .name = "Receive Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_RDTR), .def = DEFAULT_RDTR, .arg = { .r = { .min = MIN_RXDELAY, .max = MAX_RXDELAY } } }; if (num_RxIntDelay > bd) { adapter->rx_int_delay = RxIntDelay[bd]; e1000_validate_option(&adapter->rx_int_delay, &opt, adapter); } else { adapter->rx_int_delay = opt.def; } } { /* Receive Absolute Interrupt Delay */ struct e1000_option opt = { .type = range_option, .name = "Receive Absolute Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_RADV), .def = DEFAULT_RADV, .arg = { .r = { .min = MIN_RXABSDELAY, .max = MAX_RXABSDELAY } } }; if (num_RxAbsIntDelay > bd) { adapter->rx_abs_int_delay = RxAbsIntDelay[bd]; e1000_validate_option(&adapter->rx_abs_int_delay, &opt, adapter); } else { adapter->rx_abs_int_delay = opt.def; } } { /* Interrupt Throttling Rate */ struct e1000_option opt = { .type = range_option, .name = "Interrupt Throttling Rate (ints/sec)", .err = "using default of " __MODULE_STRING(DEFAULT_ITR), .def = DEFAULT_ITR, .arg = { .r = { .min = MIN_ITR, .max = MAX_ITR } } }; if (num_InterruptThrottleRate > bd) { adapter->itr = InterruptThrottleRate[bd]; switch (adapter->itr) { case 0: DPRINTK(PROBE, INFO, "%s turned off\n", opt.name); break; case 1: DPRINTK(PROBE, INFO, "%s set to dynamic mode\n", opt.name); adapter->itr_setting = adapter->itr; adapter->itr = 20000; break; case 3: DPRINTK(PROBE, INFO, "%s set to dynamic conservative mode\n", opt.name); adapter->itr_setting = adapter->itr; adapter->itr = 20000; break; default: e1000_validate_option(&adapter->itr, &opt, adapter); /* save the setting, because the dynamic bits change itr */ /* clear the lower two bits because they are * used as control */ adapter->itr_setting = adapter->itr & ~3; break; } } else { adapter->itr_setting = opt.def; adapter->itr = 20000; } } { /* Smart Power Down */ struct e1000_option opt = { .type = enable_option, .name = "PHY Smart Power Down", .err = "defaulting to Disabled", .def = OPTION_DISABLED }; if (num_SmartPowerDownEnable > bd) { int spd = SmartPowerDownEnable[bd]; e1000_validate_option(&spd, &opt, adapter); adapter->smart_power_down = spd; } else { adapter->smart_power_down = opt.def; } } { /* Kumeran Lock Loss Workaround */ struct e1000_option opt = { .type = enable_option, .name = "Kumeran Lock Loss Workaround", .err = "defaulting to Enabled", .def = OPTION_ENABLED }; if (num_KumeranLockLoss > bd) { int kmrn_lock_loss = KumeranLockLoss[bd]; e1000_validate_option(&kmrn_lock_loss, &opt, adapter); adapter->hw.kmrn_lock_loss_workaround_disabled = !kmrn_lock_loss; } else { adapter->hw.kmrn_lock_loss_workaround_disabled = !opt.def; } } switch (adapter->hw.media_type) { case e1000_media_type_fiber: case e1000_media_type_internal_serdes: e1000_check_fiber_options(adapter); break; case e1000_media_type_copper: e1000_check_copper_options(adapter); break; default: BUG(); } } /** * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version * @adapter: board private structure * * Handles speed and duplex options on fiber adapters **/ static void __devinit e1000_check_fiber_options(struct e1000_adapter *adapter) { int bd = adapter->bd_number; if (num_Speed > bd) { DPRINTK(PROBE, INFO, "Speed not valid for fiber adapters, " "parameter ignored\n"); } if (num_Duplex > bd) { DPRINTK(PROBE, INFO, "Duplex not valid for fiber adapters, " "parameter ignored\n"); } if ((num_AutoNeg > bd) && (AutoNeg[bd] != 0x20)) { DPRINTK(PROBE, INFO, "AutoNeg other than 1000/Full is " "not valid for fiber adapters, " "parameter ignored\n"); } } /** * e1000_check_copper_options - Range Checking for Link Options, Copper Version * @adapter: board private structure * * Handles speed and duplex options on copper adapters **/ static void __devinit e1000_check_copper_options(struct e1000_adapter *adapter) { int speed, dplx, an; int bd = adapter->bd_number; { /* Speed */ struct e1000_opt_list speed_list[] = {{ 0, "" }, { SPEED_10, "" }, { SPEED_100, "" }, { SPEED_1000, "" } }; struct e1000_option opt = { .type = list_option, .name = "Speed", .err = "parameter ignored", .def = 0, .arg = { .l = { .nr = ARRAY_SIZE(speed_list), .p = speed_list } } }; if (num_Speed > bd) { speed = Speed[bd]; e1000_validate_option(&speed, &opt, adapter); } else { speed = opt.def; } } { /* Duplex */ struct e1000_opt_list dplx_list[] = {{ 0, "" }, { HALF_DUPLEX, "" }, { FULL_DUPLEX, "" } }; struct e1000_option opt = { .type = list_option, .name = "Duplex", .err = "parameter ignored", .def = 0, .arg = { .l = { .nr = ARRAY_SIZE(dplx_list), .p = dplx_list } } }; if (e1000_check_phy_reset_block(&adapter->hw)) { DPRINTK(PROBE, INFO, "Link active due to SoL/IDER Session. " "Speed/Duplex/AutoNeg parameter ignored.\n"); return; } if (num_Duplex > bd) { dplx = Duplex[bd]; e1000_validate_option(&dplx, &opt, adapter); } else { dplx = opt.def; } } if ((num_AutoNeg > bd) && (speed != 0 || dplx != 0)) { DPRINTK(PROBE, INFO, "AutoNeg specified along with Speed or Duplex, " "parameter ignored\n"); adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; } else { /* Autoneg */ struct e1000_opt_list an_list[] = #define AA "AutoNeg advertising " { { 0x01, AA "10/HD" }, { 0x02, AA "10/FD" }, { 0x03, AA "10/FD, 10/HD" }, { 0x04, AA "100/HD" }, { 0x05, AA "100/HD, 10/HD" }, { 0x06, AA "100/HD, 10/FD" }, { 0x07, AA "100/HD, 10/FD, 10/HD" }, { 0x08, AA "100/FD" }, { 0x09, AA "100/FD, 10/HD" }, { 0x0a, AA "100/FD, 10/FD" }, { 0x0b, AA "100/FD, 10/FD, 10/HD" }, { 0x0c, AA "100/FD, 100/HD" }, { 0x0d, AA "100/FD, 100/HD, 10/HD" }, { 0x0e, AA "100/FD, 100/HD, 10/FD" }, { 0x0f, AA "100/FD, 100/HD, 10/FD, 10/HD" }, { 0x20, AA "1000/FD" }, { 0x21, AA "1000/FD, 10/HD" }, { 0x22, AA "1000/FD, 10/FD" }, { 0x23, AA "1000/FD, 10/FD, 10/HD" }, { 0x24, AA "1000/FD, 100/HD" }, { 0x25, AA "1000/FD, 100/HD, 10/HD" }, { 0x26, AA "1000/FD, 100/HD, 10/FD" }, { 0x27, AA "1000/FD, 100/HD, 10/FD, 10/HD" }, { 0x28, AA "1000/FD, 100/FD" }, { 0x29, AA "1000/FD, 100/FD, 10/HD" }, { 0x2a, AA "1000/FD, 100/FD, 10/FD" }, { 0x2b, AA "1000/FD, 100/FD, 10/FD, 10/HD" }, { 0x2c, AA "1000/FD, 100/FD, 100/HD" }, { 0x2d, AA "1000/FD, 100/FD, 100/HD, 10/HD" }, { 0x2e, AA "1000/FD, 100/FD, 100/HD, 10/FD" }, { 0x2f, AA "1000/FD, 100/FD, 100/HD, 10/FD, 10/HD" } }; struct e1000_option opt = { .type = list_option, .name = "AutoNeg", .err = "parameter ignored", .def = AUTONEG_ADV_DEFAULT, .arg = { .l = { .nr = ARRAY_SIZE(an_list), .p = an_list } } }; if (num_AutoNeg > bd) { an = AutoNeg[bd]; e1000_validate_option(&an, &opt, adapter); } else { an = opt.def; } adapter->hw.autoneg_advertised = an; } switch (speed + dplx) { case 0: adapter->hw.autoneg = adapter->fc_autoneg = 1; if ((num_Speed > bd) && (speed != 0 || dplx != 0)) DPRINTK(PROBE, INFO, "Speed and duplex autonegotiation enabled\n"); break; case HALF_DUPLEX: DPRINTK(PROBE, INFO, "Half Duplex specified without Speed\n"); DPRINTK(PROBE, INFO, "Using Autonegotiation at " "Half Duplex only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_10_HALF | ADVERTISE_100_HALF; break; case FULL_DUPLEX: DPRINTK(PROBE, INFO, "Full Duplex specified without Speed\n"); DPRINTK(PROBE, INFO, "Using Autonegotiation at " "Full Duplex only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_10_FULL | ADVERTISE_100_FULL | ADVERTISE_1000_FULL; break; case SPEED_10: DPRINTK(PROBE, INFO, "10 Mbps Speed specified " "without Duplex\n"); DPRINTK(PROBE, INFO, "Using Autonegotiation at 10 Mbps only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_10_HALF | ADVERTISE_10_FULL; break; case SPEED_10 + HALF_DUPLEX: DPRINTK(PROBE, INFO, "Forcing to 10 Mbps Half Duplex\n"); adapter->hw.autoneg = adapter->fc_autoneg = 0; adapter->hw.forced_speed_duplex = e1000_10_half; adapter->hw.autoneg_advertised = 0; break; case SPEED_10 + FULL_DUPLEX: DPRINTK(PROBE, INFO, "Forcing to 10 Mbps Full Duplex\n"); adapter->hw.autoneg = adapter->fc_autoneg = 0; adapter->hw.forced_speed_duplex = e1000_10_full; adapter->hw.autoneg_advertised = 0; break; case SPEED_100: DPRINTK(PROBE, INFO, "100 Mbps Speed specified " "without Duplex\n"); DPRINTK(PROBE, INFO, "Using Autonegotiation at " "100 Mbps only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_100_HALF | ADVERTISE_100_FULL; break; case SPEED_100 + HALF_DUPLEX: DPRINTK(PROBE, INFO, "Forcing to 100 Mbps Half Duplex\n"); adapter->hw.autoneg = adapter->fc_autoneg = 0; adapter->hw.forced_speed_duplex = e1000_100_half; adapter->hw.autoneg_advertised = 0; break; case SPEED_100 + FULL_DUPLEX: DPRINTK(PROBE, INFO, "Forcing to 100 Mbps Full Duplex\n"); adapter->hw.autoneg = adapter->fc_autoneg = 0; adapter->hw.forced_speed_duplex = e1000_100_full; adapter->hw.autoneg_advertised = 0; break; case SPEED_1000: DPRINTK(PROBE, INFO, "1000 Mbps Speed specified without " "Duplex\n"); goto full_duplex_only; case SPEED_1000 + HALF_DUPLEX: DPRINTK(PROBE, INFO, "Half Duplex is not supported at 1000 Mbps\n"); /* fall through */ case SPEED_1000 + FULL_DUPLEX: full_duplex_only: DPRINTK(PROBE, INFO, "Using Autonegotiation at 1000 Mbps Full Duplex only\n"); adapter->hw.autoneg = adapter->fc_autoneg = 1; adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL; break; default: BUG(); } /* Speed, AutoNeg and MDI/MDI-X must all play nice */ if (e1000_validate_mdi_setting(&(adapter->hw)) < 0) { DPRINTK(PROBE, INFO, "Speed, AutoNeg and MDI-X specifications are " "incompatible. Setting MDI-X to a compatible value.\n"); } }
static int e1000_set_ringparam(struct net_device *netdev, struct ethtool_ringparam *ring) { struct e1000_adapter *adapter = netdev->priv; e1000_mac_type mac_type = adapter->hw.mac_type; struct e1000_desc_ring *txdr = &adapter->tx_ring; struct e1000_desc_ring *rxdr = &adapter->rx_ring; struct e1000_desc_ring tx_old, tx_new, rx_old, rx_new; int err; tx_old = adapter->tx_ring; rx_old = adapter->rx_ring; if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending)) return -EINVAL; if(netif_running(adapter->netdev)) e1000_down(adapter); rxdr->count = max(ring->rx_pending,(uint32_t)E1000_MIN_RXD); rxdr->count = min(rxdr->count,(uint32_t)(mac_type < e1000_82544 ? E1000_MAX_RXD : E1000_MAX_82544_RXD)); E1000_ROUNDUP(rxdr->count, REQ_RX_DESCRIPTOR_MULTIPLE); txdr->count = max(ring->tx_pending,(uint32_t)E1000_MIN_TXD); txdr->count = min(txdr->count,(uint32_t)(mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD)); E1000_ROUNDUP(txdr->count, REQ_TX_DESCRIPTOR_MULTIPLE); if(netif_running(adapter->netdev)) { /* Try to get new resources before deleting old */ if((err = e1000_setup_rx_resources(adapter))) goto err_setup_rx; if((err = e1000_setup_tx_resources(adapter))) goto err_setup_tx; /* save the new, restore the old in order to free it, * then restore the new back again */ rx_new = adapter->rx_ring; tx_new = adapter->tx_ring; adapter->rx_ring = rx_old; adapter->tx_ring = tx_old; e1000_free_rx_resources(adapter); e1000_free_tx_resources(adapter); adapter->rx_ring = rx_new; adapter->tx_ring = tx_new; if((err = e1000_up(adapter))) return err; } return 0; err_setup_tx: e1000_free_rx_resources(adapter); err_setup_rx: adapter->rx_ring = rx_old; adapter->tx_ring = tx_old; e1000_up(adapter); return err; }
void __devinit e1000_check_options(struct e1000_adapter *adapter) { int bd = adapter->bd_number; if(bd >= E1000_MAX_NIC) { DPRINTK(PROBE, NOTICE, "Warning: no configuration for board #%i\n", bd); DPRINTK(PROBE, NOTICE, "Using defaults for all values\n"); } { /* Transmit Descriptor Count */ struct e1000_option opt = { .type = range_option, .name = "Transmit Descriptors", .err = "using default of " __MODULE_STRING(E1000_DEFAULT_TXD), .def = E1000_DEFAULT_TXD, .arg = { .r = { .min = E1000_MIN_TXD }} }; struct e1000_desc_ring *tx_ring = &adapter->tx_ring; e1000_mac_type mac_type = adapter->hw.mac_type; opt.arg.r.max = mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD; if (num_TxDescriptors > bd) { tx_ring->count = TxDescriptors[bd]; e1000_validate_option(&tx_ring->count, &opt, adapter); E1000_ROUNDUP(tx_ring->count, REQ_TX_DESCRIPTOR_MULTIPLE); } else { tx_ring->count = opt.def; } } { /* Receive Descriptor Count */ struct e1000_option opt = { .type = range_option, .name = "Receive Descriptors", .err = "using default of " __MODULE_STRING(E1000_DEFAULT_RXD), .def = E1000_DEFAULT_RXD, .arg = { .r = { .min = E1000_MIN_RXD }} }; struct e1000_desc_ring *rx_ring = &adapter->rx_ring; e1000_mac_type mac_type = adapter->hw.mac_type; opt.arg.r.max = mac_type < e1000_82544 ? E1000_MAX_RXD : E1000_MAX_82544_RXD; if (num_RxDescriptors > bd) { rx_ring->count = RxDescriptors[bd]; e1000_validate_option(&rx_ring->count, &opt, adapter); E1000_ROUNDUP(rx_ring->count, REQ_RX_DESCRIPTOR_MULTIPLE); } else { rx_ring->count = opt.def; } } { /* Checksum Offload Enable/Disable */ struct e1000_option opt = { .type = enable_option, .name = "Checksum Offload", .err = "defaulting to Enabled", .def = OPTION_ENABLED }; if (num_XsumRX > bd) { int rx_csum = XsumRX[bd]; e1000_validate_option(&rx_csum, &opt, adapter); adapter->rx_csum = rx_csum; } else { adapter->rx_csum = opt.def; } } { /* Flow Control */ struct e1000_opt_list fc_list[] = {{ e1000_fc_none, "Flow Control Disabled" }, { e1000_fc_rx_pause,"Flow Control Receive Only" }, { e1000_fc_tx_pause,"Flow Control Transmit Only" }, { e1000_fc_full, "Flow Control Enabled" }, { e1000_fc_default, "Flow Control Hardware Default" }}; struct e1000_option opt = { .type = list_option, .name = "Flow Control", .err = "reading default settings from EEPROM", .def = e1000_fc_default, .arg = { .l = { .nr = ARRAY_SIZE(fc_list), .p = fc_list }} }; if (num_FlowControl > bd) { int fc = FlowControl[bd]; e1000_validate_option(&fc, &opt, adapter); adapter->hw.fc = adapter->hw.original_fc = fc; } else { adapter->hw.fc = opt.def; } } { /* Transmit Interrupt Delay */ struct e1000_option opt = { .type = range_option, .name = "Transmit Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_TIDV), .def = DEFAULT_TIDV, .arg = { .r = { .min = MIN_TXDELAY, .max = MAX_TXDELAY }} }; if (num_TxIntDelay > bd) { adapter->tx_int_delay = TxIntDelay[bd]; e1000_validate_option(&adapter->tx_int_delay, &opt, adapter); } else { adapter->tx_int_delay = opt.def; } } { /* Transmit Absolute Interrupt Delay */ struct e1000_option opt = { .type = range_option, .name = "Transmit Absolute Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_TADV), .def = DEFAULT_TADV, .arg = { .r = { .min = MIN_TXABSDELAY, .max = MAX_TXABSDELAY }} }; if (num_TxAbsIntDelay > bd) { adapter->tx_abs_int_delay = TxAbsIntDelay[bd]; e1000_validate_option(&adapter->tx_abs_int_delay, &opt, adapter); } else { adapter->tx_abs_int_delay = opt.def; } } { /* Receive Interrupt Delay */ struct e1000_option opt = { .type = range_option, .name = "Receive Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_RDTR), .def = DEFAULT_RDTR, .arg = { .r = { .min = MIN_RXDELAY, .max = MAX_RXDELAY }} }; if (num_RxIntDelay > bd) { adapter->rx_int_delay = RxIntDelay[bd]; e1000_validate_option(&adapter->rx_int_delay, &opt, adapter); } else { adapter->rx_int_delay = opt.def; } } { /* Receive Absolute Interrupt Delay */ struct e1000_option opt = { .type = range_option, .name = "Receive Absolute Interrupt Delay", .err = "using default of " __MODULE_STRING(DEFAULT_RADV), .def = DEFAULT_RADV, .arg = { .r = { .min = MIN_RXABSDELAY, .max = MAX_RXABSDELAY }} }; if (num_RxAbsIntDelay > bd) { adapter->rx_abs_int_delay = RxAbsIntDelay[bd]; e1000_validate_option(&adapter->rx_abs_int_delay, &opt, adapter); } else { adapter->rx_abs_int_delay = opt.def; } } { /* Interrupt Throttling Rate */ struct e1000_option opt = { .type = range_option, .name = "Interrupt Throttling Rate (ints/sec)", .err = "using default of " __MODULE_STRING(DEFAULT_ITR), .def = DEFAULT_ITR, .arg = { .r = { .min = MIN_ITR, .max = MAX_ITR }} }; if (num_InterruptThrottleRate > bd) { adapter->itr = InterruptThrottleRate[bd]; switch(adapter->itr) { case 0: DPRINTK(PROBE, INFO, "%s turned off\n", opt.name); break; case 1: DPRINTK(PROBE, INFO, "%s set to dynamic mode\n", opt.name); break; case -1: default: e1000_validate_option(&adapter->itr, &opt, adapter); break; } } else { adapter->itr = opt.def; } } switch(adapter->hw.media_type) { case e1000_media_type_fiber: case e1000_media_type_internal_serdes: e1000_check_fiber_options(adapter); break; case e1000_media_type_copper: e1000_check_copper_options(adapter); break; default: BUG(); } } /** * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version * @adapter: board private structure * * Handles speed and duplex options on fiber adapters **/ static void __devinit e1000_check_fiber_options(struct e1000_adapter *adapter) { int bd = adapter->bd_number; if(num_Speed > bd) { DPRINTK(PROBE, INFO, "Speed not valid for fiber adapters, " "parameter ignored\n"); } if(num_Duplex > bd) { DPRINTK(PROBE, INFO, "Duplex not valid for fiber adapters, " "parameter ignored\n"); } if((num_AutoNeg > bd) && (AutoNeg[bd] != 0x20)) { DPRINTK(PROBE, INFO, "AutoNeg other than 1000/Full is " "not valid for fiber adapters, " "parameter ignored\n"); } }