drivers/staging/et131x/et131x_netdev.c

   1 /*
   2  * Agere Systems Inc.
   3  * 10/100/1000 Base-T Ethernet Driver for the ET1310 and ET131x series MACs
   4  *
   5  * Copyright © 2005 Agere Systems Inc.
   6  * All rights reserved.
   7  *   http://www.agere.com
   8  *
   9  * Copyright (c) 2011 Mark Einon <mark.einon@gmail.com>
  10  *
  11  *------------------------------------------------------------------------------
  12  *
  13  * et131x_netdev.c - Routines and data required by all Linux network devices.
  14  *
  15  *------------------------------------------------------------------------------
  16  *
  17  * SOFTWARE LICENSE
  18  *
  19  * This software is provided subject to the following terms and conditions,
  20  * which you should read carefully before using the software.  Using this
  21  * software indicates your acceptance of these terms and conditions.  If you do
  22  * not agree with these terms and conditions, do not use the software.
  23  *
  24  * Copyright © 2005 Agere Systems Inc.
  25  * All rights reserved.
  26  *
  27  * Redistribution and use in source or binary forms, with or without
  28  * modifications, are permitted provided that the following conditions are met:
  29  *
  30  * . Redistributions of source code must retain the above copyright notice, this
  31  *    list of conditions and the following Disclaimer as comments in the code as
  32  *    well as in the documentation and/or other materials provided with the
  33  *    distribution.
  34  *
  35  * . Redistributions in binary form must reproduce the above copyright notice,
  36  *    this list of conditions and the following Disclaimer in the documentation
  37  *    and/or other materials provided with the distribution.
  38  *
  39  * . Neither the name of Agere Systems Inc. nor the names of the contributors
  40  *    may be used to endorse or promote products derived from this software
  41  *    without specific prior written permission.
  42  *
  43  * Disclaimer
  44  *
  45  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  46  * INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
  47  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  ANY
  48  * USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
  49  * RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
  50  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  51  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  52  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  53  * ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
  54  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  55  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  56  * DAMAGE.
  57  *
  58  */
  59
  60 #include "et131x_version.h"
  61 #include "et131x_defs.h"
  62
  63 #include <linux/init.h>
  64 #include <linux/module.h>
  65 #include <linux/types.h>
  66 #include <linux/kernel.h>
  67
  68 #include <linux/sched.h>
  69 #include <linux/ptrace.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 <linux/io.h>
  77 #include <linux/bitops.h>
  78 #include <linux/pci.h>
  79 #include <asm/system.h>
  80
  81 #include <linux/mii.h>
  82 #include <linux/netdevice.h>
  83 #include <linux/etherdevice.h>
  84 #include <linux/skbuff.h>
  85 #include <linux/if_arp.h>
  86 #include <linux/ioport.h>
  87 #include <linux/phy.h>
  88
  89 #include "et1310_phy.h"
  90 #include "et1310_tx.h"
  91 #include "et131x_adapter.h"
  92 #include "et131x.h"
  93
  94 /**
  95  * et131x_stats - Return the current device statistics.
  96  * @netdev: device whose stats are being queried
  97  *
  98  * Returns 0 on success, errno on failure (as defined in errno.h)
  99  */
 100 static struct net_device_stats *et131x_stats(struct net_device *netdev)
 101 {
 102         struct et131x_adapter *adapter = netdev_priv(netdev);
 103         struct net_device_stats *stats = &adapter->net_stats;
 104         struct ce_stats *devstat = &adapter->stats;
 105
 106         stats->rx_errors = devstat->rx_length_errs +
 107                            devstat->rx_align_errs +
 108                            devstat->rx_crc_errs +
 109                            devstat->rx_code_violations +
 110                            devstat->rx_other_errs;
 111         stats->tx_errors = devstat->tx_max_pkt_errs;
 112         stats->multicast = devstat->multicast_pkts_rcvd;
 113         stats->collisions = devstat->tx_collisions;
 114
 115         stats->rx_length_errors = devstat->rx_length_errs;
 116         stats->rx_over_errors = devstat->rx_overflows;
 117         stats->rx_crc_errors = devstat->rx_crc_errs;
 118
 119         /* NOTE: These stats don't have corresponding values in CE_STATS,
 120          * so we're going to have to update these directly from within the
 121          * TX/RX code
 122          */
 123         /* stats->rx_bytes            = 20; devstat->; */
 124         /* stats->tx_bytes            = 20;  devstat->; */
 125         /* stats->rx_dropped          = devstat->; */
 126         /* stats->tx_dropped          = devstat->; */
 127
 128         /*  NOTE: Not used, can't find analogous statistics */
 129         /* stats->rx_frame_errors     = devstat->; */
 130         /* stats->rx_fifo_errors      = devstat->; */
 131         /* stats->rx_missed_errors    = devstat->; */
 132
 133         /* stats->tx_aborted_errors   = devstat->; */
 134         /* stats->tx_carrier_errors   = devstat->; */
 135         /* stats->tx_fifo_errors      = devstat->; */
 136         /* stats->tx_heartbeat_errors = devstat->; */
 137         /* stats->tx_window_errors    = devstat->; */
 138         return stats;
 139 }
 140
 141 /**
 142  * et131x_enable_txrx - Enable tx/rx queues
 143  * @netdev: device to be enabled
 144  */
 145 void et131x_enable_txrx(struct net_device *netdev)
 146 {
 147         struct et131x_adapter *adapter = netdev_priv(netdev);
 148
 149         /* Enable the Tx and Rx DMA engines (if not already enabled) */
 150         et131x_rx_dma_enable(adapter);
 151         et131x_tx_dma_enable(adapter);
 152
 153         /* Enable device interrupts */
 154         if (adapter->flags & fMP_ADAPTER_INTERRUPT_IN_USE)
 155                 et131x_enable_interrupts(adapter);
 156
 157         /* We're ready to move some data, so start the queue */
 158         netif_start_queue(netdev);
 159 }
 160
 161 /**
 162  * et131x_disable_txrx - Disable tx/rx queues
 163  * @netdev: device to be disabled
 164  */
 165 void et131x_disable_txrx(struct net_device *netdev)
 166 {
 167         struct et131x_adapter *adapter = netdev_priv(netdev);
 168
 169         /* First thing is to stop the queue */
 170         netif_stop_queue(netdev);
 171
 172         /* Stop the Tx and Rx DMA engines */
 173         et131x_rx_dma_disable(adapter);
 174         et131x_tx_dma_disable(adapter);
 175
 176         /* Disable device interrupts */
 177         et131x_disable_interrupts(adapter);
 178 }
 179
 180 /**
 181  * et131x_up - Bring up a device for use.
 182  * @netdev: device to be opened
 183  */
 184 void et131x_up(struct net_device *netdev)
 185 {
 186         struct et131x_adapter *adapter = netdev_priv(netdev);
 187
 188         et131x_enable_txrx(netdev);
 189         phy_start(adapter->phydev);
 190 }
 191
 192 /**
 193  * et131x_open - Open the device for use.
 194  * @netdev: device to be opened
 195  *
 196  * Returns 0 on success, errno on failure (as defined in errno.h)
 197  */
 198 int et131x_open(struct net_device *netdev)
 199 {
 200         int result = 0;
 201         struct et131x_adapter *adapter = netdev_priv(netdev);
 202
 203         /* Start the timer to track NIC errors */
 204         init_timer(&adapter->error_timer);
 205         adapter->error_timer.expires = jiffies + TX_ERROR_PERIOD * HZ / 1000;
 206         adapter->error_timer.function = et131x_error_timer_handler;
 207         adapter->error_timer.data = (unsigned long)adapter;
 208         add_timer(&adapter->error_timer);
 209
 210         /* Register our IRQ */
 211         result = request_irq(netdev->irq, et131x_isr, IRQF_SHARED,
 212                                         netdev->name, netdev);
 213         if (result) {
 214                 dev_err(&adapter->pdev->dev, "could not register IRQ %d\n",
 215                         netdev->irq);
 216                 return result;
 217         }
 218
 219         adapter->flags |= fMP_ADAPTER_INTERRUPT_IN_USE;
 220
 221         et131x_up(netdev);
 222
 223         return result;
 224 }
 225
 226 /**
 227  * et131x_down - Bring down the device
 228  * @netdev: device to be broght down
 229  */
 230 void et131x_down(struct net_device *netdev)
 231 {
 232         struct et131x_adapter *adapter = netdev_priv(netdev);
 233
 234         /* Save the timestamp for the TX watchdog, prevent a timeout */
 235         netdev->trans_start = jiffies;
 236
 237         phy_stop(adapter->phydev);
 238         et131x_disable_txrx(netdev);
 239 }
 240
 241 /**
 242  * et131x_close - Close the device
 243  * @netdev: device to be closed
 244  *
 245  * Returns 0 on success, errno on failure (as defined in errno.h)
 246  */
 247 int et131x_close(struct net_device *netdev)
 248 {
 249         struct et131x_adapter *adapter = netdev_priv(netdev);
 250
 251         et131x_down(netdev);
 252
 253         adapter->flags &= ~fMP_ADAPTER_INTERRUPT_IN_USE;
 254         free_irq(netdev->irq, netdev);
 255
 256         /* Stop the error timer */
 257         return del_timer_sync(&adapter->error_timer);
 258 }
 259
 260 /**
 261  * et131x_ioctl - The I/O Control handler for the driver
 262  * @netdev: device on which the control request is being made
 263  * @reqbuf: a pointer to the IOCTL request buffer
 264  * @cmd: the IOCTL command code
 265  *
 266  * Returns 0 on success, errno on failure (as defined in errno.h)
 267  */
 268 int et131x_ioctl(struct net_device *netdev, struct ifreq *reqbuf, int cmd)
 269 {
 270         struct et131x_adapter *adapter = netdev_priv(netdev);
 271
 272         if (!adapter->phydev)
 273                 return -EINVAL;
 274
 275         return phy_mii_ioctl(adapter->phydev, reqbuf, cmd);
 276 }
 277
 278 /**
 279  * et131x_set_packet_filter - Configures the Rx Packet filtering on the device
 280  * @adapter: pointer to our private adapter structure
 281  *
 282  * FIXME: lot of dups with MAC code
 283  *
 284  * Returns 0 on success, errno on failure
 285  */
 286 int et131x_set_packet_filter(struct et131x_adapter *adapter)
 287 {
 288         int status = 0;
 289         uint32_t filter = adapter->packet_filter;
 290         u32 ctrl;
 291         u32 pf_ctrl;
 292
 293         ctrl = readl(&adapter->regs->rxmac.ctrl);
 294         pf_ctrl = readl(&adapter->regs->rxmac.pf_ctrl);
 295
 296         /* Default to disabled packet filtering.  Enable it in the individual
 297          * case statements that require the device to filter something
 298          */
 299         ctrl |= 0x04;
 300
 301         /* Set us to be in promiscuous mode so we receive everything, this
 302          * is also true when we get a packet filter of 0
 303          */
 304         if ((filter & ET131X_PACKET_TYPE_PROMISCUOUS) || filter == 0)
 305                 pf_ctrl &= ~7;  /* Clear filter bits */
 306         else {
 307                 /*
 308                  * Set us up with Multicast packet filtering.  Three cases are
 309                  * possible - (1) we have a multi-cast list, (2) we receive ALL
 310                  * multicast entries or (3) we receive none.
 311                  */
 312                 if (filter & ET131X_PACKET_TYPE_ALL_MULTICAST)
 313                         pf_ctrl &= ~2;  /* Multicast filter bit */
 314                 else {
 315                         et1310_setup_device_for_multicast(adapter);
 316                         pf_ctrl |= 2;
 317                         ctrl &= ~0x04;
 318                 }
 319
 320                 /* Set us up with Unicast packet filtering */
 321                 if (filter & ET131X_PACKET_TYPE_DIRECTED) {
 322                         et1310_setup_device_for_unicast(adapter);
 323                         pf_ctrl |= 4;
 324                         ctrl &= ~0x04;
 325                 }
 326
 327                 /* Set us up with Broadcast packet filtering */
 328                 if (filter & ET131X_PACKET_TYPE_BROADCAST) {
 329                         pf_ctrl |= 1;   /* Broadcast filter bit */
 330                         ctrl &= ~0x04;
 331                 } else
 332                         pf_ctrl &= ~1;
 333
 334                 /* Setup the receive mac configuration registers - Packet
 335                  * Filter control + the enable / disable for packet filter
 336                  * in the control reg.
 337                  */
 338                 writel(pf_ctrl, &adapter->regs->rxmac.pf_ctrl);
 339                 writel(ctrl, &adapter->regs->rxmac.ctrl);
 340         }
 341         return status;
 342 }
 343
 344 /**
 345  * et131x_multicast - The handler to configure multicasting on the interface
 346  * @netdev: a pointer to a net_device struct representing the device
 347  */
 348 void et131x_multicast(struct net_device *netdev)
 349 {
 350         struct et131x_adapter *adapter = netdev_priv(netdev);
 351         uint32_t packet_filter = 0;
 352         unsigned long flags;
 353         struct netdev_hw_addr *ha;
 354         int i;
 355
 356         spin_lock_irqsave(&adapter->lock, flags);
 357
 358         /* Before we modify the platform-independent filter flags, store them
 359          * locally. This allows us to determine if anything's changed and if
 360          * we even need to bother the hardware
 361          */
 362         packet_filter = adapter->packet_filter;
 363
 364         /* Clear the 'multicast' flag locally; because we only have a single
 365          * flag to check multicast, and multiple multicast addresses can be
 366          * set, this is the easiest way to determine if more than one
 367          * multicast address is being set.
 368          */
 369         packet_filter &= ~ET131X_PACKET_TYPE_MULTICAST;
 370
 371         /* Check the net_device flags and set the device independent flags
 372          * accordingly
 373          */
 374
 375         if (netdev->flags & IFF_PROMISC)
 376                 adapter->packet_filter |= ET131X_PACKET_TYPE_PROMISCUOUS;
 377         else
 378                 adapter->packet_filter &= ~ET131X_PACKET_TYPE_PROMISCUOUS;
 379
 380         if (netdev->flags & IFF_ALLMULTI)
 381                 adapter->packet_filter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
 382
 383         if (netdev_mc_count(netdev) > NIC_MAX_MCAST_LIST)
 384                 adapter->packet_filter |= ET131X_PACKET_TYPE_ALL_MULTICAST;
 385
 386         if (netdev_mc_count(netdev) < 1) {
 387                 adapter->packet_filter &= ~ET131X_PACKET_TYPE_ALL_MULTICAST;
 388                 adapter->packet_filter &= ~ET131X_PACKET_TYPE_MULTICAST;
 389         } else
 390                 adapter->packet_filter |= ET131X_PACKET_TYPE_MULTICAST;
 391
 392         /* Set values in the private adapter struct */
 393         i = 0;
 394         netdev_for_each_mc_addr(ha, netdev) {
 395                 if (i == NIC_MAX_MCAST_LIST)
 396                         break;
 397                 memcpy(adapter->multicast_list[i++], ha->addr, ETH_ALEN);
 398         }
 399         adapter->multicast_addr_count = i;
 400
 401         /* Are the new flags different from the previous ones? If not, then no
 402          * action is required
 403          *
 404          * NOTE - This block will always update the multicast_list with the
 405          *        hardware, even if the addresses aren't the same.
 406          */
 407         if (packet_filter != adapter->packet_filter) {
 408                 /* Call the device's filter function */
 409                 et131x_set_packet_filter(adapter);
 410         }
 411         spin_unlock_irqrestore(&adapter->lock, flags);
 412 }
 413
 414 /**
 415  * et131x_tx - The handler to tx a packet on the device
 416  * @skb: data to be Tx'd
 417  * @netdev: device on which data is to be Tx'd
 418  *
 419  * Returns 0 on success, errno on failure (as defined in errno.h)
 420  */
 421 int et131x_tx(struct sk_buff *skb, struct net_device *netdev)
 422 {
 423         int status = 0;
 424
 425         /* Save the timestamp for the TX timeout watchdog */
 426         netdev->trans_start = jiffies;
 427
 428         /* Call the device-specific data Tx routine */
 429         status = et131x_send_packets(skb, netdev);
 430
 431         /* Check status and manage the netif queue if necessary */
 432         if (status != 0) {
 433                 if (status == -ENOMEM) {
 434                         /* Put the queue to sleep until resources are
 435                          * available
 436                          */
 437                         netif_stop_queue(netdev);
 438                         status = NETDEV_TX_BUSY;
 439                 } else {
 440                         status = NETDEV_TX_OK;
 441                 }
 442         }
 443         return status;
 444 }
 445
 446 /**
 447  * et131x_tx_timeout - Timeout handler
 448  * @netdev: a pointer to a net_device struct representing the device
 449  *
 450  * The handler called when a Tx request times out. The timeout period is
 451  * specified by the 'tx_timeo" element in the net_device structure (see
 452  * et131x_alloc_device() to see how this value is set).
 453  */
 454 void et131x_tx_timeout(struct net_device *netdev)
 455 {
 456         struct et131x_adapter *adapter = netdev_priv(netdev);
 457         struct tcb *tcb;
 458         unsigned long flags;
 459
 460         /* If the device is closed, ignore the timeout */
 461         if (~(adapter->flags & fMP_ADAPTER_INTERRUPT_IN_USE))
 462                 return;
 463
 464         /* Any nonrecoverable hardware error?
 465          * Checks adapter->flags for any failure in phy reading
 466          */
 467         if (adapter->flags & fMP_ADAPTER_NON_RECOVER_ERROR)
 468                 return;
 469
 470         /* Hardware failure? */
 471         if (adapter->flags & fMP_ADAPTER_HARDWARE_ERROR) {
 472                 dev_err(&adapter->pdev->dev, "hardware error - reset\n");
 473                 return;
 474         }
 475
 476         /* Is send stuck? */
 477         spin_lock_irqsave(&adapter->tcb_send_qlock, flags);
 478
 479         tcb = adapter->tx_ring.send_head;
 480
 481         if (tcb != NULL) {
 482                 tcb->count++;
 483
 484                 if (tcb->count > NIC_SEND_HANG_THRESHOLD) {
 485                         spin_unlock_irqrestore(&adapter->tcb_send_qlock,
 486                                                flags);
 487
 488                         dev_warn(&adapter->pdev->dev,
 489                                 "Send stuck - reset.  tcb->WrIndex %x, flags 0x%08x\n",
 490                                 tcb->index,
 491                                 tcb->flags);
 492
 493                         adapter->net_stats.tx_errors++;
 494
 495                         /* perform reset of tx/rx */
 496                         et131x_disable_txrx(netdev);
 497                         et131x_enable_txrx(netdev);
 498                         return;
 499                 }
 500         }
 501
 502         spin_unlock_irqrestore(&adapter->tcb_send_qlock, flags);
 503 }
 504
 505 /**
 506  * et131x_change_mtu - The handler called to change the MTU for the device
 507  * @netdev: device whose MTU is to be changed
 508  * @new_mtu: the desired MTU
 509  *
 510  * Returns 0 on success, errno on failure (as defined in errno.h)
 511  */
 512 int et131x_change_mtu(struct net_device *netdev, int new_mtu)
 513 {
 514         int result = 0;
 515         struct et131x_adapter *adapter = netdev_priv(netdev);
 516
 517         /* Make sure the requested MTU is valid */
 518         if (new_mtu < 64 || new_mtu > 9216)
 519                 return -EINVAL;
 520
 521         et131x_disable_txrx(netdev);
 522         et131x_handle_send_interrupt(adapter);
 523         et131x_handle_recv_interrupt(adapter);
 524
 525         /* Set the new MTU */
 526         netdev->mtu = new_mtu;
 527
 528         /* Free Rx DMA memory */
 529         et131x_adapter_memory_free(adapter);
 530
 531         /* Set the config parameter for Jumbo Packet support */
 532         adapter->registry_jumbo_packet = new_mtu + 14;
 533         et131x_soft_reset(adapter);
 534
 535         /* Alloc and init Rx DMA memory */
 536         result = et131x_adapter_memory_alloc(adapter);
 537         if (result != 0) {
 538                 dev_warn(&adapter->pdev->dev,
 539                         "Change MTU failed; couldn't re-alloc DMA memory\n");
 540                 return result;
 541         }
 542
 543         et131x_init_send(adapter);
 544
 545         et131x_hwaddr_init(adapter);
 546         memcpy(netdev->dev_addr, adapter->addr, ETH_ALEN);
 547
 548         /* Init the device with the new settings */
 549         et131x_adapter_setup(adapter);
 550
 551         et131x_enable_txrx(netdev);
 552
 553         return result;
 554 }
 555
 556 /**
 557  * et131x_set_mac_addr - handler to change the MAC address for the device
 558  * @netdev: device whose MAC is to be changed
 559  * @new_mac: the desired MAC address
 560  *
 561  * Returns 0 on success, errno on failure (as defined in errno.h)
 562  *
 563  * IMPLEMENTED BY : blux http://berndlux.de 22.01.2007 21:14
 564  */
 565 int et131x_set_mac_addr(struct net_device *netdev, void *new_mac)
 566 {
 567         int result = 0;
 568         struct et131x_adapter *adapter = netdev_priv(netdev);
 569         struct sockaddr *address = new_mac;
 570
 571         /* begin blux */
 572
 573         if (adapter == NULL)
 574                 return -ENODEV;
 575
 576         /* Make sure the requested MAC is valid */
 577         if (!is_valid_ether_addr(address->sa_data))
 578                 return -EINVAL;
 579
 580         et131x_disable_txrx(netdev);
 581         et131x_handle_send_interrupt(adapter);
 582         et131x_handle_recv_interrupt(adapter);
 583
 584         /* Set the new MAC */
 585         /* netdev->set_mac_address  = &new_mac; */
 586
 587         memcpy(netdev->dev_addr, address->sa_data, netdev->addr_len);
 588
 589         printk(KERN_INFO "%s: Setting MAC address to %pM\n",
 590                         netdev->name, netdev->dev_addr);
 591
 592         /* Free Rx DMA memory */
 593         et131x_adapter_memory_free(adapter);
 594
 595         et131x_soft_reset(adapter);
 596
 597         /* Alloc and init Rx DMA memory */
 598         result = et131x_adapter_memory_alloc(adapter);
 599         if (result != 0) {
 600                 dev_err(&adapter->pdev->dev,
 601                         "Change MAC failed; couldn't re-alloc DMA memory\n");
 602                 return result;
 603         }
 604
 605         et131x_init_send(adapter);
 606
 607         et131x_hwaddr_init(adapter);
 608
 609         /* Init the device with the new settings */
 610         et131x_adapter_setup(adapter);
 611
 612         et131x_enable_txrx(netdev);
 613
 614         return result;
 615 }
 616
 617 static const struct net_device_ops et131x_netdev_ops = {
 618         .ndo_open               = et131x_open,
 619         .ndo_stop               = et131x_close,
 620         .ndo_start_xmit         = et131x_tx,
 621         .ndo_set_multicast_list = et131x_multicast,
 622         .ndo_tx_timeout         = et131x_tx_timeout,
 623         .ndo_change_mtu         = et131x_change_mtu,
 624         .ndo_set_mac_address    = et131x_set_mac_addr,
 625         .ndo_validate_addr      = eth_validate_addr,
 626         .ndo_get_stats          = et131x_stats,
 627         .ndo_do_ioctl           = et131x_ioctl,
 628 };
 629
 630 /**
 631  * et131x_device_alloc
 632  *
 633  * Returns pointer to the allocated and initialized net_device struct for
 634  * this device.
 635  *
 636  * Create instances of net_device and wl_private for the new adapter and
 637  * register the device's entry points in the net_device structure.
 638  */
 639 struct net_device *et131x_device_alloc(void)
 640 {
 641         struct net_device *netdev;
 642
 643         /* Alloc net_device and adapter structs */
 644         netdev = alloc_etherdev(sizeof(struct et131x_adapter));
 645
 646         if (!netdev) {
 647                 printk(KERN_ERR "et131x: Alloc of net_device struct failed\n");
 648                 return NULL;
 649         }
 650
 651         /*
 652          * Setup the function registration table (and other data) for a
 653          * net_device
 654          */
 655         netdev->watchdog_timeo = ET131X_TX_TIMEOUT;
 656         netdev->netdev_ops     = &et131x_netdev_ops;
 657
 658         /* Poll? */
 659         /* netdev->poll               = &et131x_poll; */
 660         /* netdev->poll_controller    = &et131x_poll_controller; */
 661         return netdev;
 662 }
 663