SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/et131x/et131x_netdev.c

   1 /*
   2  * Agere Systems Inc.
   3  * 10/100/1000 Base-T Ethernet Driver for the ET1301 and ET131x series MACs
   4  *
   5  * Copyright © 2005 Agere Systems Inc.
   6  * All rights reserved.
   7  *   http://www.agere.com
   8  *
   9  *------------------------------------------------------------------------------
  10  *
  11  * et131x_netdev.c - Routines and data required by all Linux network devices.
  12  *
  13  *------------------------------------------------------------------------------
  14  *
  15  * SOFTWARE LICENSE
  16  *
  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.
  21  *
  22  * Copyright © 2005 Agere Systems Inc.
  23  * All rights reserved.
  24  *
  25  * Redistribution and use in source or binary forms, with or without
  26  * modifications, are permitted provided that the following conditions are met:
  27  *
  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
  31  *    distribution.
  32  *
  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.
  36  *
  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.
  40  *
  41  * Disclaimer
  42  *
  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
  54  * DAMAGE.
  55  *
  56  */
  57
  58 #include "et131x_version.h"
  59 #include "et131x_defs.h"
  60
  61 #include <linux/init.h>
  62 #include <linux/module.h>
  63 #include <linux/types.h>
  64 #include <linux/kernel.h>
  65
  66 #include <linux/sched.h>
  67 #include <linux/ptrace.h>
  68 #include <linux/slab.h>
  69 #include <linux/ctype.h>
  70 #include <linux/string.h>
  71 #include <linux/timer.h>
  72 #include <linux/interrupt.h>
  73 #include <linux/in.h>
  74 #include <linux/delay.h>
  75 #include <linux/io.h>
  76 #include <linux/bitops.h>
  77 #include <linux/pci.h>
  78 #include <asm/system.h>
  79
  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>
  86
  87 #include "et1310_phy.h"
  88 #include "et1310_tx.h"
  89 #include "et131x_adapter.h"
  90 #include "et131x.h"
  91
  92 struct net_device_stats *et131x_stats(struct net_device *netdev);
  93 int et131x_open(struct net_device *netdev);
  94 int et131x_close(struct net_device *netdev);
  95 int et131x_ioctl(struct net_device *netdev, struct ifreq *reqbuf, int cmd);
  96 void et131x_multicast(struct net_device *netdev);
  97 int et131x_tx(struct sk_buff *skb, struct net_device *netdev);
  98 void et131x_tx_timeout(struct net_device *netdev);
  99 int et131x_change_mtu(struct net_device *netdev, int new_mtu);
 100 int et131x_set_mac_addr(struct net_device *netdev, void *new_mac);
 101 void et131x_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);
 102 void et131x_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
 103 void et131x_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
 104
 105 static const struct net_device_ops et131x_netdev_ops = {
 106         .ndo_open               = et131x_open,
 107         .ndo_stop               = et131x_close,
 108         .ndo_start_xmit         = et131x_tx,
 109         .ndo_set_multicast_list = et131x_multicast,
 110         .ndo_tx_timeout         = et131x_tx_timeout,
 111         .ndo_change_mtu         = et131x_change_mtu,
 112         .ndo_set_mac_address    = et131x_set_mac_addr,
 113         .ndo_validate_addr      = eth_validate_addr,
 114         .ndo_get_stats          = et131x_stats,
 115         .ndo_do_ioctl           = et131x_ioctl,
 116 };
 117
 118 /**
 119  * et131x_device_alloc
 120  *
 121  * Returns pointer to the allocated and initialized net_device struct for
 122  * this device.
 123  *
 124  * Create instances of net_device and wl_private for the new adapter and
 125  * register the device's entry points in the net_device structure.
 126  */
 127 struct net_device *et131x_device_alloc(void)
 128 {
 129         struct net_device *netdev;
 130
 131         /* Alloc net_device and adapter structs */
 132         netdev = alloc_etherdev(sizeof(struct et131x_adapter));
 133
 134         if (netdev == NULL) {
 135                 printk(KERN_ERR "et131x: Alloc of net_device struct failed\n");
 136                 return NULL;
 137         }
 138
 139         /* Setup the function registration table (and other data) for a
 140          * net_device
 141          */
 142         /* netdev->init               = &et131x_init; */
 143         /* netdev->set_config = &et131x_config; */
 144         netdev->watchdog_timeo = ET131X_TX_TIMEOUT;
 145         netdev->netdev_ops = &et131x_netdev_ops;
 146
 147         /* netdev->ethtool_ops        = &et131x_ethtool_ops; */
 148
 149         /* Poll? */
 150         /* netdev->poll               = &et131x_poll; */
 151         /* netdev->poll_controller    = &et131x_poll_controller; */
 152         return netdev;
 153 }
 154
 155 /**
 156  * et131x_stats - Return the current device statistics.
 157  * @netdev: device whose stats are being queried
 158  *
 159  * Returns 0 on success, errno on failure (as defined in errno.h)
 160  */
 161 struct net_device_stats *et131x_stats(struct net_device *netdev)
 162 {
 163         struct et131x_adapter *adapter = netdev_priv(netdev);
 164         struct net_device_stats *stats = &adapter->net_stats;
 165         CE_STATS_t *devstat = &adapter->Stats;
 166
 167         stats->rx_packets = devstat->ipackets;
 168         stats->tx_packets = devstat->opackets;
 169         stats->rx_errors = devstat->length_err + devstat->alignment_err +
 170             devstat->crc_err + devstat->code_violations + devstat->other_errors;
 171         stats->tx_errors = devstat->max_pkt_error;
 172         stats->multicast = devstat->multircv;
 173         stats->collisions = devstat->collisions;
 174
 175         stats->rx_length_errors = devstat->length_err;
 176         stats->rx_over_errors = devstat->rx_ov_flow;
 177         stats->rx_crc_errors = devstat->crc_err;
 178
 179         /* NOTE: These stats don't have corresponding values in CE_STATS,
 180          * so we're going to have to update these directly from within the
 181          * TX/RX code
 182          */
 183         /* stats->rx_bytes            = 20; devstat->; */
 184         /* stats->tx_bytes            = 20;  devstat->; */
 185         /* stats->rx_dropped          = devstat->; */
 186         /* stats->tx_dropped          = devstat->; */
 187
 188         /*  NOTE: Not used, can't find analogous statistics */
 189         /* stats->rx_frame_errors     = devstat->; */
 190         /* stats->rx_fifo_errors      = devstat->; */
 191         /* stats->rx_missed_errors    = devstat->; */
 192
 193         /* stats->tx_aborted_errors   = devstat->; */
 194         /* stats->tx_carrier_errors   = devstat->; */
 195         /* stats->tx_fifo_errors      = devstat->; */
 196         /* stats->tx_heartbeat_errors = devstat->; */
 197         /* stats->tx_window_errors    = devstat->; */
 198         return stats;
 199 }
 200
 201 /**
 202  * et131x_open - Open the device for use.
 203  * @netdev: device to be opened
 204  *
 205  * Returns 0 on success, errno on failure (as defined in errno.h)
 206  */
 207 int et131x_open(struct net_device *netdev)
 208 {
 209         int result = 0;
 210         struct et131x_adapter *adapter = netdev_priv(netdev);
 211
 212         /* Start the timer to track NIC errors */
 213         add_timer(&adapter->ErrorTimer);
 214
 215         /* Register our IRQ */
 216         result = request_irq(netdev->irq, et131x_isr, IRQF_SHARED,
 217                                         netdev->name, netdev);
 218         if (result) {
 219                 dev_err(&adapter->pdev->dev, "c ould not register IRQ %d\n",
 220                         netdev->irq);
 221                 return result;
 222         }
 223
 224         /* Enable the Tx and Rx DMA engines (if not already enabled) */
 225         et131x_rx_dma_enable(adapter);
 226         et131x_tx_dma_enable(adapter);
 227
 228         /* Enable device interrupts */
 229         et131x_enable_interrupts(adapter);
 230
 231         adapter->Flags |= fMP_ADAPTER_INTERRUPT_IN_USE;
 232
 233         /* We're ready to move some data, so start the queue */
 234         netif_start_queue(netdev);
 235         return result;
 236 }
 237
 238 /**
 239  * et131x_close - Close the device
 240  * @netdev: device to be closed
 241  *
 242  * Returns 0 on success, errno on failure (as defined in errno.h)
 243  */
 244 int et131x_close(struct net_device *netdev)
 245 {
 246         struct et131x_adapter *adapter = netdev_priv(netdev);
 247
 248         /* First thing is to stop the queue */
 249         netif_stop_queue(netdev);
 250
 251         /* Stop the Tx and Rx DMA engines */
 252         et131x_rx_dma_disable(adapter);
 253         et131x_tx_dma_disable(adapter);
 254
 255         /* Disable device interrupts */
 256         et131x_disable_interrupts(adapter);
 257
 258         /* Deregistering ISR */
 259         adapter->Flags &= ~fMP_ADAPTER_INTERRUPT_IN_USE;
 260         free_irq(netdev->irq, netdev);
 261
 262         /* Stop the error timer */
 263         del_timer_sync(&adapter->ErrorTimer);
 264         return 0;
 265 }
 266
 267 /**
 268  * et131x_ioctl_mii - The function which handles MII IOCTLs
 269  * @netdev: device on which the query is being made
 270  * @reqbuf: the request-specific data buffer
 271  * @cmd: the command request code
 272  *
 273  * Returns 0 on success, errno on failure (as defined in errno.h)
 274  */
 275 int et131x_ioctl_mii(struct net_device *netdev, struct ifreq *reqbuf, int cmd)
 276 {
 277         int status = 0;
 278         struct et131x_adapter *etdev = netdev_priv(netdev);
 279         struct mii_ioctl_data *data = if_mii(reqbuf);
 280
 281         switch (cmd) {
 282         case SIOCGMIIPHY:
 283                 data->phy_id = etdev->Stats.xcvr_addr;
 284                 break;
 285
 286         case SIOCGMIIREG:
 287                 if (!capable(CAP_NET_ADMIN))
 288                         status = -EPERM;
 289                 else
 290                         status = MiRead(etdev,
 291                                         data->reg_num, &data->val_out);
 292                 break;
 293
 294         case SIOCSMIIREG:
 295                 if (!capable(CAP_NET_ADMIN))
 296                         status = -EPERM;
 297                 else
 298                         status = MiWrite(etdev, data->reg_num,
 299                                          data->val_in);
 300                 break;
 301
 302         default:
 303                 status = -EOPNOTSUPP;
 304         }
 305         return status;
 306 }
 307
 308 /**
 309  * et131x_ioctl - The I/O Control handler for the driver
 310  * @netdev: device on which the control request is being made
 311  * @reqbuf: a pointer to the IOCTL request buffer
 312  * @cmd: the IOCTL command code
 313  *
 314  * Returns 0 on success, errno on failure (as defined in errno.h)
 315  */
 316 int et131x_ioctl(struct net_device *netdev, struct ifreq *reqbuf, int cmd)
 317 {
 318         int status = 0;
 319
 320         switch (cmd) {
 321         case SIOCGMIIPHY:
 322         case SIOCGMIIREG:
 323         case SIOCSMIIREG:
 324                 status = et131x_ioctl_mii(netdev, reqbuf, cmd);
 325                 break;
 326
 327         default:
 328                 status = -EOPNOTSUPP;
 329         }
 330         return status;
 331 }
 332
 333 /**
 334  * et131x_set_packet_filter - Configures the Rx Packet filtering on the device
 335  * @adapter: pointer to our private adapter structure
 336  *
 337  * FIXME: lot of dups with MAC code
 338  *
 339  * Returns 0 on success, errno on failure
 340  */
 341 int et131x_set_packet_filter(struct et131x_adapter *adapter)
 342 {
 343         int status = 0;
 344         uint32_t filter = adapter->PacketFilter;
 345         u32 ctrl;
 346         u32 pf_ctrl;
 347
 348         ctrl = readl(&adapter->regs->rxmac.ctrl);
 349         pf_ctrl = readl(&adapter->regs->rxmac.pf_ctrl);
 350
 351         /* Default to disabled packet filtering.  Enable it in the individual
 352          * case statements that require the device to filter something
 353          */
 354         ctrl |= 0x04;
 355
 356         /* Set us to be in promiscuous mode so we receive everything, this
 357          * is also true when we get a packet filter of 0
 358          */
 359         if ((filter & ET131X_PACKET_TYPE_PROMISCUOUS) || filter == 0)
 360                 pf_ctrl &= ~7;  /* Clear filter bits */
 361         else {
 362                 /*
 363                  * Set us up with Multicast packet filtering.  Three cases are
 364                  * possible - (1) we have a multi-cast list, (2) we receive ALL
 365                  * multicast entries or (3) we receive none.
 366                  */
 367                 if (filter & ET131X_PACKET_TYPE_ALL_MULTICAST)
 368                         pf_ctrl &= ~2;  /* Multicast filter bit */
 369                 else {
 370                         SetupDeviceForMulticast(adapter);
 371                         pf_ctrl |= 2;
 372                         ctrl &= ~0x04;
 373                 }
 374
 375                 /* Set us up with Unicast packet filtering */
 376                 if (filter & ET131X_PACKET_TYPE_DIRECTED) {
 377                         SetupDeviceForUnicast(adapter);
 378                         pf_ctrl |= 4;
 379                         ctrl &= ~0x04;
 380                 }
 381
 382                 /* Set us up with Broadcast packet filtering */
 383                 if (filter & ET131X_PACKET_TYPE_BROADCAST) {
 384                         pf_ctrl |= 1;   /* Broadcast filter bit */
 385                         ctrl &= ~0x04;
 386                 } else
 387                         pf_ctrl &= ~1;
 388
 389                 /* Setup the receive mac configuration registers - Packet
 390                  * Filter control + the enable / disable for packet filter
 391                  * in the control reg.
 392                  */
 393                 writel(pf_ctrl, &adapter->regs->rxmac.pf_ctrl);
 394                 writel(ctrl, &adapter->regs->rxmac.ctrl);
 395         }
 396         return status;
 397 }
 398
 399 /**
 400  * et131x_multicast - The handler to configure multicasting on the interface
 401  * @netdev: a pointer to a net_device struct representing the device
 402  */
 403 void et131x_multicast(struct net_device *netdev)
 404 {
 405         struct et131x_adapter *adapter = netdev_priv(netdev);
 406         uint32_t PacketFilter = 0;
 407         uint32_t count;
 408         unsigned long flags;
 409         struct dev_mc_list *mclist = netdev->mc_list;
 410
 411         spin_lock_irqsave(&adapter->Lock, flags);
 412
 413         /* Before we modify the platform-independent filter flags, store them
 414          * locally. This allows us to determine if anything's changed and if
 415          * we even need to bother the hardware
 416          */
 417         PacketFilter = adapter->PacketFilter;
 418
 419         /* Clear the 'multicast' flag locally; becuase we only have a single
 420          * flag to check multicast, and multiple multicast addresses can be
 421          * set, this is the easiest way to determine if more than one
 422          * multicast address is being set.
 423          */
 424         PacketFilter &= ~ET131X_PACKET_TYPE_MULTICAST;
 425
 426         /* Check the net_device flags and set the device independent flags
 427          * accordingly
 428          */
 429
 430         if (netdev->flags & IFF_PROMISC) {
 431                 adapter->PacketFilter |= ET131X_PACKET_TYPE_PROMISCUOUS;
 432         } else {
 433                 adapter->PacketFilter &= ~ET131X_PACKET_TYPE_PROMISCUOUS;
 434         }
 435
 436         if (netdev->flags & IFF_ALLMULTI) {
 437                 adapter->PacketFilter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
 438         }
 439
 440         if (netdev->mc_count > NIC_MAX_MCAST_LIST) {
 441                 adapter->PacketFilter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
 442         }
 443
 444         if (netdev->mc_count < 1) {
 445                 adapter->PacketFilter &= ~ET131X_PACKET_TYPE_ALL_MULTICAST;
 446                 adapter->PacketFilter &= ~ET131X_PACKET_TYPE_MULTICAST;
 447         } else {
 448                 adapter->PacketFilter |= ET131X_PACKET_TYPE_MULTICAST;
 449         }
 450
 451         /* Set values in the private adapter struct */
 452         adapter->MCAddressCount = netdev->mc_count;
 453
 454         if (netdev->mc_count) {
 455                 count = netdev->mc_count - 1;
 456                 memcpy(adapter->MCList[count], mclist->dmi_addr, ETH_ALEN);
 457         }
 458
 459         /* Are the new flags different from the previous ones? If not, then no
 460          * action is required
 461          *
 462          * NOTE - This block will always update the MCList with the hardware,
 463          *        even if the addresses aren't the same.
 464          */
 465         if (PacketFilter != adapter->PacketFilter) {
 466                 /* Call the device's filter function */
 467                 et131x_set_packet_filter(adapter);
 468         }
 469         spin_unlock_irqrestore(&adapter->Lock, flags);
 470 }
 471
 472 /**
 473  * et131x_tx - The handler to tx a packet on the device
 474  * @skb: data to be Tx'd
 475  * @netdev: device on which data is to be Tx'd
 476  *
 477  * Returns 0 on success, errno on failure (as defined in errno.h)
 478  */
 479 int et131x_tx(struct sk_buff *skb, struct net_device *netdev)
 480 {
 481         int status = 0;
 482
 483         /* Save the timestamp for the TX timeout watchdog */
 484         netdev->trans_start = jiffies;
 485
 486         /* Call the device-specific data Tx routine */
 487         status = et131x_send_packets(skb, netdev);
 488
 489         /* Check status and manage the netif queue if necessary */
 490         if (status != 0) {
 491                 if (status == -ENOMEM) {
 492                         /* Put the queue to sleep until resources are
 493                          * available
 494                          */
 495                         netif_stop_queue(netdev);
 496                         status = NETDEV_TX_BUSY;
 497                 } else {
 498                         status = NETDEV_TX_OK;
 499                 }
 500         }
 501         return status;
 502 }
 503
 504 /**
 505  * et131x_tx_timeout - Timeout handler
 506  * @netdev: a pointer to a net_device struct representing the device
 507  *
 508  * The handler called when a Tx request times out. The timeout period is
 509  * specified by the 'tx_timeo" element in the net_device structure (see
 510  * et131x_alloc_device() to see how this value is set).
 511  */
 512 void et131x_tx_timeout(struct net_device *netdev)
 513 {
 514         struct et131x_adapter *etdev = netdev_priv(netdev);
 515         struct tcb *tcb;
 516         unsigned long flags;
 517
 518         /* Just skip this part if the adapter is doing link detection */
 519         if (etdev->Flags & fMP_ADAPTER_LINK_DETECTION)
 520                 return;
 521
 522         /* Any nonrecoverable hardware error?
 523          * Checks adapter->flags for any failure in phy reading
 524          */
 525         if (etdev->Flags & fMP_ADAPTER_NON_RECOVER_ERROR)
 526                 return;
 527
 528         /* Hardware failure? */
 529         if (etdev->Flags & fMP_ADAPTER_HARDWARE_ERROR) {
 530                 dev_err(&etdev->pdev->dev, "hardware error - reset\n");
 531                 return;
 532         }
 533
 534         /* Is send stuck? */
 535         spin_lock_irqsave(&etdev->TCBSendQLock, flags);
 536
 537         tcb = etdev->tx_ring.send_head;
 538
 539         if (tcb != NULL) {
 540                 tcb->count++;
 541
 542                 if (tcb->count > NIC_SEND_HANG_THRESHOLD) {
 543                         spin_unlock_irqrestore(&etdev->TCBSendQLock,
 544                                                flags);
 545
 546                         dev_warn(&etdev->pdev->dev,
 547                                 "Send stuck - reset.  tcb->WrIndex %x, Flags 0x%08x\n",
 548                                 tcb->index,
 549                                 tcb->flags);
 550
 551                         et131x_close(netdev);
 552                         et131x_open(netdev);
 553
 554                         return;
 555                 }
 556         }
 557
 558         spin_unlock_irqrestore(&etdev->TCBSendQLock, flags);
 559 }
 560
 561 /**
 562  * et131x_change_mtu - The handler called to change the MTU for the device
 563  * @netdev: device whose MTU is to be changed
 564  * @new_mtu: the desired MTU
 565  *
 566  * Returns 0 on success, errno on failure (as defined in errno.h)
 567  */
 568 int et131x_change_mtu(struct net_device *netdev, int new_mtu)
 569 {
 570         int result = 0;
 571         struct et131x_adapter *adapter = netdev_priv(netdev);
 572
 573         /* Make sure the requested MTU is valid */
 574         if (new_mtu < 64 || new_mtu > 9216)
 575                 return -EINVAL;
 576
 577         /* Stop the netif queue */
 578         netif_stop_queue(netdev);
 579
 580         /* Stop the Tx and Rx DMA engines */
 581         et131x_rx_dma_disable(adapter);
 582         et131x_tx_dma_disable(adapter);
 583
 584         /* Disable device interrupts */
 585         et131x_disable_interrupts(adapter);
 586         et131x_handle_send_interrupt(adapter);
 587         et131x_handle_recv_interrupt(adapter);
 588
 589         /* Set the new MTU */
 590         netdev->mtu = new_mtu;
 591
 592         /* Free Rx DMA memory */
 593         et131x_adapter_memory_free(adapter);
 594
 595         /* Set the config parameter for Jumbo Packet support */
 596         adapter->RegistryJumboPacket = new_mtu + 14;
 597         et131x_soft_reset(adapter);
 598
 599         /* Alloc and init Rx DMA memory */
 600         result = et131x_adapter_memory_alloc(adapter);
 601         if (result != 0) {
 602                 dev_warn(&adapter->pdev->dev,
 603                         "Change MTU failed; couldn't re-alloc DMA memory\n");
 604                 return result;
 605         }
 606
 607         et131x_init_send(adapter);
 608
 609         et131x_hwaddr_init(adapter);
 610         memcpy(netdev->dev_addr, adapter->CurrentAddress, ETH_ALEN);
 611
 612         /* Init the device with the new settings */
 613         et131x_adapter_setup(adapter);
 614
 615         /* Enable interrupts */
 616         if (adapter->Flags & fMP_ADAPTER_INTERRUPT_IN_USE)
 617                 et131x_enable_interrupts(adapter);
 618
 619         /* Restart the Tx and Rx DMA engines */
 620         et131x_rx_dma_enable(adapter);
 621         et131x_tx_dma_enable(adapter);
 622
 623         /* Restart the netif queue */
 624         netif_wake_queue(netdev);
 625         return result;
 626 }
 627
 628 /**
 629  * et131x_set_mac_addr - handler to change the MAC address for the device
 630  * @netdev: device whose MAC is to be changed
 631  * @new_mac: the desired MAC address
 632  *
 633  * Returns 0 on success, errno on failure (as defined in errno.h)
 634  *
 635  * IMPLEMENTED BY : blux http://berndlux.de 22.01.2007 21:14
 636  */
 637 int et131x_set_mac_addr(struct net_device *netdev, void *new_mac)
 638 {
 639         int result = 0;
 640         struct et131x_adapter *adapter = netdev_priv(netdev);
 641         struct sockaddr *address = new_mac;
 642
 643         /* begin blux */
 644
 645         if (adapter == NULL)
 646                 return -ENODEV;
 647
 648         /* Make sure the requested MAC is valid */
 649         if (!is_valid_ether_addr(address->sa_data))
 650                 return -EINVAL;
 651
 652         /* Stop the netif queue */
 653         netif_stop_queue(netdev);
 654
 655         /* Stop the Tx and Rx DMA engines */
 656         et131x_rx_dma_disable(adapter);
 657         et131x_tx_dma_disable(adapter);
 658
 659         /* Disable device interrupts */
 660         et131x_disable_interrupts(adapter);
 661         et131x_handle_send_interrupt(adapter);
 662         et131x_handle_recv_interrupt(adapter);
 663
 664         /* Set the new MAC */
 665         /* netdev->set_mac_address  = &new_mac; */
 666         /* netdev->mtu = new_mtu; */
 667
 668         memcpy(netdev->dev_addr, address->sa_data, netdev->addr_len);
 669
 670         printk(KERN_INFO "%s: Setting MAC address to %pM\n",
 671                         netdev->name, netdev->dev_addr);
 672
 673         /* Free Rx DMA memory */
 674         et131x_adapter_memory_free(adapter);
 675
 676         /* Set the config parameter for Jumbo Packet support */
 677         /* adapter->RegistryJumboPacket = new_mtu + 14; */
 678         /* blux: not needet here, we'll change the MAC */
 679
 680         et131x_soft_reset(adapter);
 681
 682         /* Alloc and init Rx DMA memory */
 683         result = et131x_adapter_memory_alloc(adapter);
 684         if (result != 0) {
 685                 dev_err(&adapter->pdev->dev,
 686                         "Change MAC failed; couldn't re-alloc DMA memory\n");
 687                 return result;
 688         }
 689
 690         et131x_init_send(adapter);
 691
 692         et131x_hwaddr_init(adapter);
 693
 694         /* Init the device with the new settings */
 695         et131x_adapter_setup(adapter);
 696
 697         /* Enable interrupts */
 698         if (adapter->Flags & fMP_ADAPTER_INTERRUPT_IN_USE)
 699                 et131x_enable_interrupts(adapter);
 700
 701         /* Restart the Tx and Rx DMA engines */
 702         et131x_rx_dma_enable(adapter);
 703         et131x_tx_dma_enable(adapter);
 704
 705         /* Restart the netif queue */
 706         netif_wake_queue(netdev);
 707         return result;
 708 }