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_defs.h"
61 #include <linux/init.h>
62 #include <linux/module.h>
63 #include <linux/types.h>
64 #include <linux/kernel.h>
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>
74 #include <linux/delay.h>
76 #include <linux/bitops.h>
77 #include <linux/pci.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_tx.h"
89 #include "et131x_adapter.h"
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
);
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
,
119 * et131x_device_alloc
121 * Returns pointer to the allocated and initialized net_device struct for
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.
127 struct net_device
*et131x_device_alloc(void)
129 struct net_device
*netdev
;
131 /* Alloc net_device and adapter structs */
132 netdev
= alloc_etherdev(sizeof(struct et131x_adapter
));
134 if (netdev
== NULL
) {
135 printk(KERN_ERR
"et131x: Alloc of net_device struct failed\n");
139 /* Setup the function registration table (and other data) for a
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
;
147 /* netdev->ethtool_ops = &et131x_ethtool_ops; */
150 /* netdev->poll = &et131x_poll; */
151 /* netdev->poll_controller = &et131x_poll_controller; */
156 * et131x_stats - Return the current device statistics.
157 * @netdev: device whose stats are being queried
159 * Returns 0 on success, errno on failure (as defined in errno.h)
161 struct net_device_stats
*et131x_stats(struct net_device
*netdev
)
163 struct et131x_adapter
*adapter
= netdev_priv(netdev
);
164 struct net_device_stats
*stats
= &adapter
->net_stats
;
165 CE_STATS_t
*devstat
= &adapter
->Stats
;
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
;
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
;
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
183 /* stats->rx_bytes = 20; devstat->; */
184 /* stats->tx_bytes = 20; devstat->; */
185 /* stats->rx_dropped = devstat->; */
186 /* stats->tx_dropped = devstat->; */
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->; */
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->; */
202 * et131x_open - Open the device for use.
203 * @netdev: device to be opened
205 * Returns 0 on success, errno on failure (as defined in errno.h)
207 int et131x_open(struct net_device
*netdev
)
210 struct et131x_adapter
*adapter
= netdev_priv(netdev
);
212 /* Start the timer to track NIC errors */
213 add_timer(&adapter
->ErrorTimer
);
215 /* Register our IRQ */
216 result
= request_irq(netdev
->irq
, et131x_isr
, IRQF_SHARED
,
217 netdev
->name
, netdev
);
219 dev_err(&adapter
->pdev
->dev
, "c ould not register IRQ %d\n",
224 /* Enable the Tx and Rx DMA engines (if not already enabled) */
225 et131x_rx_dma_enable(adapter
);
226 et131x_tx_dma_enable(adapter
);
228 /* Enable device interrupts */
229 et131x_enable_interrupts(adapter
);
231 adapter
->Flags
|= fMP_ADAPTER_INTERRUPT_IN_USE
;
233 /* We're ready to move some data, so start the queue */
234 netif_start_queue(netdev
);
239 * et131x_close - Close the device
240 * @netdev: device to be closed
242 * Returns 0 on success, errno on failure (as defined in errno.h)
244 int et131x_close(struct net_device
*netdev
)
246 struct et131x_adapter
*adapter
= netdev_priv(netdev
);
248 /* First thing is to stop the queue */
249 netif_stop_queue(netdev
);
251 /* Stop the Tx and Rx DMA engines */
252 et131x_rx_dma_disable(adapter
);
253 et131x_tx_dma_disable(adapter
);
255 /* Disable device interrupts */
256 et131x_disable_interrupts(adapter
);
258 /* Deregistering ISR */
259 adapter
->Flags
&= ~fMP_ADAPTER_INTERRUPT_IN_USE
;
260 free_irq(netdev
->irq
, netdev
);
262 /* Stop the error timer */
263 del_timer_sync(&adapter
->ErrorTimer
);
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
273 * Returns 0 on success, errno on failure (as defined in errno.h)
275 int et131x_ioctl_mii(struct net_device
*netdev
, struct ifreq
*reqbuf
, int cmd
)
278 struct et131x_adapter
*etdev
= netdev_priv(netdev
);
279 struct mii_ioctl_data
*data
= if_mii(reqbuf
);
283 data
->phy_id
= etdev
->Stats
.xcvr_addr
;
287 if (!capable(CAP_NET_ADMIN
))
290 status
= MiRead(etdev
,
291 data
->reg_num
, &data
->val_out
);
295 if (!capable(CAP_NET_ADMIN
))
298 status
= MiWrite(etdev
, data
->reg_num
,
303 status
= -EOPNOTSUPP
;
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
314 * Returns 0 on success, errno on failure (as defined in errno.h)
316 int et131x_ioctl(struct net_device
*netdev
, struct ifreq
*reqbuf
, int cmd
)
324 status
= et131x_ioctl_mii(netdev
, reqbuf
, cmd
);
328 status
= -EOPNOTSUPP
;
334 * et131x_set_packet_filter - Configures the Rx Packet filtering on the device
335 * @adapter: pointer to our private adapter structure
337 * FIXME: lot of dups with MAC code
339 * Returns 0 on success, errno on failure
341 int et131x_set_packet_filter(struct et131x_adapter
*adapter
)
344 uint32_t filter
= adapter
->PacketFilter
;
348 ctrl
= readl(&adapter
->regs
->rxmac
.ctrl
);
349 pf_ctrl
= readl(&adapter
->regs
->rxmac
.pf_ctrl
);
351 /* Default to disabled packet filtering. Enable it in the individual
352 * case statements that require the device to filter something
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
359 if ((filter
& ET131X_PACKET_TYPE_PROMISCUOUS
) || filter
== 0)
360 pf_ctrl
&= ~7; /* Clear filter bits */
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.
367 if (filter
& ET131X_PACKET_TYPE_ALL_MULTICAST
)
368 pf_ctrl
&= ~2; /* Multicast filter bit */
370 SetupDeviceForMulticast(adapter
);
375 /* Set us up with Unicast packet filtering */
376 if (filter
& ET131X_PACKET_TYPE_DIRECTED
) {
377 SetupDeviceForUnicast(adapter
);
382 /* Set us up with Broadcast packet filtering */
383 if (filter
& ET131X_PACKET_TYPE_BROADCAST
) {
384 pf_ctrl
|= 1; /* Broadcast filter bit */
389 /* Setup the receive mac configuration registers - Packet
390 * Filter control + the enable / disable for packet filter
391 * in the control reg.
393 writel(pf_ctrl
, &adapter
->regs
->rxmac
.pf_ctrl
);
394 writel(ctrl
, &adapter
->regs
->rxmac
.ctrl
);
400 * et131x_multicast - The handler to configure multicasting on the interface
401 * @netdev: a pointer to a net_device struct representing the device
403 void et131x_multicast(struct net_device
*netdev
)
405 struct et131x_adapter
*adapter
= netdev_priv(netdev
);
406 uint32_t PacketFilter
= 0;
408 struct netdev_hw_addr
*ha
;
411 spin_lock_irqsave(&adapter
->Lock
, flags
);
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
417 PacketFilter
= adapter
->PacketFilter
;
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.
424 PacketFilter
&= ~ET131X_PACKET_TYPE_MULTICAST
;
426 /* Check the net_device flags and set the device independent flags
430 if (netdev
->flags
& IFF_PROMISC
) {
431 adapter
->PacketFilter
|= ET131X_PACKET_TYPE_PROMISCUOUS
;
433 adapter
->PacketFilter
&= ~ET131X_PACKET_TYPE_PROMISCUOUS
;
436 if (netdev
->flags
& IFF_ALLMULTI
) {
437 adapter
->PacketFilter
|= ET131X_PACKET_TYPE_ALL_MULTICAST
;
440 if (netdev_mc_count(netdev
) > NIC_MAX_MCAST_LIST
) {
441 adapter
->PacketFilter
|= ET131X_PACKET_TYPE_ALL_MULTICAST
;
444 if (netdev_mc_count(netdev
) < 1) {
445 adapter
->PacketFilter
&= ~ET131X_PACKET_TYPE_ALL_MULTICAST
;
446 adapter
->PacketFilter
&= ~ET131X_PACKET_TYPE_MULTICAST
;
448 adapter
->PacketFilter
|= ET131X_PACKET_TYPE_MULTICAST
;
451 /* Set values in the private adapter struct */
453 netdev_for_each_mc_addr(ha
, netdev
) {
454 if (i
== NIC_MAX_MCAST_LIST
)
456 memcpy(adapter
->MCList
[i
++], ha
->addr
, ETH_ALEN
);
458 adapter
->MCAddressCount
= i
;
460 /* Are the new flags different from the previous ones? If not, then no
463 * NOTE - This block will always update the MCList with the hardware,
464 * even if the addresses aren't the same.
466 if (PacketFilter
!= adapter
->PacketFilter
) {
467 /* Call the device's filter function */
468 et131x_set_packet_filter(adapter
);
470 spin_unlock_irqrestore(&adapter
->Lock
, flags
);
474 * et131x_tx - The handler to tx a packet on the device
475 * @skb: data to be Tx'd
476 * @netdev: device on which data is to be Tx'd
478 * Returns 0 on success, errno on failure (as defined in errno.h)
480 int et131x_tx(struct sk_buff
*skb
, struct net_device
*netdev
)
484 /* Save the timestamp for the TX timeout watchdog */
485 netdev
->trans_start
= jiffies
;
487 /* Call the device-specific data Tx routine */
488 status
= et131x_send_packets(skb
, netdev
);
490 /* Check status and manage the netif queue if necessary */
492 if (status
== -ENOMEM
) {
493 /* Put the queue to sleep until resources are
496 netif_stop_queue(netdev
);
497 status
= NETDEV_TX_BUSY
;
499 status
= NETDEV_TX_OK
;
506 * et131x_tx_timeout - Timeout handler
507 * @netdev: a pointer to a net_device struct representing the device
509 * The handler called when a Tx request times out. The timeout period is
510 * specified by the 'tx_timeo" element in the net_device structure (see
511 * et131x_alloc_device() to see how this value is set).
513 void et131x_tx_timeout(struct net_device
*netdev
)
515 struct et131x_adapter
*etdev
= netdev_priv(netdev
);
519 /* Just skip this part if the adapter is doing link detection */
520 if (etdev
->Flags
& fMP_ADAPTER_LINK_DETECTION
)
523 /* Any nonrecoverable hardware error?
524 * Checks adapter->flags for any failure in phy reading
526 if (etdev
->Flags
& fMP_ADAPTER_NON_RECOVER_ERROR
)
529 /* Hardware failure? */
530 if (etdev
->Flags
& fMP_ADAPTER_HARDWARE_ERROR
) {
531 dev_err(&etdev
->pdev
->dev
, "hardware error - reset\n");
536 spin_lock_irqsave(&etdev
->TCBSendQLock
, flags
);
538 tcb
= etdev
->tx_ring
.send_head
;
543 if (tcb
->count
> NIC_SEND_HANG_THRESHOLD
) {
544 spin_unlock_irqrestore(&etdev
->TCBSendQLock
,
547 dev_warn(&etdev
->pdev
->dev
,
548 "Send stuck - reset. tcb->WrIndex %x, Flags 0x%08x\n",
552 et131x_close(netdev
);
559 spin_unlock_irqrestore(&etdev
->TCBSendQLock
, flags
);
563 * et131x_change_mtu - The handler called to change the MTU for the device
564 * @netdev: device whose MTU is to be changed
565 * @new_mtu: the desired MTU
567 * Returns 0 on success, errno on failure (as defined in errno.h)
569 int et131x_change_mtu(struct net_device
*netdev
, int new_mtu
)
572 struct et131x_adapter
*adapter
= netdev_priv(netdev
);
574 /* Make sure the requested MTU is valid */
575 if (new_mtu
< 64 || new_mtu
> 9216)
578 /* Stop the netif queue */
579 netif_stop_queue(netdev
);
581 /* Stop the Tx and Rx DMA engines */
582 et131x_rx_dma_disable(adapter
);
583 et131x_tx_dma_disable(adapter
);
585 /* Disable device interrupts */
586 et131x_disable_interrupts(adapter
);
587 et131x_handle_send_interrupt(adapter
);
588 et131x_handle_recv_interrupt(adapter
);
590 /* Set the new MTU */
591 netdev
->mtu
= new_mtu
;
593 /* Free Rx DMA memory */
594 et131x_adapter_memory_free(adapter
);
596 /* Set the config parameter for Jumbo Packet support */
597 adapter
->RegistryJumboPacket
= new_mtu
+ 14;
598 et131x_soft_reset(adapter
);
600 /* Alloc and init Rx DMA memory */
601 result
= et131x_adapter_memory_alloc(adapter
);
603 dev_warn(&adapter
->pdev
->dev
,
604 "Change MTU failed; couldn't re-alloc DMA memory\n");
608 et131x_init_send(adapter
);
610 et131x_hwaddr_init(adapter
);
611 memcpy(netdev
->dev_addr
, adapter
->CurrentAddress
, ETH_ALEN
);
613 /* Init the device with the new settings */
614 et131x_adapter_setup(adapter
);
616 /* Enable interrupts */
617 if (adapter
->Flags
& fMP_ADAPTER_INTERRUPT_IN_USE
)
618 et131x_enable_interrupts(adapter
);
620 /* Restart the Tx and Rx DMA engines */
621 et131x_rx_dma_enable(adapter
);
622 et131x_tx_dma_enable(adapter
);
624 /* Restart the netif queue */
625 netif_wake_queue(netdev
);
630 * et131x_set_mac_addr - handler to change the MAC address for the device
631 * @netdev: device whose MAC is to be changed
632 * @new_mac: the desired MAC address
634 * Returns 0 on success, errno on failure (as defined in errno.h)
636 * IMPLEMENTED BY : blux http://berndlux.de 22.01.2007 21:14
638 int et131x_set_mac_addr(struct net_device
*netdev
, void *new_mac
)
641 struct et131x_adapter
*adapter
= netdev_priv(netdev
);
642 struct sockaddr
*address
= new_mac
;
649 /* Make sure the requested MAC is valid */
650 if (!is_valid_ether_addr(address
->sa_data
))
653 /* Stop the netif queue */
654 netif_stop_queue(netdev
);
656 /* Stop the Tx and Rx DMA engines */
657 et131x_rx_dma_disable(adapter
);
658 et131x_tx_dma_disable(adapter
);
660 /* Disable device interrupts */
661 et131x_disable_interrupts(adapter
);
662 et131x_handle_send_interrupt(adapter
);
663 et131x_handle_recv_interrupt(adapter
);
665 /* Set the new MAC */
666 /* netdev->set_mac_address = &new_mac; */
667 /* netdev->mtu = new_mtu; */
669 memcpy(netdev
->dev_addr
, address
->sa_data
, netdev
->addr_len
);
671 printk(KERN_INFO
"%s: Setting MAC address to %pM\n",
672 netdev
->name
, netdev
->dev_addr
);
674 /* Free Rx DMA memory */
675 et131x_adapter_memory_free(adapter
);
677 /* Set the config parameter for Jumbo Packet support */
678 /* adapter->RegistryJumboPacket = new_mtu + 14; */
679 /* blux: not needet here, we'll change the MAC */
681 et131x_soft_reset(adapter
);
683 /* Alloc and init Rx DMA memory */
684 result
= et131x_adapter_memory_alloc(adapter
);
686 dev_err(&adapter
->pdev
->dev
,
687 "Change MAC failed; couldn't re-alloc DMA memory\n");
691 et131x_init_send(adapter
);
693 et131x_hwaddr_init(adapter
);
695 /* Init the device with the new settings */
696 et131x_adapter_setup(adapter
);
698 /* Enable interrupts */
699 if (adapter
->Flags
& fMP_ADAPTER_INTERRUPT_IN_USE
)
700 et131x_enable_interrupts(adapter
);
702 /* Restart the Tx and Rx DMA engines */
703 et131x_rx_dma_enable(adapter
);
704 et131x_tx_dma_enable(adapter
);
706 /* Restart the netif queue */
707 netif_wake_queue(netdev
);