3 * 10/100/1000 Base-T Ethernet Driver for the ET1301 and ET131x series MACs
5 * Copyright © 2005 Agere Systems Inc.
9 *------------------------------------------------------------------------------
11 * et131x_netdev.c - Routines and data required by all Linux network devices.
13 *------------------------------------------------------------------------------
17 * This software is provided subject to the following terms and conditions,
18 * which you should read carefully before using the software. Using this
19 * software indicates your acceptance of these terms and conditions. If you do
20 * not agree with these terms and conditions, do not use the software.
22 * Copyright © 2005 Agere Systems Inc.
23 * All rights reserved.
25 * Redistribution and use in source or binary forms, with or without
26 * modifications, are permitted provided that the following conditions are met:
28 * . Redistributions of source code must retain the above copyright notice, this
29 * list of conditions and the following Disclaimer as comments in the code as
30 * well as in the documentation and/or other materials provided with the
33 * . Redistributions in binary form must reproduce the above copyright notice,
34 * this list of conditions and the following Disclaimer in the documentation
35 * and/or other materials provided with the distribution.
37 * . Neither the name of Agere Systems Inc. nor the names of the contributors
38 * may be used to endorse or promote products derived from this software
39 * without specific prior written permission.
43 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
44 * INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
45 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ANY
46 * USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
47 * RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
48 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
49 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
50 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
51 * ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
52 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
53 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
58 #include "et131x_version.h"
59 #include "et131x_debug.h"
60 #include "et131x_defs.h"
62 #include <linux/init.h>
63 #include <linux/module.h>
64 #include <linux/types.h>
65 #include <linux/kernel.h>
67 #include <linux/sched.h>
68 #include <linux/ptrace.h>
69 #include <linux/slab.h>
70 #include <linux/ctype.h>
71 #include <linux/string.h>
72 #include <linux/timer.h>
73 #include <linux/interrupt.h>
75 #include <linux/delay.h>
77 #include <linux/bitops.h>
78 #include <asm/system.h>
80 #include <linux/mii.h>
81 #include <linux/netdevice.h>
82 #include <linux/etherdevice.h>
83 #include <linux/skbuff.h>
84 #include <linux/if_arp.h>
85 #include <linux/ioport.h>
87 #include "et1310_phy.h"
88 #include "et1310_pm.h"
89 #include "et1310_jagcore.h"
90 #include "et1310_mac.h"
91 #include "et1310_tx.h"
93 #include "et131x_adapter.h"
94 #include "et131x_isr.h"
95 #include "et131x_initpci.h"
97 /* Data for debugging facilities */
98 #ifdef CONFIG_ET131X_DEBUG
99 extern dbg_info_t *et131x_dbginfo;
100 #endif /* CONFIG_ET131X_DEBUG */
102 struct net_device_stats *et131x_stats(struct net_device *netdev);
103 int et131x_open(struct net_device *netdev);
104 int et131x_close(struct net_device *netdev);
105 int et131x_ioctl(struct net_device *netdev, struct ifreq *reqbuf, int cmd);
106 void et131x_multicast(struct net_device *netdev);
107 int et131x_tx(struct sk_buff *skb, struct net_device *netdev);
108 void et131x_tx_timeout(struct net_device *netdev);
109 int et131x_change_mtu(struct net_device *netdev, int new_mtu);
110 int et131x_set_mac_addr(struct net_device *netdev, void *new_mac);
111 void et131x_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);
112 void et131x_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
113 void et131x_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
115 static const struct net_device_ops et131x_netdev_ops = {
116 .ndo_open = et131x_open,
117 .ndo_stop = et131x_close,
118 .ndo_start_xmit = et131x_tx,
119 .ndo_set_multicast_list = et131x_multicast,
120 .ndo_tx_timeout = et131x_tx_timeout,
121 .ndo_change_mtu = et131x_change_mtu,
122 .ndo_set_mac_address = et131x_set_mac_addr,
123 .ndo_validate_addr = eth_validate_addr,
124 .ndo_get_stats = et131x_stats,
125 .ndo_do_ioctl = et131x_ioctl,
129 * et131x_device_alloc
131 * Returns pointer to the allocated and initialized net_device struct for
134 * Create instances of net_device and wl_private for the new adapter and
135 * register the device's entry points in the net_device structure.
137 struct net_device *et131x_device_alloc(void)
139 struct net_device *netdev;
141 DBG_ENTER(et131x_dbginfo);
143 /* Alloc net_device and adapter structs */
144 netdev = alloc_etherdev(sizeof(struct et131x_adapter));
146 if (netdev == NULL) {
147 DBG_ERROR(et131x_dbginfo,
148 "Alloc of net_device struct failed\n");
149 DBG_LEAVE(et131x_dbginfo);
153 /* Setup the function registration table (and other data) for a
156 /* netdev->init = &et131x_init; */
157 /* netdev->set_config = &et131x_config; */
158 netdev->watchdog_timeo = ET131X_TX_TIMEOUT;
159 netdev->netdev_ops = &et131x_netdev_ops;
161 /* netdev->ethtool_ops = &et131x_ethtool_ops; */
164 /* netdev->poll = &et131x_poll; */
165 /* netdev->poll_controller = &et131x_poll_controller; */
167 DBG_LEAVE(et131x_dbginfo);
172 * et131x_stats - Return the current device statistics.
173 * @netdev: device whose stats are being queried
175 * Returns 0 on success, errno on failure (as defined in errno.h)
177 struct net_device_stats *et131x_stats(struct net_device *netdev)
179 struct et131x_adapter *adapter = netdev_priv(netdev);
180 struct net_device_stats *stats = &adapter->net_stats;
181 CE_STATS_t *devstat = &adapter->Stats;
183 DBG_ENTER(et131x_dbginfo);
185 stats->rx_packets = devstat->ipackets;
186 stats->tx_packets = devstat->opackets;
187 stats->rx_errors = devstat->length_err + devstat->alignment_err +
188 devstat->crc_err + devstat->code_violations + devstat->other_errors;
189 stats->tx_errors = devstat->max_pkt_error;
190 stats->multicast = devstat->multircv;
191 stats->collisions = devstat->collisions;
193 stats->rx_length_errors = devstat->length_err;
194 stats->rx_over_errors = devstat->rx_ov_flow;
195 stats->rx_crc_errors = devstat->crc_err;
197 /* NOTE: These stats don't have corresponding values in CE_STATS,
198 * so we're going to have to update these directly from within the
201 /* stats->rx_bytes = 20; devstat->; */
202 /* stats->tx_bytes = 20; devstat->; */
203 /* stats->rx_dropped = devstat->; */
204 /* stats->tx_dropped = devstat->; */
206 /* NOTE: Not used, can't find analogous statistics */
207 /* stats->rx_frame_errors = devstat->; */
208 /* stats->rx_fifo_errors = devstat->; */
209 /* stats->rx_missed_errors = devstat->; */
211 /* stats->tx_aborted_errors = devstat->; */
212 /* stats->tx_carrier_errors = devstat->; */
213 /* stats->tx_fifo_errors = devstat->; */
214 /* stats->tx_heartbeat_errors = devstat->; */
215 /* stats->tx_window_errors = devstat->; */
217 DBG_LEAVE(et131x_dbginfo);
222 * et131x_open - Open the device for use.
223 * @netdev: device to be opened
225 * Returns 0 on success, errno on failure (as defined in errno.h)
227 int et131x_open(struct net_device *netdev)
230 struct et131x_adapter *adapter = netdev_priv(netdev);
232 DBG_ENTER(et131x_dbginfo);
234 /* Start the timer to track NIC errors */
235 add_timer(&adapter->ErrorTimer);
237 /* Register our ISR */
238 DBG_TRACE(et131x_dbginfo, "Registering ISR...\n");
241 request_irq(netdev->irq, et131x_isr, IRQF_SHARED, netdev->name,
244 DBG_ERROR(et131x_dbginfo, "Could not register ISR\n");
245 DBG_LEAVE(et131x_dbginfo);
249 /* Enable the Tx and Rx DMA engines (if not already enabled) */
250 et131x_rx_dma_enable(adapter);
251 et131x_tx_dma_enable(adapter);
253 /* Enable device interrupts */
254 et131x_enable_interrupts(adapter);
256 MP_SET_FLAG(adapter, fMP_ADAPTER_INTERRUPT_IN_USE);
258 /* We're ready to move some data, so start the queue */
259 netif_start_queue(netdev);
261 DBG_LEAVE(et131x_dbginfo);
266 * et131x_close - Close the device
267 * @netdev: device to be closed
269 * Returns 0 on success, errno on failure (as defined in errno.h)
271 int et131x_close(struct net_device *netdev)
273 struct et131x_adapter *adapter = netdev_priv(netdev);
275 DBG_ENTER(et131x_dbginfo);
277 /* First thing is to stop the queue */
278 netif_stop_queue(netdev);
280 /* Stop the Tx and Rx DMA engines */
281 et131x_rx_dma_disable(adapter);
282 et131x_tx_dma_disable(adapter);
284 /* Disable device interrupts */
285 et131x_disable_interrupts(adapter);
287 /* Deregistering ISR */
288 MP_CLEAR_FLAG(adapter, fMP_ADAPTER_INTERRUPT_IN_USE);
290 DBG_TRACE(et131x_dbginfo, "Deregistering ISR...\n");
291 free_irq(netdev->irq, netdev);
293 /* Stop the error timer */
294 del_timer_sync(&adapter->ErrorTimer);
296 DBG_LEAVE(et131x_dbginfo);
301 * et131x_ioctl_mii - The function which handles MII IOCTLs
302 * @netdev: device on which the query is being made
303 * @reqbuf: the request-specific data buffer
304 * @cmd: the command request code
306 * Returns 0 on success, errno on failure (as defined in errno.h)
308 int et131x_ioctl_mii(struct net_device *netdev, struct ifreq *reqbuf, int cmd)
311 struct et131x_adapter *etdev = netdev_priv(netdev);
312 struct mii_ioctl_data *data = if_mii(reqbuf);
314 DBG_ENTER(et131x_dbginfo);
318 DBG_VERBOSE(et131x_dbginfo, "SIOCGMIIPHY\n");
319 data->phy_id = etdev->Stats.xcvr_addr;
323 DBG_VERBOSE(et131x_dbginfo, "SIOCGMIIREG\n");
324 if (!capable(CAP_NET_ADMIN)) {
327 status = MiRead(etdev,
328 data->reg_num, &data->val_out);
333 DBG_VERBOSE(et131x_dbginfo, "SIOCSMIIREG\n");
334 if (!capable(CAP_NET_ADMIN)) {
337 status = MiWrite(etdev, data->reg_num,
343 status = -EOPNOTSUPP;
346 DBG_LEAVE(et131x_dbginfo);
351 * et131x_ioctl - The I/O Control handler for the driver
352 * @netdev: device on which the control request is being made
353 * @reqbuf: a pointer to the IOCTL request buffer
354 * @cmd: the IOCTL command code
356 * Returns 0 on success, errno on failure (as defined in errno.h)
358 int et131x_ioctl(struct net_device *netdev, struct ifreq *reqbuf, int cmd)
362 DBG_ENTER(et131x_dbginfo);
368 status = et131x_ioctl_mii(netdev, reqbuf, cmd);
372 DBG_WARNING(et131x_dbginfo, "Unhandled IOCTL Code: 0x%04x\n",
374 status = -EOPNOTSUPP;
377 DBG_LEAVE(et131x_dbginfo);
382 * et131x_set_packet_filter - Configures the Rx Packet filtering on the device
383 * @adapter: pointer to our private adapter structure
385 * Returns 0 on success, errno on failure
387 int et131x_set_packet_filter(struct et131x_adapter *adapter)
390 uint32_t filter = adapter->PacketFilter;
392 RXMAC_PF_CTRL_t pf_ctrl;
394 DBG_ENTER(et131x_dbginfo);
396 ctrl.value = readl(&adapter->regs->rxmac.ctrl.value);
397 pf_ctrl.value = readl(&adapter->regs->rxmac.pf_ctrl.value);
399 /* Default to disabled packet filtering. Enable it in the individual
400 * case statements that require the device to filter something
402 ctrl.bits.pkt_filter_disable = 1;
404 /* Set us to be in promiscuous mode so we receive everything, this
405 * is also true when we get a packet filter of 0
407 if ((filter & ET131X_PACKET_TYPE_PROMISCUOUS) || filter == 0) {
408 pf_ctrl.bits.filter_broad_en = 0;
409 pf_ctrl.bits.filter_multi_en = 0;
410 pf_ctrl.bits.filter_uni_en = 0;
413 * Set us up with Multicast packet filtering. Three cases are
414 * possible - (1) we have a multi-cast list, (2) we receive ALL
415 * multicast entries or (3) we receive none.
417 if (filter & ET131X_PACKET_TYPE_ALL_MULTICAST) {
418 DBG_VERBOSE(et131x_dbginfo,
419 "Multicast filtering OFF (Rx ALL MULTICAST)\n");
420 pf_ctrl.bits.filter_multi_en = 0;
422 DBG_VERBOSE(et131x_dbginfo,
423 "Multicast filtering ON\n");
424 SetupDeviceForMulticast(adapter);
425 pf_ctrl.bits.filter_multi_en = 1;
426 ctrl.bits.pkt_filter_disable = 0;
429 /* Set us up with Unicast packet filtering */
430 if (filter & ET131X_PACKET_TYPE_DIRECTED) {
431 DBG_VERBOSE(et131x_dbginfo, "Unicast Filtering ON\n");
432 SetupDeviceForUnicast(adapter);
433 pf_ctrl.bits.filter_uni_en = 1;
434 ctrl.bits.pkt_filter_disable = 0;
437 /* Set us up with Broadcast packet filtering */
438 if (filter & ET131X_PACKET_TYPE_BROADCAST) {
439 DBG_VERBOSE(et131x_dbginfo, "Broadcast Filtering ON\n");
440 pf_ctrl.bits.filter_broad_en = 1;
441 ctrl.bits.pkt_filter_disable = 0;
443 DBG_VERBOSE(et131x_dbginfo,
444 "Broadcast Filtering OFF\n");
445 pf_ctrl.bits.filter_broad_en = 0;
448 /* Setup the receive mac configuration registers - Packet
449 * Filter control + the enable / disable for packet filter
450 * in the control reg.
452 writel(pf_ctrl.value,
453 &adapter->regs->rxmac.pf_ctrl.value);
454 writel(ctrl.value, &adapter->regs->rxmac.ctrl.value);
457 DBG_LEAVE(et131x_dbginfo);
462 * et131x_multicast - The handler to configure multicasting on the interface
463 * @netdev: a pointer to a net_device struct representing the device
465 void et131x_multicast(struct net_device *netdev)
467 struct et131x_adapter *adapter = netdev_priv(netdev);
468 uint32_t PacketFilter = 0;
471 struct dev_mc_list *mclist = netdev->mc_list;
473 DBG_ENTER(et131x_dbginfo);
475 spin_lock_irqsave(&adapter->Lock, flags);
477 /* Before we modify the platform-independent filter flags, store them
478 * locally. This allows us to determine if anything's changed and if
479 * we even need to bother the hardware
481 PacketFilter = adapter->PacketFilter;
483 /* Clear the 'multicast' flag locally; becuase we only have a single
484 * flag to check multicast, and multiple multicast addresses can be
485 * set, this is the easiest way to determine if more than one
486 * multicast address is being set.
488 PacketFilter &= ~ET131X_PACKET_TYPE_MULTICAST;
490 /* Check the net_device flags and set the device independent flags
493 DBG_VERBOSE(et131x_dbginfo,
494 "MULTICAST ADDR COUNT: %d\n", netdev->mc_count);
496 if (netdev->flags & IFF_PROMISC) {
497 DBG_VERBOSE(et131x_dbginfo, "Request: PROMISCUOUS MODE ON\n");
498 adapter->PacketFilter |= ET131X_PACKET_TYPE_PROMISCUOUS;
500 DBG_VERBOSE(et131x_dbginfo, "Request: PROMISCUOUS MODE OFF\n");
501 adapter->PacketFilter &= ~ET131X_PACKET_TYPE_PROMISCUOUS;
504 if (netdev->flags & IFF_ALLMULTI) {
505 DBG_VERBOSE(et131x_dbginfo, "Request: ACCEPT ALL MULTICAST\n");
506 adapter->PacketFilter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
509 if (netdev->mc_count > NIC_MAX_MCAST_LIST) {
510 DBG_WARNING(et131x_dbginfo,
511 "ACCEPT ALL MULTICAST for now, as there's more Multicast addresses than the HW supports\n");
512 adapter->PacketFilter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
515 if (netdev->mc_count < 1) {
516 DBG_VERBOSE(et131x_dbginfo, "Request: REJECT ALL MULTICAST\n");
517 adapter->PacketFilter &= ~ET131X_PACKET_TYPE_ALL_MULTICAST;
518 adapter->PacketFilter &= ~ET131X_PACKET_TYPE_MULTICAST;
520 DBG_VERBOSE(et131x_dbginfo,
521 "Request: SET MULTICAST FILTER(S)\n");
522 adapter->PacketFilter |= ET131X_PACKET_TYPE_MULTICAST;
525 /* Set values in the private adapter struct */
526 adapter->MCAddressCount = netdev->mc_count;
528 if (netdev->mc_count) {
529 if (mclist->dmi_addrlen != ETH_ALEN)
530 DBG_WARNING(et131x_dbginfo,
531 "Multicast addrs are not ETH_ALEN in size\n");
533 count = netdev->mc_count - 1;
534 memcpy(adapter->MCList[count], mclist->dmi_addr,
539 /* Are the new flags different from the previous ones? If not, then no
542 * NOTE - This block will always update the MCList with the hardware,
543 * even if the addresses aren't the same.
545 if (PacketFilter != adapter->PacketFilter) {
546 /* Call the device's filter function */
547 DBG_VERBOSE(et131x_dbginfo, "UPDATE REQUIRED, FLAGS changed\n");
549 et131x_set_packet_filter(adapter);
551 DBG_VERBOSE(et131x_dbginfo,
552 "NO UPDATE REQUIRED, FLAGS didn't change\n");
555 spin_unlock_irqrestore(&adapter->Lock, flags);
557 DBG_LEAVE(et131x_dbginfo);
561 * et131x_tx - The handler to tx a packet on the device
562 * @skb: data to be Tx'd
563 * @netdev: device on which data is to be Tx'd
565 * Returns 0 on success, errno on failure (as defined in errno.h)
567 int et131x_tx(struct sk_buff *skb, struct net_device *netdev)
571 DBG_TX_ENTER(et131x_dbginfo);
573 /* Save the timestamp for the TX timeout watchdog */
574 netdev->trans_start = jiffies;
576 /* Call the device-specific data Tx routine */
577 status = et131x_send_packets(skb, netdev);
579 /* Check status and manage the netif queue if necessary */
581 if (status == -ENOMEM) {
582 DBG_VERBOSE(et131x_dbginfo,
583 "OUT OF TCBs; STOP NETIF QUEUE\n");
585 /* Put the queue to sleep until resources are
588 netif_stop_queue(netdev);
589 status = NETDEV_TX_BUSY;
591 DBG_WARNING(et131x_dbginfo,
592 "Misc error; drop packet\n");
593 status = NETDEV_TX_OK;
597 DBG_TX_LEAVE(et131x_dbginfo);
602 * et131x_tx_timeout - Timeout handler
603 * @netdev: a pointer to a net_device struct representing the device
605 * The handler called when a Tx request times out. The timeout period is
606 * specified by the 'tx_timeo" element in the net_device structure (see
607 * et131x_alloc_device() to see how this value is set).
609 void et131x_tx_timeout(struct net_device *netdev)
611 struct et131x_adapter *etdev = netdev_priv(netdev);
615 DBG_WARNING(et131x_dbginfo, "TX TIMEOUT\n");
617 /* Just skip this part if the adapter is doing link detection */
618 if (MP_TEST_FLAG(etdev, fMP_ADAPTER_LINK_DETECTION)) {
619 DBG_ERROR(et131x_dbginfo, "Still doing link detection\n");
623 /* Any nonrecoverable hardware error?
624 * Checks adapter->flags for any failure in phy reading
626 if (MP_TEST_FLAG(etdev, fMP_ADAPTER_NON_RECOVER_ERROR)) {
627 DBG_WARNING(et131x_dbginfo, "Non recoverable error - remove\n");
631 /* Hardware failure? */
632 if (MP_TEST_FLAG(etdev, fMP_ADAPTER_HARDWARE_ERROR)) {
633 DBG_WARNING(et131x_dbginfo, "hardware error - reset\n");
638 spin_lock_irqsave(&etdev->TCBSendQLock, flags);
640 pMpTcb = etdev->TxRing.CurrSendHead;
642 if (pMpTcb != NULL) {
645 if (pMpTcb->Count > NIC_SEND_HANG_THRESHOLD) {
646 #ifdef CONFIG_ET131X_DEBUG
647 TX_STATUS_BLOCK_t txDmaComplete =
648 *(etdev->TxRing.pTxStatusVa);
649 PTX_DESC_ENTRY_t pDesc =
650 etdev->TxRing.pTxDescRingVa +
651 pMpTcb->WrIndex.bits.val;
653 TX_DESC_ENTRY_t StuckDescriptors[10];
655 if (pMpTcb->WrIndex.bits.val > 7) {
656 memcpy(StuckDescriptors,
657 etdev->TxRing.pTxDescRingVa +
658 pMpTcb->WrIndex.bits.val - 6,
659 sizeof(TX_DESC_ENTRY_t) * 10);
662 spin_unlock_irqrestore(&etdev->TCBSendQLock,
665 DBG_WARNING(et131x_dbginfo,
666 "Send stuck - reset. pMpTcb->WrIndex %x, Flags 0x%08x\n",
667 pMpTcb->WrIndex.bits.val,
670 DBG_WARNING(et131x_dbginfo,
671 "pDesc 0x%08x, 0x%08x, 0x%08x, 0x%08x\n",
672 pDesc->DataBufferPtrHigh,
673 pDesc->DataBufferPtrLow, pDesc->word2.value,
676 DBG_WARNING(et131x_dbginfo,
677 "WbStatus 0x%08x\n", txDmaComplete.value);
679 #ifdef CONFIG_ET131X_DEBUG
680 DumpDeviceBlock(DBG_WARNING_ON, etdev, 0);
681 DumpDeviceBlock(DBG_WARNING_ON, etdev, 1);
682 DumpDeviceBlock(DBG_WARNING_ON, etdev, 3);
683 DumpDeviceBlock(DBG_WARNING_ON, etdev, 5);
685 et131x_close(netdev);
692 spin_unlock_irqrestore(&etdev->TCBSendQLock, flags);
696 * et131x_change_mtu - The handler called to change the MTU for the device
697 * @netdev: device whose MTU is to be changed
698 * @new_mtu: the desired MTU
700 * Returns 0 on success, errno on failure (as defined in errno.h)
702 int et131x_change_mtu(struct net_device *netdev, int new_mtu)
705 struct et131x_adapter *adapter = netdev_priv(netdev);
707 DBG_ENTER(et131x_dbginfo);
709 /* Make sure the requested MTU is valid */
710 if (new_mtu == 0 || new_mtu > 9216) {
711 DBG_LEAVE(et131x_dbginfo);
715 /* Stop the netif queue */
716 netif_stop_queue(netdev);
718 /* Stop the Tx and Rx DMA engines */
719 et131x_rx_dma_disable(adapter);
720 et131x_tx_dma_disable(adapter);
722 /* Disable device interrupts */
723 et131x_disable_interrupts(adapter);
724 et131x_handle_send_interrupt(adapter);
725 et131x_handle_recv_interrupt(adapter);
727 /* Set the new MTU */
728 netdev->mtu = new_mtu;
730 /* Free Rx DMA memory */
731 et131x_adapter_memory_free(adapter);
733 /* Set the config parameter for Jumbo Packet support */
734 adapter->RegistryJumboPacket = new_mtu + 14;
735 et131x_soft_reset(adapter);
737 /* Alloc and init Rx DMA memory */
738 result = et131x_adapter_memory_alloc(adapter);
740 DBG_WARNING(et131x_dbginfo,
741 "Change MTU failed; couldn't re-alloc DMA memory\n");
745 et131x_init_send(adapter);
747 et131x_setup_hardware_properties(adapter);
748 memcpy(netdev->dev_addr, adapter->CurrentAddress, ETH_ALEN);
750 /* Init the device with the new settings */
751 et131x_adapter_setup(adapter);
753 /* Enable interrupts */
754 if (MP_TEST_FLAG(adapter, fMP_ADAPTER_INTERRUPT_IN_USE))
755 et131x_enable_interrupts(adapter);
757 /* Restart the Tx and Rx DMA engines */
758 et131x_rx_dma_enable(adapter);
759 et131x_tx_dma_enable(adapter);
761 /* Restart the netif queue */
762 netif_wake_queue(netdev);
764 DBG_LEAVE(et131x_dbginfo);
769 * et131x_set_mac_addr - handler to change the MAC address for the device
770 * @netdev: device whose MAC is to be changed
771 * @new_mac: the desired MAC address
773 * Returns 0 on success, errno on failure (as defined in errno.h)
775 * IMPLEMENTED BY : blux http://berndlux.de 22.01.2007 21:14
777 int et131x_set_mac_addr(struct net_device *netdev, void *new_mac)
780 struct et131x_adapter *adapter = netdev_priv(netdev);
781 struct sockaddr *address = new_mac;
783 DBG_ENTER(et131x_dbginfo);
785 /* DBG_VERBOSE( et131x_dbginfo, "Function not implemented!!\n" ); */
787 if (adapter == NULL) {
788 DBG_LEAVE(et131x_dbginfo);
792 /* Make sure the requested MAC is valid */
793 if (!is_valid_ether_addr(address->sa_data)) {
794 DBG_LEAVE(et131x_dbginfo);
798 /* Stop the netif queue */
799 netif_stop_queue(netdev);
801 /* Stop the Tx and Rx DMA engines */
802 et131x_rx_dma_disable(adapter);
803 et131x_tx_dma_disable(adapter);
805 /* Disable device interrupts */
806 et131x_disable_interrupts(adapter);
807 et131x_handle_send_interrupt(adapter);
808 et131x_handle_recv_interrupt(adapter);
810 /* Set the new MAC */
811 /* netdev->set_mac_address = &new_mac; */
812 /* netdev->mtu = new_mtu; */
814 memcpy(netdev->dev_addr, address->sa_data, netdev->addr_len);
817 "%s: Setting MAC address to %02x:%02x:%02x:%02x:%02x:%02x\n",
819 netdev->dev_addr[0], netdev->dev_addr[1],
820 netdev->dev_addr[2], netdev->dev_addr[3],
821 netdev->dev_addr[4], netdev->dev_addr[5]);
823 /* Free Rx DMA memory */
824 et131x_adapter_memory_free(adapter);
826 /* Set the config parameter for Jumbo Packet support */
827 /* adapter->RegistryJumboPacket = new_mtu + 14; */
828 /* blux: not needet here, we'll change the MAC */
830 et131x_soft_reset(adapter);
832 /* Alloc and init Rx DMA memory */
833 result = et131x_adapter_memory_alloc(adapter);
835 DBG_WARNING(et131x_dbginfo,
836 "Change MAC failed; couldn't re-alloc DMA memory\n");
840 et131x_init_send(adapter);
842 et131x_setup_hardware_properties(adapter);
843 /* memcpy( netdev->dev_addr, adapter->CurrentAddress, ETH_ALEN ); */
844 /* blux: no, do not override our nice address */
846 /* Init the device with the new settings */
847 et131x_adapter_setup(adapter);
849 /* Enable interrupts */
850 if (MP_TEST_FLAG(adapter, fMP_ADAPTER_INTERRUPT_IN_USE))
851 et131x_enable_interrupts(adapter);
853 /* Restart the Tx and Rx DMA engines */
854 et131x_rx_dma_enable(adapter);
855 et131x_tx_dma_enable(adapter);
857 /* Restart the netif queue */
858 netif_wake_queue(netdev);
860 DBG_LEAVE(et131x_dbginfo);