src/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 \93AS IS\94 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_debug.h"
  60 #include "et131x_defs.h"
  61
  62 #include <linux/init.h>
  63 #include <linux/module.h>
  64 #include <linux/types.h>
  65 #include <linux/kernel.h>
  66
  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>
  74 #include <linux/in.h>
  75 #include <linux/delay.h>
  76 #include <asm/io.h>
  77 #include <asm/system.h>
  78 #include <asm/bitops.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_pm.h"
  89 #include "et1310_jagcore.h"
  90 #include "et1310_mac.h"
  91 #include "et1310_tx.h"
  92
  93 #include "et131x_adapter.h"
  94 #include "et131x_isr.h"
  95 #include "et131x_initpci.h"
  96
  97 /* Data for debugging facilities */
  98 #ifdef CONFIG_ET131X_DEBUG
  99 extern dbg_info_t *et131x_dbginfo;
 100 #endif /* CONFIG_ET131X_DEBUG */
 101
 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);
 114
 115 /**
 116  * et131x_device_alloc
 117  *
 118  * Returns pointer to the allocated and initialized net_device struct for
 119  * this device.
 120  *
 121  * Create instances of net_device and wl_private for the new adapter and
 122  * register the device's entry points in the net_device structure.
 123  */
 124 struct net_device *et131x_device_alloc(void)
 125 {
 126         struct net_device *netdev;
 127
 128         DBG_ENTER(et131x_dbginfo);
 129
 130         /* Alloc net_device and adapter structs */
 131         netdev = alloc_etherdev(sizeof(struct et131x_adapter));
 132
 133         if (netdev == NULL) {
 134                 DBG_ERROR(et131x_dbginfo,
 135                           "Alloc of net_device struct failed\n");
 136                 DBG_LEAVE(et131x_dbginfo);
 137                 return NULL;
 138         }
 139
 140         /* Setup the function registration table (and other data) for a
 141          * net_device
 142          */
 143         //netdev->init               = &et131x_init;
 144         //netdev->set_config = &et131x_config;
 145         netdev->get_stats = &et131x_stats;
 146         netdev->open = &et131x_open;
 147         netdev->stop = &et131x_close;
 148         netdev->do_ioctl = &et131x_ioctl;
 149         netdev->set_multicast_list = &et131x_multicast;
 150         netdev->hard_start_xmit = &et131x_tx;
 151         netdev->tx_timeout = &et131x_tx_timeout;
 152         netdev->watchdog_timeo = ET131X_TX_TIMEOUT;
 153         netdev->change_mtu = &et131x_change_mtu;
 154         netdev->set_mac_address = &et131x_set_mac_addr;
 155
 156         //netdev->ethtool_ops        = &et131x_ethtool_ops;
 157
 158         // Poll?
 159         //netdev->poll               = &et131x_poll;
 160         //netdev->poll_controller    = &et131x_poll_controller;
 161
 162         DBG_LEAVE(et131x_dbginfo);
 163         return netdev;
 164 }
 165
 166 /**
 167  * et131x_stats - Return the current device statistics.
 168  * @netdev: device whose stats are being queried
 169  *
 170  * Returns 0 on success, errno on failure (as defined in errno.h)
 171  */
 172 struct net_device_stats *et131x_stats(struct net_device *netdev)
 173 {
 174         struct et131x_adapter *adapter = netdev_priv(netdev);
 175         struct net_device_stats *stats = &adapter->net_stats;
 176         CE_STATS_t *devstat = &adapter->Stats;
 177
 178         DBG_ENTER(et131x_dbginfo);
 179
 180         stats->rx_packets = devstat->ipackets;
 181         stats->tx_packets = devstat->opackets;
 182         stats->rx_errors = devstat->length_err + devstat->alignment_err +
 183             devstat->crc_err + devstat->code_violations + devstat->other_errors;
 184         stats->tx_errors = devstat->max_pkt_error;
 185         stats->multicast = devstat->multircv;
 186         stats->collisions = devstat->collisions;
 187
 188         stats->rx_length_errors = devstat->length_err;
 189         stats->rx_over_errors = devstat->rx_ov_flow;
 190         stats->rx_crc_errors = devstat->crc_err;
 191
 192         // NOTE: These stats don't have corresponding values in CE_STATS, so we're
 193         //       going to have to update these directly from within the TX/RX code
 194         //stats->rx_bytes            = 20; //devstat->;
 195         //stats->tx_bytes            = 20; //devstat->;
 196         //stats->rx_dropped          = devstat->;
 197         //stats->tx_dropped          = devstat->;
 198
 199         // NOTE: Not used, can't find analogous statistics
 200         //stats->rx_frame_errors     = devstat->;
 201         //stats->rx_fifo_errors      = devstat->;
 202         //stats->rx_missed_errors    = devstat->;
 203
 204         //stats->tx_aborted_errors   = devstat->;
 205         //stats->tx_carrier_errors   = devstat->;
 206         //stats->tx_fifo_errors      = devstat->;
 207         //stats->tx_heartbeat_errors = devstat->;
 208         //stats->tx_window_errors    = devstat->;
 209
 210         DBG_LEAVE(et131x_dbginfo);
 211         return stats;
 212 }
 213
 214 /**
 215  * et131x_open - Open the device for use.
 216  * @netdev: device to be opened
 217  *
 218  * Returns 0 on success, errno on failure (as defined in errno.h)
 219  */
 220 int et131x_open(struct net_device *netdev)
 221 {
 222         int result = 0;
 223         struct et131x_adapter *adapter = netdev_priv(netdev);
 224
 225         DBG_ENTER(et131x_dbginfo);
 226
 227         /* Start the timer to track NIC errors */
 228         add_timer(&adapter->ErrorTimer);
 229
 230         /* Register our ISR */
 231         DBG_TRACE(et131x_dbginfo, "Registering ISR...\n");
 232
 233         result =
 234             request_irq(netdev->irq, et131x_isr, IRQF_SHARED, netdev->name,
 235                         netdev);
 236         if (result) {
 237                 DBG_ERROR(et131x_dbginfo, "Could not register ISR\n");
 238                 DBG_LEAVE(et131x_dbginfo);
 239                 return result;
 240         }
 241
 242         /* Enable the Tx and Rx DMA engines (if not already enabled) */
 243         et131x_rx_dma_enable(adapter);
 244         et131x_tx_dma_enable(adapter);
 245
 246         /* Enable device interrupts */
 247         et131x_enable_interrupts(adapter);
 248
 249         MP_SET_FLAG(adapter, fMP_ADAPTER_INTERRUPT_IN_USE);
 250
 251         /* We're ready to move some data, so start the queue */
 252         netif_start_queue(netdev);
 253
 254         DBG_LEAVE(et131x_dbginfo);
 255         return result;
 256 }
 257
 258 /**
 259  * et131x_close - Close the device
 260  * @netdev: device to be closed
 261  *
 262  * Returns 0 on success, errno on failure (as defined in errno.h)
 263  */
 264 int et131x_close(struct net_device *netdev)
 265 {
 266         struct et131x_adapter *adapter = netdev_priv(netdev);
 267
 268         DBG_ENTER(et131x_dbginfo);
 269
 270         /* First thing is to stop the queue */
 271         netif_stop_queue(netdev);
 272
 273         /* Stop the Tx and Rx DMA engines */
 274         et131x_rx_dma_disable(adapter);
 275         et131x_tx_dma_disable(adapter);
 276
 277         /* Disable device interrupts */
 278         et131x_disable_interrupts(adapter);
 279
 280         /* Deregistering ISR */
 281         MP_CLEAR_FLAG(adapter, fMP_ADAPTER_INTERRUPT_IN_USE);
 282
 283         DBG_TRACE(et131x_dbginfo, "Deregistering ISR...\n");
 284         free_irq(netdev->irq, netdev);
 285
 286         /* Stop the error timer */
 287         del_timer_sync(&adapter->ErrorTimer);
 288
 289         DBG_LEAVE(et131x_dbginfo);
 290         return 0;
 291 }
 292
 293 /**
 294  * et131x_ioctl_mii - The function which handles MII IOCTLs
 295  * @netdev: device on which the query is being made
 296  * @reqbuf: the request-specific data buffer
 297  * @cmd: the command request code
 298  *
 299  * Returns 0 on success, errno on failure (as defined in errno.h)
 300  */
 301 int et131x_ioctl_mii(struct net_device *netdev, struct ifreq *reqbuf, int cmd)
 302 {
 303         int status = 0;
 304         struct et131x_adapter *pAdapter = netdev_priv(netdev);
 305         struct mii_ioctl_data *data = if_mii(reqbuf);
 306
 307         DBG_ENTER(et131x_dbginfo);
 308
 309         switch (cmd) {
 310         case SIOCGMIIPHY:
 311                 DBG_VERBOSE(et131x_dbginfo, "SIOCGMIIPHY\n");
 312                 data->phy_id = pAdapter->Stats.xcvr_addr;
 313                 break;
 314
 315         case SIOCGMIIREG:
 316                 DBG_VERBOSE(et131x_dbginfo, "SIOCGMIIREG\n");
 317                 if (!capable(CAP_NET_ADMIN)) {
 318                         status = -EPERM;
 319                 } else {
 320                         status = MiRead(pAdapter,
 321                                         data->reg_num, &data->val_out);
 322                 }
 323                 break;
 324
 325         case SIOCSMIIREG:
 326                 DBG_VERBOSE(et131x_dbginfo, "SIOCSMIIREG\n");
 327                 if (!capable(CAP_NET_ADMIN)) {
 328                         status = -EPERM;
 329                 } else {
 330                         status = MiWrite(pAdapter, data->reg_num,
 331                                          data->val_in);
 332                 }
 333                 break;
 334
 335         default:
 336                 status = -EOPNOTSUPP;
 337         }
 338
 339         DBG_LEAVE(et131x_dbginfo);
 340         return status;
 341 }
 342
 343 /**
 344  * et131x_ioctl - The I/O Control handler for the driver
 345  * @netdev: device on which the control request is being made
 346  * @reqbuf: a pointer to the IOCTL request buffer
 347  * @cmd: the IOCTL command code
 348  *
 349  * Returns 0 on success, errno on failure (as defined in errno.h)
 350  */
 351 int et131x_ioctl(struct net_device *netdev, struct ifreq *reqbuf, int cmd)
 352 {
 353         int status = 0;
 354
 355         DBG_ENTER(et131x_dbginfo);
 356
 357         switch (cmd) {
 358         case SIOCGMIIPHY:
 359         case SIOCGMIIREG:
 360         case SIOCSMIIREG:
 361                 status = et131x_ioctl_mii(netdev, reqbuf, cmd);
 362                 break;
 363
 364         default:
 365                 DBG_WARNING(et131x_dbginfo, "Unhandled IOCTL Code: 0x%04x\n",
 366                             cmd);
 367                 status = -EOPNOTSUPP;
 368         }
 369
 370         DBG_LEAVE(et131x_dbginfo);
 371         return status;
 372 }
 373
 374 /**
 375  * et131x_set_packet_filter - Configures the Rx Packet filtering on the device
 376  * @adapter: pointer to our private adapter structure
 377  *
 378  * Returns 0 on success, errno on failure
 379  */
 380 int et131x_set_packet_filter(struct et131x_adapter *adapter)
 381 {
 382         int status = 0;
 383         uint32_t filter = adapter->PacketFilter;
 384         RXMAC_CTRL_t ctrl;
 385         RXMAC_PF_CTRL_t pf_ctrl;
 386
 387         DBG_ENTER(et131x_dbginfo);
 388
 389         ctrl.value = readl(&adapter->CSRAddress->rxmac.ctrl.value);
 390         pf_ctrl.value = readl(&adapter->CSRAddress->rxmac.pf_ctrl.value);
 391
 392         /* Default to disabled packet filtering.  Enable it in the individual
 393          * case statements that require the device to filter something
 394          */
 395         ctrl.bits.pkt_filter_disable = 1;
 396
 397         /* Set us to be in promiscuous mode so we receive everything, this
 398          * is also true when we get a packet filter of 0
 399          */
 400         if ((filter & ET131X_PACKET_TYPE_PROMISCUOUS) || filter == 0) {
 401                 pf_ctrl.bits.filter_broad_en = 0;
 402                 pf_ctrl.bits.filter_multi_en = 0;
 403                 pf_ctrl.bits.filter_uni_en = 0;
 404         } else {
 405                 /*
 406                  * Set us up with Multicast packet filtering.  Three cases are
 407                  * possible - (1) we have a multi-cast list, (2) we receive ALL
 408                  * multicast entries or (3) we receive none.
 409                  */
 410                 if (filter & ET131X_PACKET_TYPE_ALL_MULTICAST) {
 411                         DBG_VERBOSE(et131x_dbginfo,
 412                                     "Multicast filtering OFF (Rx ALL MULTICAST)\n");
 413                         pf_ctrl.bits.filter_multi_en = 0;
 414                 } else {
 415                         DBG_VERBOSE(et131x_dbginfo, "Multicast filtering ON\n");
 416                         SetupDeviceForMulticast(adapter);
 417                         pf_ctrl.bits.filter_multi_en = 1;
 418                         ctrl.bits.pkt_filter_disable = 0;
 419                 }
 420
 421                 /* Set us up with Unicast packet filtering */
 422                 if (filter & ET131X_PACKET_TYPE_DIRECTED) {
 423                         DBG_VERBOSE(et131x_dbginfo, "Unicast Filtering ON\n");
 424                         SetupDeviceForUnicast(adapter);
 425                         pf_ctrl.bits.filter_uni_en = 1;
 426                         ctrl.bits.pkt_filter_disable = 0;
 427                 }
 428
 429                 /* Set us up with Broadcast packet filtering */
 430                 if (filter & ET131X_PACKET_TYPE_BROADCAST) {
 431                         DBG_VERBOSE(et131x_dbginfo, "Broadcast Filtering ON\n");
 432                         pf_ctrl.bits.filter_broad_en = 1;
 433                         ctrl.bits.pkt_filter_disable = 0;
 434                 } else {
 435                         DBG_VERBOSE(et131x_dbginfo,
 436                                     "Broadcast Filtering OFF\n");
 437                         pf_ctrl.bits.filter_broad_en = 0;
 438                 }
 439
 440                 /* Setup the receive mac configuration registers - Packet
 441                  * Filter control + the enable / disable for packet filter
 442                  * in the control reg.
 443                  */
 444                 writel(pf_ctrl.value,
 445                        &adapter->CSRAddress->rxmac.pf_ctrl.value);
 446                 writel(ctrl.value, &adapter->CSRAddress->rxmac.ctrl.value);
 447         }
 448
 449         DBG_LEAVE(et131x_dbginfo);
 450         return status;
 451 }
 452
 453 /**
 454  * et131x_multicast - The handler to configure multicasting on the interface
 455  * @netdev: a pointer to a net_device struct representing the device
 456  */
 457 void et131x_multicast(struct net_device *netdev)
 458 {
 459         struct et131x_adapter *adapter = netdev_priv(netdev);
 460         uint32_t PacketFilter = 0;
 461         uint32_t count;
 462         unsigned long lockflags;
 463         struct dev_mc_list *mclist = netdev->mc_list;
 464
 465         DBG_ENTER(et131x_dbginfo);
 466
 467         spin_lock_irqsave(&adapter->Lock, lockflags);
 468
 469         /* Before we modify the platform-independent filter flags, store them
 470          * locally. This allows us to determine if anything's changed and if
 471          * we even need to bother the hardware
 472          */
 473         PacketFilter = adapter->PacketFilter;
 474
 475         /* Clear the 'multicast' flag locally; becuase we only have a single
 476          * flag to check multicast, and multiple multicast addresses can be
 477          * set, this is the easiest way to determine if more than one
 478          * multicast address is being set.
 479          */
 480         PacketFilter &= ~ET131X_PACKET_TYPE_MULTICAST;
 481
 482         /* Check the net_device flags and set the device independent flags
 483          * accordingly
 484          */
 485         DBG_VERBOSE(et131x_dbginfo,
 486                     "MULTICAST ADDR COUNT: %d\n", netdev->mc_count);
 487
 488         if (netdev->flags & IFF_PROMISC) {
 489                 DBG_VERBOSE(et131x_dbginfo, "Request: PROMISCUOUS MODE ON\n");
 490                 adapter->PacketFilter |= ET131X_PACKET_TYPE_PROMISCUOUS;
 491         } else {
 492                 DBG_VERBOSE(et131x_dbginfo, "Request: PROMISCUOUS MODE OFF\n");
 493                 adapter->PacketFilter &= ~ET131X_PACKET_TYPE_PROMISCUOUS;
 494         }
 495
 496         if (netdev->flags & IFF_ALLMULTI) {
 497                 DBG_VERBOSE(et131x_dbginfo, "Request: ACCEPT ALL MULTICAST\n");
 498                 adapter->PacketFilter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
 499         }
 500
 501         if (netdev->mc_count > NIC_MAX_MCAST_LIST) {
 502                 DBG_WARNING(et131x_dbginfo,
 503                             "ACCEPT ALL MULTICAST for now, as there's more Multicast "
 504                             "addresses than the HW supports\n");
 505
 506                 adapter->PacketFilter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
 507         }
 508
 509         if (netdev->mc_count < 1) {
 510                 DBG_VERBOSE(et131x_dbginfo, "Request: REJECT ALL MULTICAST\n");
 511                 adapter->PacketFilter &= ~ET131X_PACKET_TYPE_ALL_MULTICAST;
 512                 adapter->PacketFilter &= ~ET131X_PACKET_TYPE_MULTICAST;
 513         } else {
 514                 DBG_VERBOSE(et131x_dbginfo,
 515                             "Request: SET MULTICAST FILTER(S)\n");
 516                 adapter->PacketFilter |= ET131X_PACKET_TYPE_MULTICAST;
 517         }
 518
 519         /* Set values in the private adapter struct */
 520         adapter->MCAddressCount = netdev->mc_count;
 521
 522         if (netdev->mc_count) {
 523                 if (mclist->dmi_addrlen != ETH_ALEN) {
 524                         DBG_WARNING(et131x_dbginfo,
 525                                     "Multicast addrs are not ETH_ALEN in size\n");
 526                 } else {
 527                         count = netdev->mc_count - 1;
 528                         memcpy(adapter->MCList[count], mclist->dmi_addr,
 529                                ETH_ALEN);
 530                 }
 531         }
 532
 533         /* Are the new flags different from the previous ones? If not, then no
 534          * action is required
 535          *
 536          * NOTE - This block will always update the MCList with the hardware,
 537          *        even if the addresses aren't the same.
 538          */
 539         if (PacketFilter != adapter->PacketFilter) {
 540                 /* Call the device's filter function */
 541                 DBG_VERBOSE(et131x_dbginfo, "UPDATE REQUIRED, FLAGS changed\n");
 542
 543                 et131x_set_packet_filter(adapter);
 544         } else {
 545                 DBG_VERBOSE(et131x_dbginfo,
 546                             "NO UPDATE REQUIRED, FLAGS didn't change\n");
 547         }
 548
 549         spin_unlock_irqrestore(&adapter->Lock, lockflags);
 550
 551         DBG_LEAVE(et131x_dbginfo);
 552 }
 553
 554 /**
 555  * et131x_tx - The handler to tx a packet on the device
 556  * @skb: data to be Tx'd
 557  * @netdev: device on which data is to be Tx'd
 558  *
 559  * Returns 0 on success, errno on failure (as defined in errno.h)
 560  */
 561 int et131x_tx(struct sk_buff *skb, struct net_device *netdev)
 562 {
 563         int status = 0;
 564
 565         DBG_TX_ENTER(et131x_dbginfo);
 566
 567         /* Save the timestamp for the TX timeout watchdog */
 568         netdev->trans_start = jiffies;
 569
 570         /* Call the device-specific data Tx routine */
 571         status = et131x_send_packets(skb, netdev);
 572
 573         /* Check status and manage the netif queue if necessary */
 574         if (status != 0) {
 575                 if (status == -ENOMEM) {
 576                         DBG_VERBOSE(et131x_dbginfo,
 577                                     "OUT OF TCBs; STOP NETIF QUEUE\n");
 578
 579                         /* Put the queue to sleep until resources are
 580                          * available
 581                          */
 582                         netif_stop_queue(netdev);
 583                         status = 1;
 584                 } else {
 585                         DBG_WARNING(et131x_dbginfo,
 586                                     "Misc error; drop packet\n");
 587                         status = 0;
 588                 }
 589         }
 590
 591         DBG_TX_LEAVE(et131x_dbginfo);
 592         return status;
 593 }
 594
 595 /**
 596  * et131x_tx_timeout - Timeout handler
 597  * @netdev: a pointer to a net_device struct representing the device
 598  *
 599  * The handler called when a Tx request times out. The timeout period is
 600  * specified by the 'tx_timeo" element in the net_device structure (see
 601  * et131x_alloc_device() to see how this value is set).
 602  */
 603 void et131x_tx_timeout(struct net_device *netdev)
 604 {
 605         struct et131x_adapter *pAdapter = netdev_priv(netdev);
 606         PMP_TCB pMpTcb;
 607         unsigned long lockflags;
 608
 609         DBG_WARNING(et131x_dbginfo, "TX TIMEOUT\n");
 610
 611         /* Just skip this part if the adapter is doing link detection */
 612         if (MP_TEST_FLAG(pAdapter, fMP_ADAPTER_LINK_DETECTION)) {
 613                 DBG_ERROR(et131x_dbginfo, "Still doing link detection\n");
 614                 return;
 615         }
 616
 617         /* Any nonrecoverable hardware error?
 618          * Checks adapter->flags for any failure in phy reading
 619          */
 620         if (MP_TEST_FLAG(pAdapter, fMP_ADAPTER_NON_RECOVER_ERROR)) {
 621                 DBG_WARNING(et131x_dbginfo, "Non recoverable error - remove\n");
 622                 return;
 623         }
 624
 625         /* Hardware failure? */
 626         if (MP_TEST_FLAG(pAdapter, fMP_ADAPTER_HARDWARE_ERROR)) {
 627                 DBG_WARNING(et131x_dbginfo, "hardware error - reset\n");
 628                 return;
 629         }
 630
 631         /* Is send stuck? */
 632         spin_lock_irqsave(&pAdapter->TCBSendQLock, lockflags);
 633
 634         pMpTcb = pAdapter->TxRing.CurrSendHead;
 635
 636         if (pMpTcb != NULL) {
 637                 pMpTcb->Count++;
 638
 639                 if (pMpTcb->Count > NIC_SEND_HANG_THRESHOLD) {
 640 #ifdef CONFIG_ET131X_DEBUG
 641                         TX_STATUS_BLOCK_t txDmaComplete =
 642                             *(pAdapter->TxRing.pTxStatusVa);
 643                         PTX_DESC_ENTRY_t pDesc =
 644                             pAdapter->TxRing.pTxDescRingVa +
 645                             pMpTcb->WrIndex.bits.val;
 646 #endif
 647                         TX_DESC_ENTRY_t StuckDescriptors[10];
 648
 649                         if (pMpTcb->WrIndex.bits.val > 7) {
 650                                 memcpy(StuckDescriptors,
 651                                        pAdapter->TxRing.pTxDescRingVa +
 652                                        pMpTcb->WrIndex.bits.val - 6,
 653                                        sizeof(TX_DESC_ENTRY_t) * 10);
 654                         }
 655
 656                         spin_unlock_irqrestore(&pAdapter->TCBSendQLock,
 657                                                lockflags);
 658
 659                         DBG_WARNING(et131x_dbginfo,
 660                                     "Send stuck - reset.  pMpTcb->WrIndex %x, Flags 0x%08x\n",
 661                                     pMpTcb->WrIndex.bits.val,
 662                                     pMpTcb->Flags);
 663
 664                         DBG_WARNING(et131x_dbginfo,
 665                                     "pDesc 0x%08x, 0x%08x, 0x%08x, 0x%08x\n",
 666                                     pDesc->DataBufferPtrHigh,
 667                                     pDesc->DataBufferPtrLow, pDesc->word2.value,
 668                                     pDesc->word3.value);
 669
 670                         DBG_WARNING(et131x_dbginfo,
 671                                     "WbStatus 0x%08x\n", txDmaComplete.value);
 672
 673 #ifdef CONFIG_ET131X_DEBUG
 674                         DumpDeviceBlock(DBG_WARNING_ON, pAdapter, 0);
 675                         DumpDeviceBlock(DBG_WARNING_ON, pAdapter, 1);
 676                         DumpDeviceBlock(DBG_WARNING_ON, pAdapter, 3);
 677                         DumpDeviceBlock(DBG_WARNING_ON, pAdapter, 5);
 678 #endif
 679                         et131x_close(netdev);
 680                         et131x_open(netdev);
 681
 682                         return;
 683                 }
 684         }
 685
 686         spin_unlock_irqrestore(&pAdapter->TCBSendQLock, lockflags);
 687 }
 688
 689 /**
 690  * et131x_change_mtu - The handler called to change the MTU for the device
 691  * @netdev: device whose MTU is to be changed
 692  * @new_mtu: the desired MTU
 693  *
 694  * Returns 0 on success, errno on failure (as defined in errno.h)
 695  */
 696 int et131x_change_mtu(struct net_device *netdev, int new_mtu)
 697 {
 698         int result = 0;
 699         struct et131x_adapter *adapter = netdev_priv(netdev);
 700
 701         DBG_ENTER(et131x_dbginfo);
 702
 703         /* Make sure the requested MTU is valid */
 704         if (new_mtu == 0 || new_mtu > 9216) {
 705                 DBG_LEAVE(et131x_dbginfo);
 706                 return -EINVAL;
 707         }
 708
 709         /* Stop the netif queue */
 710         netif_stop_queue(netdev);
 711
 712         /* Stop the Tx and Rx DMA engines */
 713         et131x_rx_dma_disable(adapter);
 714         et131x_tx_dma_disable(adapter);
 715
 716         /* Disable device interrupts */
 717         et131x_disable_interrupts(adapter);
 718         et131x_handle_send_interrupt(adapter);
 719         et131x_handle_recv_interrupt(adapter);
 720
 721         /* Set the new MTU */
 722         netdev->mtu = new_mtu;
 723
 724         /* Free Rx DMA memory */
 725         et131x_adapter_memory_free(adapter);
 726
 727         /* Set the config parameter for Jumbo Packet support */
 728         adapter->RegistryJumboPacket = new_mtu + 14;
 729         et131x_soft_reset(adapter);
 730
 731         /* Alloc and init Rx DMA memory */
 732         result = et131x_adapter_memory_alloc(adapter);
 733         if (result != 0) {
 734                 DBG_WARNING(et131x_dbginfo,
 735                             "Change MTU failed; couldn't re-alloc DMA memory\n");
 736                 return result;
 737         }
 738
 739         et131x_init_send(adapter);
 740
 741         et131x_setup_hardware_properties(adapter);
 742         memcpy(netdev->dev_addr, adapter->CurrentAddress, ETH_ALEN);
 743
 744         /* Init the device with the new settings */
 745         et131x_adapter_setup(adapter);
 746
 747         /* Enable interrupts */
 748         if (MP_TEST_FLAG(adapter, fMP_ADAPTER_INTERRUPT_IN_USE)) {
 749                 et131x_enable_interrupts(adapter);
 750         }
 751
 752         /* Restart the Tx and Rx DMA engines */
 753         et131x_rx_dma_enable(adapter);
 754         et131x_tx_dma_enable(adapter);
 755
 756         /* Restart the netif queue */
 757         netif_wake_queue(netdev);
 758
 759         DBG_LEAVE(et131x_dbginfo);
 760         return result;
 761 }
 762
 763 /**
 764  * et131x_set_mac_addr - handler to change the MAC address for the device
 765  * @netdev: device whose MAC is to be changed
 766  * @new_mac: the desired MAC address
 767  *
 768  * Returns 0 on success, errno on failure (as defined in errno.h)
 769  *
 770  * IMPLEMENTED BY : blux http://berndlux.de 22.01.2007 21:14
 771  */
 772 int et131x_set_mac_addr(struct net_device *netdev, void *new_mac)
 773 {
 774         int result = 0;
 775         struct et131x_adapter *adapter = netdev_priv(netdev);
 776         struct sockaddr *address = new_mac;
 777
 778         DBG_ENTER(et131x_dbginfo);
 779         // begin blux
 780         // DBG_VERBOSE( et131x_dbginfo, "Function not implemented!!\n" );
 781
 782         if (adapter == NULL) {
 783                 DBG_LEAVE(et131x_dbginfo);
 784                 return -ENODEV;
 785         }
 786
 787         /* Make sure the requested MAC is valid */
 788         if (!is_valid_ether_addr(address->sa_data)) {
 789                 DBG_LEAVE(et131x_dbginfo);
 790                 return -EINVAL;
 791         }
 792
 793         /* Stop the netif queue */
 794         netif_stop_queue(netdev);
 795
 796         /* Stop the Tx and Rx DMA engines */
 797         et131x_rx_dma_disable(adapter);
 798         et131x_tx_dma_disable(adapter);
 799
 800         /* Disable device interrupts */
 801         et131x_disable_interrupts(adapter);
 802         et131x_handle_send_interrupt(adapter);
 803         et131x_handle_recv_interrupt(adapter);
 804
 805         /* Set the new MAC */
 806         // netdev->set_mac_address  = &new_mac;
 807         // netdev->mtu = new_mtu;
 808
 809         memcpy(netdev->dev_addr, address->sa_data, netdev->addr_len);
 810
 811         printk("%s: Setting MAC address to %02x:%02x:%02x:%02x:%02x:%02x\n",
 812                netdev->name, netdev->dev_addr[0], netdev->dev_addr[1],
 813                netdev->dev_addr[2], netdev->dev_addr[3], netdev->dev_addr[4],
 814                netdev->dev_addr[5]);
 815
 816         /* Free Rx DMA memory */
 817         et131x_adapter_memory_free(adapter);
 818
 819         /* Set the config parameter for Jumbo Packet support */
 820         // adapter->RegistryJumboPacket = new_mtu + 14;
 821         // blux: not needet here, w'll change the MAC
 822
 823         et131x_soft_reset(adapter);
 824
 825         /* Alloc and init Rx DMA memory */
 826         result = et131x_adapter_memory_alloc(adapter);
 827         if (result != 0) {
 828                 DBG_WARNING(et131x_dbginfo,
 829                             "Change MAC failed; couldn't re-alloc DMA memory\n");
 830                 return result;
 831         }
 832
 833         et131x_init_send(adapter);
 834
 835         et131x_setup_hardware_properties(adapter);
 836         // memcpy( netdev->dev_addr, adapter->CurrentAddress, ETH_ALEN );
 837         // blux: no, do not override our nice address
 838
 839         /* Init the device with the new settings */
 840         et131x_adapter_setup(adapter);
 841
 842         /* Enable interrupts */
 843         if (MP_TEST_FLAG(adapter, fMP_ADAPTER_INTERRUPT_IN_USE)) {
 844                 et131x_enable_interrupts(adapter);
 845         }
 846
 847         /* Restart the Tx and Rx DMA engines */
 848         et131x_rx_dma_enable(adapter);
 849         et131x_tx_dma_enable(adapter);
 850
 851         /* Restart the netif queue */
 852         netif_wake_queue(netdev);
 853
 854         DBG_LEAVE(et131x_dbginfo);
 855         return result;
 856 }