drivers/net/mv643xx_eth.c

   1 /*
   2  * drivers/net/mv643xx_eth.c - Driver for MV643XX ethernet ports
   3  * Copyright (C) 2002 Matthew Dharm <mdharm@momenco.com>
   4  *
   5  * Based on the 64360 driver from:
   6  * Copyright (C) 2002 rabeeh@galileo.co.il
   7  *
   8  * Copyright (C) 2003 PMC-Sierra, Inc.,
   9  *      written by Manish Lachwani
  10  *
  11  * Copyright (C) 2003 Ralf Baechle <ralf@linux-mips.org>
  12  *
  13  * Copyright (C) 2004-2005 MontaVista Software, Inc.
  14  *                         Dale Farnsworth <dale@farnsworth.org>
  15  *
  16  * Copyright (C) 2004 Steven J. Hill <sjhill1@rockwellcollins.com>
  17  *                                   <sjhill@realitydiluted.com>
  18  *
  19  * This program is free software; you can redistribute it and/or
  20  * modify it under the terms of the GNU General Public License
  21  * as published by the Free Software Foundation; either version 2
  22  * of the License, or (at your option) any later version.
  23  *
  24  * This program is distributed in the hope that it will be useful,
  25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  * GNU General Public License for more details.
  28  *
  29  * You should have received a copy of the GNU General Public License
  30  * along with this program; if not, write to the Free Software
  31  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  32  */
  33 #include <linux/init.h>
  34 #include <linux/dma-mapping.h>
  35 #include <linux/in.h>
  36 #include <linux/ip.h>
  37 #include <linux/tcp.h>
  38 #include <linux/udp.h>
  39 #include <linux/etherdevice.h>
  40 #include <linux/in.h>
  41 #include <linux/ip.h>
  42
  43 #include <linux/bitops.h>
  44 #include <linux/delay.h>
  45 #include <linux/ethtool.h>
  46 #include <linux/platform_device.h>
  47
  48 #include <asm/io.h>
  49 #include <asm/types.h>
  50 #include <asm/pgtable.h>
  51 #include <asm/system.h>
  52 #include <asm/delay.h>
  53 #include "mv643xx_eth.h"
  54
  55 /*
  56  * The first part is the high level driver of the gigE ethernet ports.
  57  */
  58
  59 /* Constants */
  60 #define VLAN_HLEN               4
  61 #define FCS_LEN                 4
  62 #define DMA_ALIGN               8       /* hw requires 8-byte alignment */
  63 #define HW_IP_ALIGN             2       /* hw aligns IP header */
  64 #define WRAP                    HW_IP_ALIGN + ETH_HLEN + VLAN_HLEN + FCS_LEN
  65 #define RX_SKB_SIZE             ((dev->mtu + WRAP + 7) & ~0x7)
  66
  67 #define INT_UNMASK_ALL                  0x0007ffff
  68 #define INT_UNMASK_ALL_EXT              0x0011ffff
  69 #define INT_MASK_ALL                    0x00000000
  70 #define INT_MASK_ALL_EXT                0x00000000
  71 #define INT_CAUSE_CHECK_BITS            INT_CAUSE_UNMASK_ALL
  72 #define INT_CAUSE_CHECK_BITS_EXT        INT_CAUSE_UNMASK_ALL_EXT
  73
  74 #ifdef MV643XX_CHECKSUM_OFFLOAD_TX
  75 #define MAX_DESCS_PER_SKB       (MAX_SKB_FRAGS + 1)
  76 #else
  77 #define MAX_DESCS_PER_SKB       1
  78 #endif
  79
  80 #define PHY_WAIT_ITERATIONS     1000    /* 1000 iterations * 10uS = 10mS max */
  81 #define PHY_WAIT_MICRO_SECONDS  10
  82
  83 /* Static function declarations */
  84 static void eth_port_uc_addr_get(struct net_device *dev,
  85                                                 unsigned char *MacAddr);
  86 static void eth_port_set_multicast_list(struct net_device *);
  87 static void mv643xx_eth_port_enable_tx(unsigned int port_num,
  88                                                 unsigned int channels);
  89 static void mv643xx_eth_port_enable_rx(unsigned int port_num,
  90                                                 unsigned int channels);
  91 static unsigned int mv643xx_eth_port_disable_tx(unsigned int port_num);
  92 static unsigned int mv643xx_eth_port_disable_rx(unsigned int port_num);
  93 static int mv643xx_eth_open(struct net_device *);
  94 static int mv643xx_eth_stop(struct net_device *);
  95 static int mv643xx_eth_change_mtu(struct net_device *, int);
  96 static struct net_device_stats *mv643xx_eth_get_stats(struct net_device *);
  97 static void eth_port_init_mac_tables(unsigned int eth_port_num);
  98 #ifdef MV643XX_NAPI
  99 static int mv643xx_poll(struct net_device *dev, int *budget);
 100 #endif
 101 static int ethernet_phy_get(unsigned int eth_port_num);
 102 static void ethernet_phy_set(unsigned int eth_port_num, int phy_addr);
 103 static int ethernet_phy_detect(unsigned int eth_port_num);
 104 static int mv643xx_mdio_read(struct net_device *dev, int phy_id, int location);
 105 static void mv643xx_mdio_write(struct net_device *dev, int phy_id, int location, int val);
 106 static int mv643xx_eth_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
 107 static struct ethtool_ops mv643xx_ethtool_ops;
 108
 109 static char mv643xx_driver_name[] = "mv643xx_eth";
 110 static char mv643xx_driver_version[] = "1.0";
 111
 112 static void __iomem *mv643xx_eth_shared_base;
 113
 114 /* used to protect MV643XX_ETH_SMI_REG, which is shared across ports */
 115 static DEFINE_SPINLOCK(mv643xx_eth_phy_lock);
 116
 117 static inline u32 mv_read(int offset)
 118 {
 119         void __iomem *reg_base;
 120
 121         reg_base = mv643xx_eth_shared_base - MV643XX_ETH_SHARED_REGS;
 122
 123         return readl(reg_base + offset);
 124 }
 125
 126 static inline void mv_write(int offset, u32 data)
 127 {
 128         void __iomem *reg_base;
 129
 130         reg_base = mv643xx_eth_shared_base - MV643XX_ETH_SHARED_REGS;
 131         writel(data, reg_base + offset);
 132 }
 133
 134 /*
 135  * Changes MTU (maximum transfer unit) of the gigabit ethenret port
 136  *
 137  * Input :      pointer to ethernet interface network device structure
 138  *              new mtu size
 139  * Output :     0 upon success, -EINVAL upon failure
 140  */
 141 static int mv643xx_eth_change_mtu(struct net_device *dev, int new_mtu)
 142 {
 143         if ((new_mtu > 9500) || (new_mtu < 64))
 144                 return -EINVAL;
 145
 146         dev->mtu = new_mtu;
 147         /*
 148          * Stop then re-open the interface. This will allocate RX skb's with
 149          * the new MTU.
 150          * There is a possible danger that the open will not successed, due
 151          * to memory is full, which might fail the open function.
 152          */
 153         if (netif_running(dev)) {
 154                 mv643xx_eth_stop(dev);
 155                 if (mv643xx_eth_open(dev))
 156                         printk(KERN_ERR
 157                                 "%s: Fatal error on opening device\n",
 158                                 dev->name);
 159         }
 160
 161         return 0;
 162 }
 163
 164 /*
 165  * mv643xx_eth_rx_task
 166  *
 167  * Fills / refills RX queue on a certain gigabit ethernet port
 168  *
 169  * Input :      pointer to ethernet interface network device structure
 170  * Output :     N/A
 171  */
 172 static void mv643xx_eth_rx_task(void *data)
 173 {
 174         struct net_device *dev = (struct net_device *)data;
 175         struct mv643xx_private *mp = netdev_priv(dev);
 176         struct pkt_info pkt_info;
 177         struct sk_buff *skb;
 178         int unaligned;
 179
 180         if (test_and_set_bit(0, &mp->rx_task_busy))
 181                 panic("%s: Error in test_set_bit / clear_bit", dev->name);
 182
 183         while (mp->rx_desc_count < (mp->rx_ring_size - 5)) {
 184                 skb = dev_alloc_skb(RX_SKB_SIZE + DMA_ALIGN);
 185                 if (!skb)
 186                         break;
 187                 mp->rx_desc_count++;
 188                 unaligned = (u32)skb->data & (DMA_ALIGN - 1);
 189                 if (unaligned)
 190                         skb_reserve(skb, DMA_ALIGN - unaligned);
 191                 pkt_info.cmd_sts = ETH_RX_ENABLE_INTERRUPT;
 192                 pkt_info.byte_cnt = RX_SKB_SIZE;
 193                 pkt_info.buf_ptr = dma_map_single(NULL, skb->data, RX_SKB_SIZE,
 194                                                         DMA_FROM_DEVICE);
 195                 pkt_info.return_info = skb;
 196                 if (eth_rx_return_buff(mp, &pkt_info) != ETH_OK) {
 197                         printk(KERN_ERR
 198                                 "%s: Error allocating RX Ring\n", dev->name);
 199                         break;
 200                 }
 201                 skb_reserve(skb, HW_IP_ALIGN);
 202         }
 203         clear_bit(0, &mp->rx_task_busy);
 204         /*
 205          * If RX ring is empty of SKB, set a timer to try allocating
 206          * again in a later time .
 207          */
 208         if ((mp->rx_desc_count == 0) && (mp->rx_timer_flag == 0)) {
 209                 printk(KERN_INFO "%s: Rx ring is empty\n", dev->name);
 210                 /* After 100mSec */
 211                 mp->timeout.expires = jiffies + (HZ / 10);
 212                 add_timer(&mp->timeout);
 213                 mp->rx_timer_flag = 1;
 214         }
 215 #ifdef MV643XX_RX_QUEUE_FILL_ON_TASK
 216         else {
 217                 /* Return interrupts */
 218                 mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(mp->port_num),
 219                                                         INT_UNMASK_ALL);
 220         }
 221 #endif
 222 }
 223
 224 /*
 225  * mv643xx_eth_rx_task_timer_wrapper
 226  *
 227  * Timer routine to wake up RX queue filling task. This function is
 228  * used only in case the RX queue is empty, and all alloc_skb has
 229  * failed (due to out of memory event).
 230  *
 231  * Input :      pointer to ethernet interface network device structure
 232  * Output :     N/A
 233  */
 234 static void mv643xx_eth_rx_task_timer_wrapper(unsigned long data)
 235 {
 236         struct net_device *dev = (struct net_device *)data;
 237         struct mv643xx_private *mp = netdev_priv(dev);
 238
 239         mp->rx_timer_flag = 0;
 240         mv643xx_eth_rx_task((void *)data);
 241 }
 242
 243 /*
 244  * mv643xx_eth_update_mac_address
 245  *
 246  * Update the MAC address of the port in the address table
 247  *
 248  * Input :      pointer to ethernet interface network device structure
 249  * Output :     N/A
 250  */
 251 static void mv643xx_eth_update_mac_address(struct net_device *dev)
 252 {
 253         struct mv643xx_private *mp = netdev_priv(dev);
 254         unsigned int port_num = mp->port_num;
 255
 256         eth_port_init_mac_tables(port_num);
 257         eth_port_uc_addr_set(port_num, dev->dev_addr);
 258 }
 259
 260 /*
 261  * mv643xx_eth_set_rx_mode
 262  *
 263  * Change from promiscuos to regular rx mode
 264  *
 265  * Input :      pointer to ethernet interface network device structure
 266  * Output :     N/A
 267  */
 268 static void mv643xx_eth_set_rx_mode(struct net_device *dev)
 269 {
 270         struct mv643xx_private *mp = netdev_priv(dev);
 271         u32 config_reg;
 272
 273         config_reg = mv_read(MV643XX_ETH_PORT_CONFIG_REG(mp->port_num));
 274         if (dev->flags & IFF_PROMISC)
 275                 config_reg |= (u32) MV643XX_ETH_UNICAST_PROMISCUOUS_MODE;
 276         else
 277                 config_reg &= ~(u32) MV643XX_ETH_UNICAST_PROMISCUOUS_MODE;
 278         mv_write(MV643XX_ETH_PORT_CONFIG_REG(mp->port_num), config_reg);
 279
 280         eth_port_set_multicast_list(dev);
 281 }
 282
 283 /*
 284  * mv643xx_eth_set_mac_address
 285  *
 286  * Change the interface's mac address.
 287  * No special hardware thing should be done because interface is always
 288  * put in promiscuous mode.
 289  *
 290  * Input :      pointer to ethernet interface network device structure and
 291  *              a pointer to the designated entry to be added to the cache.
 292  * Output :     zero upon success, negative upon failure
 293  */
 294 static int mv643xx_eth_set_mac_address(struct net_device *dev, void *addr)
 295 {
 296         int i;
 297
 298         for (i = 0; i < 6; i++)
 299                 /* +2 is for the offset of the HW addr type */
 300                 dev->dev_addr[i] = ((unsigned char *)addr)[i + 2];
 301         mv643xx_eth_update_mac_address(dev);
 302         return 0;
 303 }
 304
 305 /*
 306  * mv643xx_eth_tx_timeout
 307  *
 308  * Called upon a timeout on transmitting a packet
 309  *
 310  * Input :      pointer to ethernet interface network device structure.
 311  * Output :     N/A
 312  */
 313 static void mv643xx_eth_tx_timeout(struct net_device *dev)
 314 {
 315         struct mv643xx_private *mp = netdev_priv(dev);
 316
 317         printk(KERN_INFO "%s: TX timeout  ", dev->name);
 318
 319         /* Do the reset outside of interrupt context */
 320         schedule_work(&mp->tx_timeout_task);
 321 }
 322
 323 /*
 324  * mv643xx_eth_tx_timeout_task
 325  *
 326  * Actual routine to reset the adapter when a timeout on Tx has occurred
 327  */
 328 static void mv643xx_eth_tx_timeout_task(struct net_device *dev)
 329 {
 330         struct mv643xx_private *mp = netdev_priv(dev);
 331
 332         netif_device_detach(dev);
 333         eth_port_reset(mp->port_num);
 334         eth_port_start(dev);
 335         netif_device_attach(dev);
 336 }
 337
 338 /*
 339  * mv643xx_eth_free_tx_queue
 340  *
 341  * Input :      dev - a pointer to the required interface
 342  *
 343  * Output :     0 if was able to release skb , nonzero otherwise
 344  */
 345 static int mv643xx_eth_free_tx_queue(struct net_device *dev,
 346                                         unsigned int eth_int_cause_ext)
 347 {
 348         struct mv643xx_private *mp = netdev_priv(dev);
 349         struct net_device_stats *stats = &mp->stats;
 350         struct pkt_info pkt_info;
 351         int released = 1;
 352
 353         if (!(eth_int_cause_ext & (BIT0 | BIT8)))
 354                 return released;
 355
 356         /* Check only queue 0 */
 357         while (eth_tx_return_desc(mp, &pkt_info) == ETH_OK) {
 358                 if (pkt_info.cmd_sts & BIT0) {
 359                         printk("%s: Error in TX\n", dev->name);
 360                         stats->tx_errors++;
 361                 }
 362
 363                 if (pkt_info.cmd_sts & ETH_TX_FIRST_DESC)
 364                         dma_unmap_single(NULL, pkt_info.buf_ptr,
 365                                         pkt_info.byte_cnt,
 366                                         DMA_TO_DEVICE);
 367                 else
 368                         dma_unmap_page(NULL, pkt_info.buf_ptr,
 369                                         pkt_info.byte_cnt,
 370                                         DMA_TO_DEVICE);
 371
 372                 if (pkt_info.return_info) {
 373                         dev_kfree_skb_irq(pkt_info.return_info);
 374                         released = 0;
 375                 }
 376         }
 377
 378         return released;
 379 }
 380
 381 /*
 382  * mv643xx_eth_receive
 383  *
 384  * This function is forward packets that are received from the port's
 385  * queues toward kernel core or FastRoute them to another interface.
 386  *
 387  * Input :      dev - a pointer to the required interface
 388  *              max - maximum number to receive (0 means unlimted)
 389  *
 390  * Output :     number of served packets
 391  */
 392 #ifdef MV643XX_NAPI
 393 static int mv643xx_eth_receive_queue(struct net_device *dev, int budget)
 394 #else
 395 static int mv643xx_eth_receive_queue(struct net_device *dev)
 396 #endif
 397 {
 398         struct mv643xx_private *mp = netdev_priv(dev);
 399         struct net_device_stats *stats = &mp->stats;
 400         unsigned int received_packets = 0;
 401         struct sk_buff *skb;
 402         struct pkt_info pkt_info;
 403
 404 #ifdef MV643XX_NAPI
 405         while (budget-- > 0 && eth_port_receive(mp, &pkt_info) == ETH_OK) {
 406 #else
 407         while (eth_port_receive(mp, &pkt_info) == ETH_OK) {
 408 #endif
 409                 mp->rx_desc_count--;
 410                 received_packets++;
 411
 412                 /* Update statistics. Note byte count includes 4 byte CRC count */
 413                 stats->rx_packets++;
 414                 stats->rx_bytes += pkt_info.byte_cnt;
 415                 skb = pkt_info.return_info;
 416                 /*
 417                  * In case received a packet without first / last bits on OR
 418                  * the error summary bit is on, the packets needs to be dropeed.
 419                  */
 420                 if (((pkt_info.cmd_sts
 421                                 & (ETH_RX_FIRST_DESC | ETH_RX_LAST_DESC)) !=
 422                                         (ETH_RX_FIRST_DESC | ETH_RX_LAST_DESC))
 423                                 || (pkt_info.cmd_sts & ETH_ERROR_SUMMARY)) {
 424                         stats->rx_dropped++;
 425                         if ((pkt_info.cmd_sts & (ETH_RX_FIRST_DESC |
 426                                                         ETH_RX_LAST_DESC)) !=
 427                                 (ETH_RX_FIRST_DESC | ETH_RX_LAST_DESC)) {
 428                                 if (net_ratelimit())
 429                                         printk(KERN_ERR
 430                                                 "%s: Received packet spread "
 431                                                 "on multiple descriptors\n",
 432                                                 dev->name);
 433                         }
 434                         if (pkt_info.cmd_sts & ETH_ERROR_SUMMARY)
 435                                 stats->rx_errors++;
 436
 437                         dev_kfree_skb_irq(skb);
 438                 } else {
 439                         /*
 440                          * The -4 is for the CRC in the trailer of the
 441                          * received packet
 442                          */
 443                         skb_put(skb, pkt_info.byte_cnt - 4);
 444                         skb->dev = dev;
 445
 446                         if (pkt_info.cmd_sts & ETH_LAYER_4_CHECKSUM_OK) {
 447                                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 448                                 skb->csum = htons(
 449                                         (pkt_info.cmd_sts & 0x0007fff8) >> 3);
 450                         }
 451                         skb->protocol = eth_type_trans(skb, dev);
 452 #ifdef MV643XX_NAPI
 453                         netif_receive_skb(skb);
 454 #else
 455                         netif_rx(skb);
 456 #endif
 457                 }
 458                 dev->last_rx = jiffies;
 459         }
 460
 461         return received_packets;
 462 }
 463
 464 /* Set the mv643xx port configuration register for the speed/duplex mode. */
 465 static void mv643xx_eth_update_pscr(struct net_device *dev,
 466                                     struct ethtool_cmd *ecmd)
 467 {
 468         struct mv643xx_private *mp = netdev_priv(dev);
 469         int port_num = mp->port_num;
 470         u32 o_pscr, n_pscr;
 471         unsigned int channels;
 472
 473         o_pscr = mv_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
 474         n_pscr = o_pscr;
 475
 476         /* clear speed, duplex and rx buffer size fields */
 477         n_pscr &= ~(MV643XX_ETH_SET_MII_SPEED_TO_100  |
 478                    MV643XX_ETH_SET_GMII_SPEED_TO_1000 |
 479                    MV643XX_ETH_SET_FULL_DUPLEX_MODE   |
 480                    MV643XX_ETH_MAX_RX_PACKET_MASK);
 481
 482         if (ecmd->duplex == DUPLEX_FULL)
 483                 n_pscr |= MV643XX_ETH_SET_FULL_DUPLEX_MODE;
 484
 485         if (ecmd->speed == SPEED_1000)
 486                 n_pscr |= MV643XX_ETH_SET_GMII_SPEED_TO_1000 |
 487                           MV643XX_ETH_MAX_RX_PACKET_9700BYTE;
 488         else {
 489                 if (ecmd->speed == SPEED_100)
 490                         n_pscr |= MV643XX_ETH_SET_MII_SPEED_TO_100;
 491                 n_pscr |= MV643XX_ETH_MAX_RX_PACKET_1522BYTE;
 492         }
 493
 494         if (n_pscr != o_pscr) {
 495                 if ((o_pscr & MV643XX_ETH_SERIAL_PORT_ENABLE) == 0)
 496                         mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num),
 497                                                                 n_pscr);
 498                 else {
 499                         channels = mv643xx_eth_port_disable_tx(port_num);
 500
 501                         o_pscr &= ~MV643XX_ETH_SERIAL_PORT_ENABLE;
 502                         mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num),
 503                                                                 o_pscr);
 504                         mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num),
 505                                                                 n_pscr);
 506                         mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num),
 507                                                                 n_pscr);
 508                         if (channels)
 509                                 mv643xx_eth_port_enable_tx(port_num, channels);
 510                 }
 511         }
 512 }
 513
 514 /*
 515  * mv643xx_eth_int_handler
 516  *
 517  * Main interrupt handler for the gigbit ethernet ports
 518  *
 519  * Input :      irq     - irq number (not used)
 520  *              dev_id  - a pointer to the required interface's data structure
 521  *              regs    - not used
 522  * Output :     N/A
 523  */
 524
 525 static irqreturn_t mv643xx_eth_int_handler(int irq, void *dev_id,
 526                                                 struct pt_regs *regs)
 527 {
 528         struct net_device *dev = (struct net_device *)dev_id;
 529         struct mv643xx_private *mp = netdev_priv(dev);
 530         u32 eth_int_cause, eth_int_cause_ext = 0;
 531         unsigned int port_num = mp->port_num;
 532
 533         /* Read interrupt cause registers */
 534         eth_int_cause = mv_read(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num)) &
 535                                                 INT_UNMASK_ALL;
 536
 537         if (eth_int_cause & BIT1)
 538                 eth_int_cause_ext = mv_read(
 539                         MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG(port_num)) &
 540                                                 INT_UNMASK_ALL_EXT;
 541
 542 #ifdef MV643XX_NAPI
 543         if (!(eth_int_cause & 0x0007fffd)) {
 544                 /* Dont ack the Rx interrupt */
 545 #endif
 546                 /*
 547                  * Clear specific ethernet port intrerrupt registers by
 548                  * acknowleding relevant bits.
 549                  */
 550                 mv_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num),
 551                                                         ~eth_int_cause);
 552                 if (eth_int_cause_ext != 0x0)
 553                         mv_write(MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG
 554                                         (port_num), ~eth_int_cause_ext);
 555
 556                 /* UDP change : We may need this */
 557                 if ((eth_int_cause_ext & 0x0000ffff) &&
 558                     (mv643xx_eth_free_tx_queue(dev, eth_int_cause_ext) == 0) &&
 559                     (mp->tx_ring_size > mp->tx_desc_count + MAX_DESCS_PER_SKB))
 560                         netif_wake_queue(dev);
 561 #ifdef MV643XX_NAPI
 562         } else {
 563                 if (netif_rx_schedule_prep(dev)) {
 564                         /* Mask all the interrupts */
 565                         mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num),
 566                                                                 INT_MASK_ALL);
 567                         /* wait for previous write to complete */
 568                         mv_read(MV643XX_ETH_INTERRUPT_MASK_REG(port_num));
 569                         __netif_rx_schedule(dev);
 570                 }
 571 #else
 572                 if (eth_int_cause & (BIT2 | BIT11))
 573                         mv643xx_eth_receive_queue(dev, 0);
 574
 575                 /*
 576                  * After forwarded received packets to upper layer, add a task
 577                  * in an interrupts enabled context that refills the RX ring
 578                  * with skb's.
 579                  */
 580 #ifdef MV643XX_RX_QUEUE_FILL_ON_TASK
 581                 /* Mask all interrupts on ethernet port */
 582                 mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num),
 583                                                         INT_MASK_ALL);
 584                 /* wait for previous write to take effect */
 585                 mv_read(MV643XX_ETH_INTERRUPT_MASK_REG(port_num));
 586
 587                 queue_task(&mp->rx_task, &tq_immediate);
 588                 mark_bh(IMMEDIATE_BH);
 589 #else
 590                 mp->rx_task.func(dev);
 591 #endif
 592 #endif
 593         }
 594         /* PHY status changed */
 595         if (eth_int_cause_ext & (BIT16 | BIT20)) {
 596                 struct ethtool_cmd cmd;
 597
 598                 if (mii_link_ok(&mp->mii)) {
 599                         mii_ethtool_gset(&mp->mii, &cmd);
 600                         mv643xx_eth_update_pscr(dev, &cmd);
 601                         if (!netif_carrier_ok(dev)) {
 602                                 netif_carrier_on(dev);
 603                                 if (mp->tx_ring_size > mp->tx_desc_count +
 604                                                         MAX_DESCS_PER_SKB) {
 605                                         netif_wake_queue(dev);
 606                                         /* Start TX queue */
 607                                         mv643xx_eth_port_enable_tx(port_num, mp->port_tx_queue_command);
 608                                 }
 609                         }
 610                 } else if (netif_carrier_ok(dev)) {
 611                         netif_stop_queue(dev);
 612                         netif_carrier_off(dev);
 613                 }
 614         }
 615
 616         /*
 617          * If no real interrupt occured, exit.
 618          * This can happen when using gigE interrupt coalescing mechanism.
 619          */
 620         if ((eth_int_cause == 0x0) && (eth_int_cause_ext == 0x0))
 621                 return IRQ_NONE;
 622
 623         return IRQ_HANDLED;
 624 }
 625
 626 #ifdef MV643XX_COAL
 627
 628 /*
 629  * eth_port_set_rx_coal - Sets coalescing interrupt mechanism on RX path
 630  *
 631  * DESCRIPTION:
 632  *      This routine sets the RX coalescing interrupt mechanism parameter.
 633  *      This parameter is a timeout counter, that counts in 64 t_clk
 634  *      chunks ; that when timeout event occurs a maskable interrupt
 635  *      occurs.
 636  *      The parameter is calculated using the tClk of the MV-643xx chip
 637  *      , and the required delay of the interrupt in usec.
 638  *
 639  * INPUT:
 640  *      unsigned int eth_port_num       Ethernet port number
 641  *      unsigned int t_clk              t_clk of the MV-643xx chip in HZ units
 642  *      unsigned int delay              Delay in usec
 643  *
 644  * OUTPUT:
 645  *      Interrupt coalescing mechanism value is set in MV-643xx chip.
 646  *
 647  * RETURN:
 648  *      The interrupt coalescing value set in the gigE port.
 649  *
 650  */
 651 static unsigned int eth_port_set_rx_coal(unsigned int eth_port_num,
 652                                         unsigned int t_clk, unsigned int delay)
 653 {
 654         unsigned int coal = ((t_clk / 1000000) * delay) / 64;
 655
 656         /* Set RX Coalescing mechanism */
 657         mv_write(MV643XX_ETH_SDMA_CONFIG_REG(eth_port_num),
 658                 ((coal & 0x3fff) << 8) |
 659                 (mv_read(MV643XX_ETH_SDMA_CONFIG_REG(eth_port_num))
 660                         & 0xffc000ff));
 661
 662         return coal;
 663 }
 664 #endif
 665
 666 /*
 667  * eth_port_set_tx_coal - Sets coalescing interrupt mechanism on TX path
 668  *
 669  * DESCRIPTION:
 670  *      This routine sets the TX coalescing interrupt mechanism parameter.
 671  *      This parameter is a timeout counter, that counts in 64 t_clk
 672  *      chunks ; that when timeout event occurs a maskable interrupt
 673  *      occurs.
 674  *      The parameter is calculated using the t_cLK frequency of the
 675  *      MV-643xx chip and the required delay in the interrupt in uSec
 676  *
 677  * INPUT:
 678  *      unsigned int eth_port_num       Ethernet port number
 679  *      unsigned int t_clk              t_clk of the MV-643xx chip in HZ units
 680  *      unsigned int delay              Delay in uSeconds
 681  *
 682  * OUTPUT:
 683  *      Interrupt coalescing mechanism value is set in MV-643xx chip.
 684  *
 685  * RETURN:
 686  *      The interrupt coalescing value set in the gigE port.
 687  *
 688  */
 689 static unsigned int eth_port_set_tx_coal(unsigned int eth_port_num,
 690                                         unsigned int t_clk, unsigned int delay)
 691 {
 692         unsigned int coal;
 693         coal = ((t_clk / 1000000) * delay) / 64;
 694         /* Set TX Coalescing mechanism */
 695         mv_write(MV643XX_ETH_TX_FIFO_URGENT_THRESHOLD_REG(eth_port_num),
 696                                                                 coal << 4);
 697         return coal;
 698 }
 699
 700 /*
 701  * ether_init_rx_desc_ring - Curve a Rx chain desc list and buffer in memory.
 702  *
 703  * DESCRIPTION:
 704  *      This function prepares a Rx chained list of descriptors and packet
 705  *      buffers in a form of a ring. The routine must be called after port
 706  *      initialization routine and before port start routine.
 707  *      The Ethernet SDMA engine uses CPU bus addresses to access the various
 708  *      devices in the system (i.e. DRAM). This function uses the ethernet
 709  *      struct 'virtual to physical' routine (set by the user) to set the ring
 710  *      with physical addresses.
 711  *
 712  * INPUT:
 713  *      struct mv643xx_private *mp      Ethernet Port Control srtuct.
 714  *
 715  * OUTPUT:
 716  *      The routine updates the Ethernet port control struct with information
 717  *      regarding the Rx descriptors and buffers.
 718  *
 719  * RETURN:
 720  *      None.
 721  */
 722 static void ether_init_rx_desc_ring(struct mv643xx_private *mp)
 723 {
 724         volatile struct eth_rx_desc *p_rx_desc;
 725         int rx_desc_num = mp->rx_ring_size;
 726         int i;
 727
 728         /* initialize the next_desc_ptr links in the Rx descriptors ring */
 729         p_rx_desc = (struct eth_rx_desc *)mp->p_rx_desc_area;
 730         for (i = 0; i < rx_desc_num; i++) {
 731                 p_rx_desc[i].next_desc_ptr = mp->rx_desc_dma +
 732                         ((i + 1) % rx_desc_num) * sizeof(struct eth_rx_desc);
 733         }
 734
 735         /* Save Rx desc pointer to driver struct. */
 736         mp->rx_curr_desc_q = 0;
 737         mp->rx_used_desc_q = 0;
 738
 739         mp->rx_desc_area_size = rx_desc_num * sizeof(struct eth_rx_desc);
 740
 741         /* Enable queue 0 for this port */
 742         mp->port_rx_queue_command = 1;
 743 }
 744
 745 /*
 746  * ether_init_tx_desc_ring - Curve a Tx chain desc list and buffer in memory.
 747  *
 748  * DESCRIPTION:
 749  *      This function prepares a Tx chained list of descriptors and packet
 750  *      buffers in a form of a ring. The routine must be called after port
 751  *      initialization routine and before port start routine.
 752  *      The Ethernet SDMA engine uses CPU bus addresses to access the various
 753  *      devices in the system (i.e. DRAM). This function uses the ethernet
 754  *      struct 'virtual to physical' routine (set by the user) to set the ring
 755  *      with physical addresses.
 756  *
 757  * INPUT:
 758  *      struct mv643xx_private *mp      Ethernet Port Control srtuct.
 759  *
 760  * OUTPUT:
 761  *      The routine updates the Ethernet port control struct with information
 762  *      regarding the Tx descriptors and buffers.
 763  *
 764  * RETURN:
 765  *      None.
 766  */
 767 static void ether_init_tx_desc_ring(struct mv643xx_private *mp)
 768 {
 769         int tx_desc_num = mp->tx_ring_size;
 770         struct eth_tx_desc *p_tx_desc;
 771         int i;
 772
 773         /* Initialize the next_desc_ptr links in the Tx descriptors ring */
 774         p_tx_desc = (struct eth_tx_desc *)mp->p_tx_desc_area;
 775         for (i = 0; i < tx_desc_num; i++) {
 776                 p_tx_desc[i].next_desc_ptr = mp->tx_desc_dma +
 777                         ((i + 1) % tx_desc_num) * sizeof(struct eth_tx_desc);
 778         }
 779
 780         mp->tx_curr_desc_q = 0;
 781         mp->tx_used_desc_q = 0;
 782 #ifdef MV643XX_CHECKSUM_OFFLOAD_TX
 783         mp->tx_first_desc_q = 0;
 784 #endif
 785
 786         mp->tx_desc_area_size = tx_desc_num * sizeof(struct eth_tx_desc);
 787
 788         /* Enable queue 0 for this port */
 789         mp->port_tx_queue_command = 1;
 790 }
 791
 792 static int mv643xx_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 793 {
 794         struct mv643xx_private *mp = netdev_priv(dev);
 795         int err;
 796
 797         spin_lock_irq(&mp->lock);
 798         err = mii_ethtool_sset(&mp->mii, cmd);
 799         spin_unlock_irq(&mp->lock);
 800
 801         return err;
 802 }
 803
 804 static int mv643xx_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 805 {
 806         struct mv643xx_private *mp = netdev_priv(dev);
 807         int err;
 808
 809         spin_lock_irq(&mp->lock);
 810         err = mii_ethtool_gset(&mp->mii, cmd);
 811         spin_unlock_irq(&mp->lock);
 812
 813         /* The PHY may support 1000baseT_Half, but the mv643xx does not */
 814         cmd->supported &= ~SUPPORTED_1000baseT_Half;
 815         cmd->advertising &= ~ADVERTISED_1000baseT_Half;
 816
 817         return err;
 818 }
 819
 820 /*
 821  * mv643xx_eth_open
 822  *
 823  * This function is called when openning the network device. The function
 824  * should initialize all the hardware, initialize cyclic Rx/Tx
 825  * descriptors chain and buffers and allocate an IRQ to the network
 826  * device.
 827  *
 828  * Input :      a pointer to the network device structure
 829  *
 830  * Output :     zero of success , nonzero if fails.
 831  */
 832
 833 static int mv643xx_eth_open(struct net_device *dev)
 834 {
 835         struct mv643xx_private *mp = netdev_priv(dev);
 836         unsigned int port_num = mp->port_num;
 837         unsigned int size;
 838         int err;
 839
 840         err = request_irq(dev->irq, mv643xx_eth_int_handler,
 841                         SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
 842         if (err) {
 843                 printk(KERN_ERR "Can not assign IRQ number to MV643XX_eth%d\n",
 844                                                                 port_num);
 845                 return -EAGAIN;
 846         }
 847
 848         eth_port_init(mp);
 849
 850         INIT_WORK(&mp->rx_task, (void (*)(void *))mv643xx_eth_rx_task, dev);
 851
 852         memset(&mp->timeout, 0, sizeof(struct timer_list));
 853         mp->timeout.function = mv643xx_eth_rx_task_timer_wrapper;
 854         mp->timeout.data = (unsigned long)dev;
 855
 856         mp->rx_task_busy = 0;
 857         mp->rx_timer_flag = 0;
 858
 859         /* Allocate RX and TX skb rings */
 860         mp->rx_skb = kmalloc(sizeof(*mp->rx_skb) * mp->rx_ring_size,
 861                                                                 GFP_KERNEL);
 862         if (!mp->rx_skb) {
 863                 printk(KERN_ERR "%s: Cannot allocate Rx skb ring\n", dev->name);
 864                 err = -ENOMEM;
 865                 goto out_free_irq;
 866         }
 867         mp->tx_skb = kmalloc(sizeof(*mp->tx_skb) * mp->tx_ring_size,
 868                                                                 GFP_KERNEL);
 869         if (!mp->tx_skb) {
 870                 printk(KERN_ERR "%s: Cannot allocate Tx skb ring\n", dev->name);
 871                 err = -ENOMEM;
 872                 goto out_free_rx_skb;
 873         }
 874
 875         /* Allocate TX ring */
 876         mp->tx_desc_count = 0;
 877         size = mp->tx_ring_size * sizeof(struct eth_tx_desc);
 878         mp->tx_desc_area_size = size;
 879
 880         if (mp->tx_sram_size) {
 881                 mp->p_tx_desc_area = ioremap(mp->tx_sram_addr,
 882                                                         mp->tx_sram_size);
 883                 mp->tx_desc_dma = mp->tx_sram_addr;
 884         } else
 885                 mp->p_tx_desc_area = dma_alloc_coherent(NULL, size,
 886                                                         &mp->tx_desc_dma,
 887                                                         GFP_KERNEL);
 888
 889         if (!mp->p_tx_desc_area) {
 890                 printk(KERN_ERR "%s: Cannot allocate Tx Ring (size %d bytes)\n",
 891                                                         dev->name, size);
 892                 err = -ENOMEM;
 893                 goto out_free_tx_skb;
 894         }
 895         BUG_ON((u32) mp->p_tx_desc_area & 0xf); /* check 16-byte alignment */
 896         memset((void *)mp->p_tx_desc_area, 0, mp->tx_desc_area_size);
 897
 898         ether_init_tx_desc_ring(mp);
 899
 900         /* Allocate RX ring */
 901         mp->rx_desc_count = 0;
 902         size = mp->rx_ring_size * sizeof(struct eth_rx_desc);
 903         mp->rx_desc_area_size = size;
 904
 905         if (mp->rx_sram_size) {
 906                 mp->p_rx_desc_area = ioremap(mp->rx_sram_addr,
 907                                                         mp->rx_sram_size);
 908                 mp->rx_desc_dma = mp->rx_sram_addr;
 909         } else
 910                 mp->p_rx_desc_area = dma_alloc_coherent(NULL, size,
 911                                                         &mp->rx_desc_dma,
 912                                                         GFP_KERNEL);
 913
 914         if (!mp->p_rx_desc_area) {
 915                 printk(KERN_ERR "%s: Cannot allocate Rx ring (size %d bytes)\n",
 916                                                         dev->name, size);
 917                 printk(KERN_ERR "%s: Freeing previously allocated TX queues...",
 918                                                         dev->name);
 919                 if (mp->rx_sram_size)
 920                         iounmap(mp->p_tx_desc_area);
 921                 else
 922                         dma_free_coherent(NULL, mp->tx_desc_area_size,
 923                                         mp->p_tx_desc_area, mp->tx_desc_dma);
 924                 err = -ENOMEM;
 925                 goto out_free_tx_skb;
 926         }
 927         memset((void *)mp->p_rx_desc_area, 0, size);
 928
 929         ether_init_rx_desc_ring(mp);
 930
 931         mv643xx_eth_rx_task(dev);       /* Fill RX ring with skb's */
 932
 933         /* Clear any pending ethernet port interrupts */
 934         mv_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num), 0);
 935         mv_write(MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG(port_num), 0);
 936
 937         eth_port_start(dev);
 938
 939         /* Interrupt Coalescing */
 940
 941 #ifdef MV643XX_COAL
 942         mp->rx_int_coal =
 943                 eth_port_set_rx_coal(port_num, 133000000, MV643XX_RX_COAL);
 944 #endif
 945
 946         mp->tx_int_coal =
 947                 eth_port_set_tx_coal(port_num, 133000000, MV643XX_TX_COAL);
 948
 949         /* Unmask phy and link status changes interrupts */
 950         mv_write(MV643XX_ETH_INTERRUPT_EXTEND_MASK_REG(port_num),
 951                                                 INT_UNMASK_ALL_EXT);
 952
 953         /* Unmask RX buffer and TX end interrupt */
 954         mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num), INT_UNMASK_ALL);
 955
 956         return 0;
 957
 958 out_free_tx_skb:
 959         kfree(mp->tx_skb);
 960 out_free_rx_skb:
 961         kfree(mp->rx_skb);
 962 out_free_irq:
 963         free_irq(dev->irq, dev);
 964
 965         return err;
 966 }
 967
 968 static void mv643xx_eth_free_tx_rings(struct net_device *dev)
 969 {
 970         struct mv643xx_private *mp = netdev_priv(dev);
 971         unsigned int port_num = mp->port_num;
 972         unsigned int curr;
 973         struct sk_buff *skb;
 974
 975         /* Stop Tx Queues */
 976         mv643xx_eth_port_disable_tx(port_num);
 977
 978         /* Free outstanding skb's on TX rings */
 979         for (curr = 0; mp->tx_desc_count && curr < mp->tx_ring_size; curr++) {
 980                 skb = mp->tx_skb[curr];
 981                 if (skb) {
 982                         mp->tx_desc_count -= skb_shinfo(skb)->nr_frags;
 983                         dev_kfree_skb(skb);
 984                         mp->tx_desc_count--;
 985                 }
 986         }
 987         if (mp->tx_desc_count)
 988                 printk("%s: Error on Tx descriptor free - could not free %d"
 989                                 " descriptors\n", dev->name, mp->tx_desc_count);
 990
 991         /* Free TX ring */
 992         if (mp->tx_sram_size)
 993                 iounmap(mp->p_tx_desc_area);
 994         else
 995                 dma_free_coherent(NULL, mp->tx_desc_area_size,
 996                                 mp->p_tx_desc_area, mp->tx_desc_dma);
 997 }
 998
 999 static void mv643xx_eth_free_rx_rings(struct net_device *dev)
1000 {
1001         struct mv643xx_private *mp = netdev_priv(dev);
1002         unsigned int port_num = mp->port_num;
1003         int curr;
1004
1005         /* Stop RX Queues */
1006         mv643xx_eth_port_disable_rx(port_num);
1007
1008         /* Free preallocated skb's on RX rings */
1009         for (curr = 0; mp->rx_desc_count && curr < mp->rx_ring_size; curr++) {
1010                 if (mp->rx_skb[curr]) {
1011                         dev_kfree_skb(mp->rx_skb[curr]);
1012                         mp->rx_desc_count--;
1013                 }
1014         }
1015
1016         if (mp->rx_desc_count)
1017                 printk(KERN_ERR
1018                         "%s: Error in freeing Rx Ring. %d skb's still"
1019                         " stuck in RX Ring - ignoring them\n", dev->name,
1020                         mp->rx_desc_count);
1021         /* Free RX ring */
1022         if (mp->rx_sram_size)
1023                 iounmap(mp->p_rx_desc_area);
1024         else
1025                 dma_free_coherent(NULL, mp->rx_desc_area_size,
1026                                 mp->p_rx_desc_area, mp->rx_desc_dma);
1027 }
1028
1029 /*
1030  * mv643xx_eth_stop
1031  *
1032  * This function is used when closing the network device.
1033  * It updates the hardware,
1034  * release all memory that holds buffers and descriptors and release the IRQ.
1035  * Input :      a pointer to the device structure
1036  * Output :     zero if success , nonzero if fails
1037  */
1038
1039 static int mv643xx_eth_stop(struct net_device *dev)
1040 {
1041         struct mv643xx_private *mp = netdev_priv(dev);
1042         unsigned int port_num = mp->port_num;
1043
1044         /* Mask all interrupts on ethernet port */
1045         mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num), INT_MASK_ALL);
1046         /* wait for previous write to complete */
1047         mv_read(MV643XX_ETH_INTERRUPT_MASK_REG(port_num));
1048
1049 #ifdef MV643XX_NAPI
1050         netif_poll_disable(dev);
1051 #endif
1052         netif_carrier_off(dev);
1053         netif_stop_queue(dev);
1054
1055         eth_port_reset(mp->port_num);
1056
1057         mv643xx_eth_free_tx_rings(dev);
1058         mv643xx_eth_free_rx_rings(dev);
1059
1060 #ifdef MV643XX_NAPI
1061         netif_poll_enable(dev);
1062 #endif
1063
1064         free_irq(dev->irq, dev);
1065
1066         return 0;
1067 }
1068
1069 #ifdef MV643XX_NAPI
1070 static void mv643xx_tx(struct net_device *dev)
1071 {
1072         struct mv643xx_private *mp = netdev_priv(dev);
1073         struct pkt_info pkt_info;
1074
1075         while (eth_tx_return_desc(mp, &pkt_info) == ETH_OK) {
1076                 if (pkt_info.cmd_sts & ETH_TX_FIRST_DESC)
1077                         dma_unmap_single(NULL, pkt_info.buf_ptr,
1078                                         pkt_info.byte_cnt,
1079                                         DMA_TO_DEVICE);
1080                 else
1081                         dma_unmap_page(NULL, pkt_info.buf_ptr,
1082                                         pkt_info.byte_cnt,
1083                                         DMA_TO_DEVICE);
1084
1085                 if (pkt_info.return_info)
1086                         dev_kfree_skb_irq(pkt_info.return_info);
1087         }
1088
1089         if (netif_queue_stopped(dev) &&
1090                         mp->tx_ring_size >
1091                                         mp->tx_desc_count + MAX_DESCS_PER_SKB)
1092                 netif_wake_queue(dev);
1093 }
1094
1095 /*
1096  * mv643xx_poll
1097  *
1098  * This function is used in case of NAPI
1099  */
1100 static int mv643xx_poll(struct net_device *dev, int *budget)
1101 {
1102         struct mv643xx_private *mp = netdev_priv(dev);
1103         int done = 1, orig_budget, work_done;
1104         unsigned int port_num = mp->port_num;
1105
1106 #ifdef MV643XX_TX_FAST_REFILL
1107         if (++mp->tx_clean_threshold > 5) {
1108                 mv643xx_tx(dev);
1109                 mp->tx_clean_threshold = 0;
1110         }
1111 #endif
1112
1113         if ((mv_read(MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_0(port_num)))
1114                                                 != (u32) mp->rx_used_desc_q) {
1115                 orig_budget = *budget;
1116                 if (orig_budget > dev->quota)
1117                         orig_budget = dev->quota;
1118                 work_done = mv643xx_eth_receive_queue(dev, orig_budget);
1119                 mp->rx_task.func(dev);
1120                 *budget -= work_done;
1121                 dev->quota -= work_done;
1122                 if (work_done >= orig_budget)
1123                         done = 0;
1124         }
1125
1126         if (done) {
1127                 netif_rx_complete(dev);
1128                 mv_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num), 0);
1129                 mv_write(MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG(port_num), 0);
1130                 mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num),
1131                                                 INT_UNMASK_ALL);
1132         }
1133
1134         return done ? 0 : 1;
1135 }
1136 #endif
1137
1138 /* Hardware can't handle unaligned fragments smaller than 9 bytes.
1139  * This helper function detects that case.
1140  */
1141
1142 static inline unsigned int has_tiny_unaligned_frags(struct sk_buff *skb)
1143 {
1144         unsigned int frag;
1145         skb_frag_t *fragp;
1146
1147         for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) {
1148                 fragp = &skb_shinfo(skb)->frags[frag];
1149                 if (fragp->size <= 8 && fragp->page_offset & 0x7)
1150                         return 1;
1151         }
1152         return 0;
1153 }
1154
1155
1156 /*
1157  * mv643xx_eth_start_xmit
1158  *
1159  * This function is queues a packet in the Tx descriptor for
1160  * required port.
1161  *
1162  * Input :      skb - a pointer to socket buffer
1163  *              dev - a pointer to the required port
1164  *
1165  * Output :     zero upon success
1166  */
1167 static int mv643xx_eth_start_xmit(struct sk_buff *skb, struct net_device *dev)
1168 {
1169         struct mv643xx_private *mp = netdev_priv(dev);
1170         struct net_device_stats *stats = &mp->stats;
1171         ETH_FUNC_RET_STATUS status;
1172         unsigned long flags;
1173         struct pkt_info pkt_info;
1174
1175         if (netif_queue_stopped(dev)) {
1176                 printk(KERN_ERR
1177                         "%s: Tried sending packet when interface is stopped\n",
1178                         dev->name);
1179                 return 1;
1180         }
1181
1182         /* This is a hard error, log it. */
1183         if ((mp->tx_ring_size - mp->tx_desc_count) <=
1184                                         (skb_shinfo(skb)->nr_frags + 1)) {
1185                 netif_stop_queue(dev);
1186                 printk(KERN_ERR
1187                         "%s: Bug in mv643xx_eth - Trying to transmit when"
1188                         " queue full !\n", dev->name);
1189                 return 1;
1190         }
1191
1192         /* Paranoid check - this shouldn't happen */
1193         if (skb == NULL) {
1194                 stats->tx_dropped++;
1195                 printk(KERN_ERR "mv64320_eth paranoid check failed\n");
1196                 return 1;
1197         }
1198
1199 #ifdef MV643XX_CHECKSUM_OFFLOAD_TX
1200         if (has_tiny_unaligned_frags(skb)) {
1201                 if ((skb_linearize(skb, GFP_ATOMIC) != 0)) {
1202                         stats->tx_dropped++;
1203                         printk(KERN_DEBUG "%s: failed to linearize tiny "
1204                                         "unaligned fragment\n", dev->name);
1205                         return 1;
1206                 }
1207         }
1208
1209         spin_lock_irqsave(&mp->lock, flags);
1210
1211         if (!skb_shinfo(skb)->nr_frags) {
1212                 if (skb->ip_summed != CHECKSUM_HW) {
1213                         /* Errata BTS #50, IHL must be 5 if no HW checksum */
1214                         pkt_info.cmd_sts = ETH_TX_ENABLE_INTERRUPT |
1215                                            ETH_TX_FIRST_DESC |
1216                                            ETH_TX_LAST_DESC |
1217                                            5 << ETH_TX_IHL_SHIFT;
1218                         pkt_info.l4i_chk = 0;
1219                 } else {
1220                         pkt_info.cmd_sts = ETH_TX_ENABLE_INTERRUPT |
1221                                            ETH_TX_FIRST_DESC |
1222                                            ETH_TX_LAST_DESC |
1223                                            ETH_GEN_TCP_UDP_CHECKSUM |
1224                                            ETH_GEN_IP_V_4_CHECKSUM |
1225                                            skb->nh.iph->ihl << ETH_TX_IHL_SHIFT;
1226                         /* CPU already calculated pseudo header checksum. */
1227                         if ((skb->protocol == ETH_P_IP) &&
1228                             (skb->nh.iph->protocol == IPPROTO_UDP) ) {
1229                                 pkt_info.cmd_sts |= ETH_UDP_FRAME;
1230                                 pkt_info.l4i_chk = skb->h.uh->check;
1231                         } else if ((skb->protocol == ETH_P_IP) &&
1232                                    (skb->nh.iph->protocol == IPPROTO_TCP))
1233                                 pkt_info.l4i_chk = skb->h.th->check;
1234                         else {
1235                                 printk(KERN_ERR
1236                                         "%s: chksum proto != IPv4 TCP or UDP\n",
1237                                         dev->name);
1238                                 spin_unlock_irqrestore(&mp->lock, flags);
1239                                 return 1;
1240                         }
1241                 }
1242                 pkt_info.byte_cnt = skb->len;
1243                 pkt_info.buf_ptr = dma_map_single(NULL, skb->data, skb->len,
1244                                                         DMA_TO_DEVICE);
1245                 pkt_info.return_info = skb;
1246                 status = eth_port_send(mp, &pkt_info);
1247                 if ((status == ETH_ERROR) || (status == ETH_QUEUE_FULL))
1248                         printk(KERN_ERR "%s: Error on transmitting packet\n",
1249                                                                 dev->name);
1250                 stats->tx_bytes += pkt_info.byte_cnt;
1251         } else {
1252                 unsigned int frag;
1253
1254                 /* first frag which is skb header */
1255                 pkt_info.byte_cnt = skb_headlen(skb);
1256                 pkt_info.buf_ptr = dma_map_single(NULL, skb->data,
1257                                                         skb_headlen(skb),
1258                                                         DMA_TO_DEVICE);
1259                 pkt_info.l4i_chk = 0;
1260                 pkt_info.return_info = 0;
1261
1262                 if (skb->ip_summed != CHECKSUM_HW)
1263                         /* Errata BTS #50, IHL must be 5 if no HW checksum */
1264                         pkt_info.cmd_sts = ETH_TX_FIRST_DESC |
1265                                            5 << ETH_TX_IHL_SHIFT;
1266                 else {
1267                         pkt_info.cmd_sts = ETH_TX_FIRST_DESC |
1268                                            ETH_GEN_TCP_UDP_CHECKSUM |
1269                                            ETH_GEN_IP_V_4_CHECKSUM |
1270                                            skb->nh.iph->ihl << ETH_TX_IHL_SHIFT;
1271                         /* CPU already calculated pseudo header checksum. */
1272                         if ((skb->protocol == ETH_P_IP) &&
1273                             (skb->nh.iph->protocol == IPPROTO_UDP)) {
1274                                 pkt_info.cmd_sts |= ETH_UDP_FRAME;
1275                                 pkt_info.l4i_chk = skb->h.uh->check;
1276                         } else if ((skb->protocol == ETH_P_IP) &&
1277                                    (skb->nh.iph->protocol == IPPROTO_TCP))
1278                                 pkt_info.l4i_chk = skb->h.th->check;
1279                         else {
1280                                 printk(KERN_ERR
1281                                         "%s: chksum proto != IPv4 TCP or UDP\n",
1282                                         dev->name);
1283                                 spin_unlock_irqrestore(&mp->lock, flags);
1284                                 return 1;
1285                         }
1286                 }
1287
1288                 status = eth_port_send(mp, &pkt_info);
1289                 if (status != ETH_OK) {
1290                         if ((status == ETH_ERROR))
1291                                 printk(KERN_ERR
1292                                         "%s: Error on transmitting packet\n",
1293                                         dev->name);
1294                         if (status == ETH_QUEUE_FULL)
1295                                 printk("Error on Queue Full \n");
1296                         if (status == ETH_QUEUE_LAST_RESOURCE)
1297                                 printk("Tx resource error \n");
1298                 }
1299                 stats->tx_bytes += pkt_info.byte_cnt;
1300
1301                 /* Check for the remaining frags */
1302                 for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) {
1303                         skb_frag_t *this_frag = &skb_shinfo(skb)->frags[frag];
1304                         pkt_info.l4i_chk = 0x0000;
1305                         pkt_info.cmd_sts = 0x00000000;
1306
1307                         /* Last Frag enables interrupt and frees the skb */
1308                         if (frag == (skb_shinfo(skb)->nr_frags - 1)) {
1309                                 pkt_info.cmd_sts |= ETH_TX_ENABLE_INTERRUPT |
1310                                                         ETH_TX_LAST_DESC;
1311                                 pkt_info.return_info = skb;
1312                         } else {
1313                                 pkt_info.return_info = 0;
1314                         }
1315                         pkt_info.l4i_chk = 0;
1316                         pkt_info.byte_cnt = this_frag->size;
1317
1318                         pkt_info.buf_ptr = dma_map_page(NULL, this_frag->page,
1319                                                         this_frag->page_offset,
1320                                                         this_frag->size,
1321                                                         DMA_TO_DEVICE);
1322
1323                         status = eth_port_send(mp, &pkt_info);
1324
1325                         if (status != ETH_OK) {
1326                                 if ((status == ETH_ERROR))
1327                                         printk(KERN_ERR "%s: Error on "
1328                                                         "transmitting packet\n",
1329                                                         dev->name);
1330
1331                                 if (status == ETH_QUEUE_LAST_RESOURCE)
1332                                         printk("Tx resource error \n");
1333
1334                                 if (status == ETH_QUEUE_FULL)
1335                                         printk("Queue is full \n");
1336                         }
1337                         stats->tx_bytes += pkt_info.byte_cnt;
1338                 }
1339         }
1340 #else
1341         spin_lock_irqsave(&mp->lock, flags);
1342
1343         pkt_info.cmd_sts = ETH_TX_ENABLE_INTERRUPT | ETH_TX_FIRST_DESC |
1344                                                         ETH_TX_LAST_DESC;
1345         pkt_info.l4i_chk = 0;
1346         pkt_info.byte_cnt = skb->len;
1347         pkt_info.buf_ptr = dma_map_single(NULL, skb->data, skb->len,
1348                                                                 DMA_TO_DEVICE);
1349         pkt_info.return_info = skb;
1350         status = eth_port_send(mp, &pkt_info);
1351         if ((status == ETH_ERROR) || (status == ETH_QUEUE_FULL))
1352                 printk(KERN_ERR "%s: Error on transmitting packet\n",
1353                                                                 dev->name);
1354         stats->tx_bytes += pkt_info.byte_cnt;
1355 #endif
1356
1357         /* Check if TX queue can handle another skb. If not, then
1358          * signal higher layers to stop requesting TX
1359          */
1360         if (mp->tx_ring_size <= (mp->tx_desc_count + MAX_DESCS_PER_SKB))
1361                 /*
1362                  * Stop getting skb's from upper layers.
1363                  * Getting skb's from upper layers will be enabled again after
1364                  * packets are released.
1365                  */
1366                 netif_stop_queue(dev);
1367
1368         /* Update statistics and start of transmittion time */
1369         stats->tx_packets++;
1370         dev->trans_start = jiffies;
1371
1372         spin_unlock_irqrestore(&mp->lock, flags);
1373
1374         return 0;               /* success */
1375 }
1376
1377 /*
1378  * mv643xx_eth_get_stats
1379  *
1380  * Returns a pointer to the interface statistics.
1381  *
1382  * Input :      dev - a pointer to the required interface
1383  *
1384  * Output :     a pointer to the interface's statistics
1385  */
1386
1387 static struct net_device_stats *mv643xx_eth_get_stats(struct net_device *dev)
1388 {
1389         struct mv643xx_private *mp = netdev_priv(dev);
1390
1391         return &mp->stats;
1392 }
1393
1394 #ifdef CONFIG_NET_POLL_CONTROLLER
1395 static void mv643xx_netpoll(struct net_device *netdev)
1396 {
1397         struct mv643xx_private *mp = netdev_priv(netdev);
1398         int port_num = mp->port_num;
1399
1400         mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num), INT_MASK_ALL);
1401         /* wait for previous write to complete */
1402         mv_read(MV643XX_ETH_INTERRUPT_MASK_REG(port_num));
1403
1404         mv643xx_eth_int_handler(netdev->irq, netdev, NULL);
1405
1406         mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num), INT_UNMASK_ALL);
1407 }
1408 #endif
1409
1410 static void mv643xx_init_ethtool_cmd(struct net_device *dev, int phy_address,
1411                                      int speed, int duplex,
1412                                      struct ethtool_cmd *cmd)
1413 {
1414         struct mv643xx_private *mp = netdev_priv(dev);
1415
1416         memset(cmd, 0, sizeof(*cmd));
1417
1418         cmd->port = PORT_MII;
1419         cmd->transceiver = XCVR_INTERNAL;
1420         cmd->phy_address = phy_address;
1421
1422         if (speed == 0) {
1423                 cmd->autoneg = AUTONEG_ENABLE;
1424                 /* mii lib checks, but doesn't use speed on AUTONEG_ENABLE */
1425                 cmd->speed = SPEED_100;
1426                 cmd->advertising = ADVERTISED_10baseT_Half  |
1427                                    ADVERTISED_10baseT_Full  |
1428                                    ADVERTISED_100baseT_Half |
1429                                    ADVERTISED_100baseT_Full;
1430                 if (mp->mii.supports_gmii)
1431                         cmd->advertising |= ADVERTISED_1000baseT_Full;
1432         } else {
1433                 cmd->autoneg = AUTONEG_DISABLE;
1434                 cmd->speed = speed;
1435                 cmd->duplex = duplex;
1436         }
1437 }
1438
1439 /*/
1440  * mv643xx_eth_probe
1441  *
1442  * First function called after registering the network device.
1443  * It's purpose is to initialize the device as an ethernet device,
1444  * fill the ethernet device structure with pointers * to functions,
1445  * and set the MAC address of the interface
1446  *
1447  * Input :      struct device *
1448  * Output :     -ENOMEM if failed , 0 if success
1449  */
1450 static int mv643xx_eth_probe(struct platform_device *pdev)
1451 {
1452         struct mv643xx_eth_platform_data *pd;
1453         int port_num = pdev->id;
1454         struct mv643xx_private *mp;
1455         struct net_device *dev;
1456         u8 *p;
1457         struct resource *res;
1458         int err;
1459         struct ethtool_cmd cmd;
1460         int duplex = DUPLEX_HALF;
1461         int speed = 0;                  /* default to auto-negotiation */
1462
1463         dev = alloc_etherdev(sizeof(struct mv643xx_private));
1464         if (!dev)
1465                 return -ENOMEM;
1466
1467         platform_set_drvdata(pdev, dev);
1468
1469         mp = netdev_priv(dev);
1470
1471         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1472         BUG_ON(!res);
1473         dev->irq = res->start;
1474
1475         mp->port_num = port_num;
1476
1477         dev->open = mv643xx_eth_open;
1478         dev->stop = mv643xx_eth_stop;
1479         dev->hard_start_xmit = mv643xx_eth_start_xmit;
1480         dev->get_stats = mv643xx_eth_get_stats;
1481         dev->set_mac_address = mv643xx_eth_set_mac_address;
1482         dev->set_multicast_list = mv643xx_eth_set_rx_mode;
1483
1484         /* No need to Tx Timeout */
1485         dev->tx_timeout = mv643xx_eth_tx_timeout;
1486 #ifdef MV643XX_NAPI
1487         dev->poll = mv643xx_poll;
1488         dev->weight = 64;
1489 #endif
1490
1491 #ifdef CONFIG_NET_POLL_CONTROLLER
1492         dev->poll_controller = mv643xx_netpoll;
1493 #endif
1494
1495         dev->watchdog_timeo = 2 * HZ;
1496         dev->tx_queue_len = mp->tx_ring_size;
1497         dev->base_addr = 0;
1498         dev->change_mtu = mv643xx_eth_change_mtu;
1499         dev->do_ioctl = mv643xx_eth_do_ioctl;
1500         SET_ETHTOOL_OPS(dev, &mv643xx_ethtool_ops);
1501
1502 #ifdef MV643XX_CHECKSUM_OFFLOAD_TX
1503 #ifdef MAX_SKB_FRAGS
1504         /*
1505          * Zero copy can only work if we use Discovery II memory. Else, we will
1506          * have to map the buffers to ISA memory which is only 16 MB
1507          */
1508         dev->features = NETIF_F_SG | NETIF_F_IP_CSUM;
1509 #endif
1510 #endif
1511
1512         /* Configure the timeout task */
1513         INIT_WORK(&mp->tx_timeout_task,
1514                         (void (*)(void *))mv643xx_eth_tx_timeout_task, dev);
1515
1516         spin_lock_init(&mp->lock);
1517
1518         /* set default config values */
1519         eth_port_uc_addr_get(dev, dev->dev_addr);
1520         mp->rx_ring_size = MV643XX_ETH_PORT_DEFAULT_RECEIVE_QUEUE_SIZE;
1521         mp->tx_ring_size = MV643XX_ETH_PORT_DEFAULT_TRANSMIT_QUEUE_SIZE;
1522
1523         pd = pdev->dev.platform_data;
1524         if (pd) {
1525                 if (pd->mac_addr)
1526                         memcpy(dev->dev_addr, pd->mac_addr, 6);
1527
1528                 if (pd->phy_addr || pd->force_phy_addr)
1529                         ethernet_phy_set(port_num, pd->phy_addr);
1530
1531                 if (pd->rx_queue_size)
1532                         mp->rx_ring_size = pd->rx_queue_size;
1533
1534                 if (pd->tx_queue_size)
1535                         mp->tx_ring_size = pd->tx_queue_size;
1536
1537                 if (pd->tx_sram_size) {
1538                         mp->tx_sram_size = pd->tx_sram_size;
1539                         mp->tx_sram_addr = pd->tx_sram_addr;
1540                 }
1541
1542                 if (pd->rx_sram_size) {
1543                         mp->rx_sram_size = pd->rx_sram_size;
1544                         mp->rx_sram_addr = pd->rx_sram_addr;
1545                 }
1546
1547                 duplex = pd->duplex;
1548                 speed = pd->speed;
1549         }
1550
1551         /* Hook up MII support for ethtool */
1552         mp->mii.dev = dev;
1553         mp->mii.mdio_read = mv643xx_mdio_read;
1554         mp->mii.mdio_write = mv643xx_mdio_write;
1555         mp->mii.phy_id = ethernet_phy_get(port_num);
1556         mp->mii.phy_id_mask = 0x3f;
1557         mp->mii.reg_num_mask = 0x1f;
1558
1559         err = ethernet_phy_detect(port_num);
1560         if (err) {
1561                 pr_debug("MV643xx ethernet port %d: "
1562                                         "No PHY detected at addr %d\n",
1563                                         port_num, ethernet_phy_get(port_num));
1564                 goto out;
1565         }
1566
1567         ethernet_phy_reset(port_num);
1568         mp->mii.supports_gmii = mii_check_gmii_support(&mp->mii);
1569         mv643xx_init_ethtool_cmd(dev, mp->mii.phy_id, speed, duplex, &cmd);
1570         mv643xx_eth_update_pscr(dev, &cmd);
1571         mv643xx_set_settings(dev, &cmd);
1572
1573         err = register_netdev(dev);
1574         if (err)
1575                 goto out;
1576
1577         p = dev->dev_addr;
1578         printk(KERN_NOTICE
1579                 "%s: port %d with MAC address %02x:%02x:%02x:%02x:%02x:%02x\n",
1580                 dev->name, port_num, p[0], p[1], p[2], p[3], p[4], p[5]);
1581
1582         if (dev->features & NETIF_F_SG)
1583                 printk(KERN_NOTICE "%s: Scatter Gather Enabled\n", dev->name);
1584
1585         if (dev->features & NETIF_F_IP_CSUM)
1586                 printk(KERN_NOTICE "%s: TX TCP/IP Checksumming Supported\n",
1587                                                                 dev->name);
1588
1589 #ifdef MV643XX_CHECKSUM_OFFLOAD_TX
1590         printk(KERN_NOTICE "%s: RX TCP/UDP Checksum Offload ON \n", dev->name);
1591 #endif
1592
1593 #ifdef MV643XX_COAL
1594         printk(KERN_NOTICE "%s: TX and RX Interrupt Coalescing ON \n",
1595                                                                 dev->name);
1596 #endif
1597
1598 #ifdef MV643XX_NAPI
1599         printk(KERN_NOTICE "%s: RX NAPI Enabled \n", dev->name);
1600 #endif
1601
1602         if (mp->tx_sram_size > 0)
1603                 printk(KERN_NOTICE "%s: Using SRAM\n", dev->name);
1604
1605         return 0;
1606
1607 out:
1608         free_netdev(dev);
1609
1610         return err;
1611 }
1612
1613 static int mv643xx_eth_remove(struct platform_device *pdev)
1614 {
1615         struct net_device *dev = platform_get_drvdata(pdev);
1616
1617         unregister_netdev(dev);
1618         flush_scheduled_work();
1619
1620         free_netdev(dev);
1621         platform_set_drvdata(pdev, NULL);
1622         return 0;
1623 }
1624
1625 static int mv643xx_eth_shared_probe(struct platform_device *pdev)
1626 {
1627         struct resource *res;
1628
1629         printk(KERN_NOTICE "MV-643xx 10/100/1000 Ethernet Driver\n");
1630
1631         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1632         if (res == NULL)
1633                 return -ENODEV;
1634
1635         mv643xx_eth_shared_base = ioremap(res->start,
1636                                                 MV643XX_ETH_SHARED_REGS_SIZE);
1637         if (mv643xx_eth_shared_base == NULL)
1638                 return -ENOMEM;
1639
1640         return 0;
1641
1642 }
1643
1644 static int mv643xx_eth_shared_remove(struct platform_device *pdev)
1645 {
1646         iounmap(mv643xx_eth_shared_base);
1647         mv643xx_eth_shared_base = NULL;
1648
1649         return 0;
1650 }
1651
1652 static struct platform_driver mv643xx_eth_driver = {
1653         .probe = mv643xx_eth_probe,
1654         .remove = mv643xx_eth_remove,
1655         .driver = {
1656                 .name = MV643XX_ETH_NAME,
1657         },
1658 };
1659
1660 static struct platform_driver mv643xx_eth_shared_driver = {
1661         .probe = mv643xx_eth_shared_probe,
1662         .remove = mv643xx_eth_shared_remove,
1663         .driver = {
1664                 .name = MV643XX_ETH_SHARED_NAME,
1665         },
1666 };
1667
1668 /*
1669  * mv643xx_init_module
1670  *
1671  * Registers the network drivers into the Linux kernel
1672  *
1673  * Input :      N/A
1674  *
1675  * Output :     N/A
1676  */
1677 static int __init mv643xx_init_module(void)
1678 {
1679         int rc;
1680
1681         rc = platform_driver_register(&mv643xx_eth_shared_driver);
1682         if (!rc) {
1683                 rc = platform_driver_register(&mv643xx_eth_driver);
1684                 if (rc)
1685                         platform_driver_unregister(&mv643xx_eth_shared_driver);
1686         }
1687         return rc;
1688 }
1689
1690 /*
1691  * mv643xx_cleanup_module
1692  *
1693  * Registers the network drivers into the Linux kernel
1694  *
1695  * Input :      N/A
1696  *
1697  * Output :     N/A
1698  */
1699 static void __exit mv643xx_cleanup_module(void)
1700 {
1701         platform_driver_unregister(&mv643xx_eth_driver);
1702         platform_driver_unregister(&mv643xx_eth_shared_driver);
1703 }
1704
1705 module_init(mv643xx_init_module);
1706 module_exit(mv643xx_cleanup_module);
1707
1708 MODULE_LICENSE("GPL");
1709 MODULE_AUTHOR(  "Rabeeh Khoury, Assaf Hoffman, Matthew Dharm, Manish Lachwani"
1710                 " and Dale Farnsworth");
1711 MODULE_DESCRIPTION("Ethernet driver for Marvell MV643XX");
1712
1713 /*
1714  * The second part is the low level driver of the gigE ethernet ports.
1715  */
1716
1717 /*
1718  * Marvell's Gigabit Ethernet controller low level driver
1719  *
1720  * DESCRIPTION:
1721  *      This file introduce low level API to Marvell's Gigabit Ethernet
1722  *              controller. This Gigabit Ethernet Controller driver API controls
1723  *              1) Operations (i.e. port init, start, reset etc').
1724  *              2) Data flow (i.e. port send, receive etc').
1725  *              Each Gigabit Ethernet port is controlled via
1726  *              struct mv643xx_private.
1727  *              This struct includes user configuration information as well as
1728  *              driver internal data needed for its operations.
1729  *
1730  *              Supported Features:
1731  *              - This low level driver is OS independent. Allocating memory for
1732  *                the descriptor rings and buffers are not within the scope of
1733  *                this driver.
1734  *              - The user is free from Rx/Tx queue managing.
1735  *              - This low level driver introduce functionality API that enable
1736  *                the to operate Marvell's Gigabit Ethernet Controller in a
1737  *                convenient way.
1738  *              - Simple Gigabit Ethernet port operation API.
1739  *              - Simple Gigabit Ethernet port data flow API.
1740  *              - Data flow and operation API support per queue functionality.
1741  *              - Support cached descriptors for better performance.
1742  *              - Enable access to all four DRAM banks and internal SRAM memory
1743  *                spaces.
1744  *              - PHY access and control API.
1745  *              - Port control register configuration API.
1746  *              - Full control over Unicast and Multicast MAC configurations.
1747  *
1748  *              Operation flow:
1749  *
1750  *              Initialization phase
1751  *              This phase complete the initialization of the the
1752  *              mv643xx_private struct.
1753  *              User information regarding port configuration has to be set
1754  *              prior to calling the port initialization routine.
1755  *
1756  *              In this phase any port Tx/Rx activity is halted, MIB counters
1757  *              are cleared, PHY address is set according to user parameter and
1758  *              access to DRAM and internal SRAM memory spaces.
1759  *
1760  *              Driver ring initialization
1761  *              Allocating memory for the descriptor rings and buffers is not
1762  *              within the scope of this driver. Thus, the user is required to
1763  *              allocate memory for the descriptors ring and buffers. Those
1764  *              memory parameters are used by the Rx and Tx ring initialization
1765  *              routines in order to curve the descriptor linked list in a form
1766  *              of a ring.
1767  *              Note: Pay special attention to alignment issues when using
1768  *              cached descriptors/buffers. In this phase the driver store
1769  *              information in the mv643xx_private struct regarding each queue
1770  *              ring.
1771  *
1772  *              Driver start
1773  *              This phase prepares the Ethernet port for Rx and Tx activity.
1774  *              It uses the information stored in the mv643xx_private struct to
1775  *              initialize the various port registers.
1776  *
1777  *              Data flow:
1778  *              All packet references to/from the driver are done using
1779  *              struct pkt_info.
1780  *              This struct is a unified struct used with Rx and Tx operations.
1781  *              This way the user is not required to be familiar with neither
1782  *              Tx nor Rx descriptors structures.
1783  *              The driver's descriptors rings are management by indexes.
1784  *              Those indexes controls the ring resources and used to indicate
1785  *              a SW resource error:
1786  *              'current'
1787  *              This index points to the current available resource for use. For
1788  *              example in Rx process this index will point to the descriptor
1789  *              that will be passed to the user upon calling the receive
1790  *              routine.  In Tx process, this index will point to the descriptor
1791  *              that will be assigned with the user packet info and transmitted.
1792  *              'used'
1793  *              This index points to the descriptor that need to restore its
1794  *              resources. For example in Rx process, using the Rx buffer return
1795  *              API will attach the buffer returned in packet info to the
1796  *              descriptor pointed by 'used'. In Tx process, using the Tx
1797  *              descriptor return will merely return the user packet info with
1798  *              the command status of the transmitted buffer pointed by the
1799  *              'used' index. Nevertheless, it is essential to use this routine
1800  *              to update the 'used' index.
1801  *              'first'
1802  *              This index supports Tx Scatter-Gather. It points to the first
1803  *              descriptor of a packet assembled of multiple buffers. For
1804  *              example when in middle of Such packet we have a Tx resource
1805  *              error the 'curr' index get the value of 'first' to indicate
1806  *              that the ring returned to its state before trying to transmit
1807  *              this packet.
1808  *
1809  *              Receive operation:
1810  *              The eth_port_receive API set the packet information struct,
1811  *              passed by the caller, with received information from the
1812  *              'current' SDMA descriptor.
1813  *              It is the user responsibility to return this resource back
1814  *              to the Rx descriptor ring to enable the reuse of this source.
1815  *              Return Rx resource is done using the eth_rx_return_buff API.
1816  *
1817  *              Transmit operation:
1818  *              The eth_port_send API supports Scatter-Gather which enables to
1819  *              send a packet spanned over multiple buffers. This means that
1820  *              for each packet info structure given by the user and put into
1821  *              the Tx descriptors ring, will be transmitted only if the 'LAST'
1822  *              bit will be set in the packet info command status field. This
1823  *              API also consider restriction regarding buffer alignments and
1824  *              sizes.
1825  *              The user must return a Tx resource after ensuring the buffer
1826  *              has been transmitted to enable the Tx ring indexes to update.
1827  *
1828  *              BOARD LAYOUT
1829  *              This device is on-board.  No jumper diagram is necessary.
1830  *
1831  *              EXTERNAL INTERFACE
1832  *
1833  *      Prior to calling the initialization routine eth_port_init() the user
1834  *      must set the following fields under mv643xx_private struct:
1835  *      port_num                User Ethernet port number.
1836  *      port_config             User port configuration value.
1837  *      port_config_extend      User port config extend value.
1838  *      port_sdma_config        User port SDMA config value.
1839  *      port_serial_control     User port serial control value.
1840  *
1841  *              This driver data flow is done using the struct pkt_info which
1842  *              is a unified struct for Rx and Tx operations:
1843  *
1844  *              byte_cnt        Tx/Rx descriptor buffer byte count.
1845  *              l4i_chk         CPU provided TCP Checksum. For Tx operation
1846  *                              only.
1847  *              cmd_sts         Tx/Rx descriptor command status.
1848  *              buf_ptr         Tx/Rx descriptor buffer pointer.
1849  *              return_info     Tx/Rx user resource return information.
1850  */
1851
1852 /* PHY routines */
1853 static int ethernet_phy_get(unsigned int eth_port_num);
1854 static void ethernet_phy_set(unsigned int eth_port_num, int phy_addr);
1855
1856 /* Ethernet Port routines */
1857 static void eth_port_set_filter_table_entry(int table, unsigned char entry);
1858
1859 /*
1860  * eth_port_init - Initialize the Ethernet port driver
1861  *
1862  * DESCRIPTION:
1863  *      This function prepares the ethernet port to start its activity:
1864  *      1) Completes the ethernet port driver struct initialization toward port
1865  *              start routine.
1866  *      2) Resets the device to a quiescent state in case of warm reboot.
1867  *      3) Enable SDMA access to all four DRAM banks as well as internal SRAM.
1868  *      4) Clean MAC tables. The reset status of those tables is unknown.
1869  *      5) Set PHY address.
1870  *      Note: Call this routine prior to eth_port_start routine and after
1871  *      setting user values in the user fields of Ethernet port control
1872  *      struct.
1873  *
1874  * INPUT:
1875  *      struct mv643xx_private *mp      Ethernet port control struct
1876  *
1877  * OUTPUT:
1878  *      See description.
1879  *
1880  * RETURN:
1881  *      None.
1882  */
1883 static void eth_port_init(struct mv643xx_private *mp)
1884 {
1885         mp->rx_resource_err = 0;
1886         mp->tx_resource_err = 0;
1887
1888         eth_port_reset(mp->port_num);
1889
1890         eth_port_init_mac_tables(mp->port_num);
1891 }
1892
1893 /*
1894  * eth_port_start - Start the Ethernet port activity.
1895  *
1896  * DESCRIPTION:
1897  *      This routine prepares the Ethernet port for Rx and Tx activity:
1898  *       1. Initialize Tx and Rx Current Descriptor Pointer for each queue that
1899  *          has been initialized a descriptor's ring (using
1900  *          ether_init_tx_desc_ring for Tx and ether_init_rx_desc_ring for Rx)
1901  *       2. Initialize and enable the Ethernet configuration port by writing to
1902  *          the port's configuration and command registers.
1903  *       3. Initialize and enable the SDMA by writing to the SDMA's
1904  *          configuration and command registers.  After completing these steps,
1905  *          the ethernet port SDMA can starts to perform Rx and Tx activities.
1906  *
1907  *      Note: Each Rx and Tx queue descriptor's list must be initialized prior
1908  *      to calling this function (use ether_init_tx_desc_ring for Tx queues
1909  *      and ether_init_rx_desc_ring for Rx queues).
1910  *
1911  * INPUT:
1912  *      dev - a pointer to the required interface
1913  *
1914  * OUTPUT:
1915  *      Ethernet port is ready to receive and transmit.
1916  *
1917  * RETURN:
1918  *      None.
1919  */
1920 static void eth_port_start(struct net_device *dev)
1921 {
1922         struct mv643xx_private *mp = netdev_priv(dev);
1923         unsigned int port_num = mp->port_num;
1924         int tx_curr_desc, rx_curr_desc;
1925         u32 pscr;
1926         struct ethtool_cmd ethtool_cmd;
1927
1928         /* Assignment of Tx CTRP of given queue */
1929         tx_curr_desc = mp->tx_curr_desc_q;
1930         mv_write(MV643XX_ETH_TX_CURRENT_QUEUE_DESC_PTR_0(port_num),
1931                 (u32)((struct eth_tx_desc *)mp->tx_desc_dma + tx_curr_desc));
1932
1933         /* Assignment of Rx CRDP of given queue */
1934         rx_curr_desc = mp->rx_curr_desc_q;
1935         mv_write(MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_0(port_num),
1936                 (u32)((struct eth_rx_desc *)mp->rx_desc_dma + rx_curr_desc));
1937
1938         /* Add the assigned Ethernet address to the port's address table */
1939         eth_port_uc_addr_set(port_num, dev->dev_addr);
1940
1941         /* Assign port configuration and command. */
1942         mv_write(MV643XX_ETH_PORT_CONFIG_REG(port_num),
1943                           MV643XX_ETH_PORT_CONFIG_DEFAULT_VALUE);
1944
1945         mv_write(MV643XX_ETH_PORT_CONFIG_EXTEND_REG(port_num),
1946                           MV643XX_ETH_PORT_CONFIG_EXTEND_DEFAULT_VALUE);
1947
1948         pscr = mv_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
1949
1950         pscr &= ~(MV643XX_ETH_SERIAL_PORT_ENABLE | MV643XX_ETH_FORCE_LINK_PASS);
1951         mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num), pscr);
1952
1953         pscr |= MV643XX_ETH_DISABLE_AUTO_NEG_FOR_FLOW_CTRL |
1954                 MV643XX_ETH_DISABLE_AUTO_NEG_SPEED_GMII    |
1955                 MV643XX_ETH_DISABLE_AUTO_NEG_FOR_DUPLX     |
1956                 MV643XX_ETH_DO_NOT_FORCE_LINK_FAIL         |
1957                 MV643XX_ETH_SERIAL_PORT_CONTROL_RESERVED;
1958
1959         mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num), pscr);
1960
1961         pscr |= MV643XX_ETH_SERIAL_PORT_ENABLE;
1962         mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num), pscr);
1963
1964         /* Assign port SDMA configuration */
1965         mv_write(MV643XX_ETH_SDMA_CONFIG_REG(port_num),
1966                           MV643XX_ETH_PORT_SDMA_CONFIG_DEFAULT_VALUE);
1967
1968         /* Enable port Rx. */
1969         mv643xx_eth_port_enable_rx(port_num, mp->port_rx_queue_command);
1970
1971         /* Disable port bandwidth limits by clearing MTU register */
1972         mv_write(MV643XX_ETH_MAXIMUM_TRANSMIT_UNIT(port_num), 0);
1973
1974         /* save phy settings across reset */
1975         mv643xx_get_settings(dev, &ethtool_cmd);
1976         ethernet_phy_reset(mp->port_num);
1977         mv643xx_set_settings(dev, &ethtool_cmd);
1978 }
1979
1980 /*
1981  * eth_port_uc_addr_set - This function Set the port Unicast address.
1982  *
1983  * DESCRIPTION:
1984  *              This function Set the port Ethernet MAC address.
1985  *
1986  * INPUT:
1987  *      unsigned int    eth_port_num    Port number.
1988  *      char *          p_addr          Address to be set
1989  *
1990  * OUTPUT:
1991  *      Set MAC address low and high registers. also calls
1992  *      eth_port_set_filter_table_entry() to set the unicast
1993  *      table with the proper information.
1994  *
1995  * RETURN:
1996  *      N/A.
1997  *
1998  */
1999 static void eth_port_uc_addr_set(unsigned int eth_port_num,
2000                                                         unsigned char *p_addr)
2001 {
2002         unsigned int mac_h;
2003         unsigned int mac_l;
2004         int table;
2005
2006         mac_l = (p_addr[4] << 8) | (p_addr[5]);
2007         mac_h = (p_addr[0] << 24) | (p_addr[1] << 16) | (p_addr[2] << 8) |
2008                                                         (p_addr[3] << 0);
2009
2010         mv_write(MV643XX_ETH_MAC_ADDR_LOW(eth_port_num), mac_l);
2011         mv_write(MV643XX_ETH_MAC_ADDR_HIGH(eth_port_num), mac_h);
2012
2013         /* Accept frames of this address */
2014         table = MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE(eth_port_num);
2015         eth_port_set_filter_table_entry(table, p_addr[5] & 0x0f);
2016 }
2017
2018 /*
2019  * eth_port_uc_addr_get - This function retrieves the port Unicast address
2020  * (MAC address) from the ethernet hw registers.
2021  *
2022  * DESCRIPTION:
2023  *              This function retrieves the port Ethernet MAC address.
2024  *
2025  * INPUT:
2026  *      unsigned int    eth_port_num    Port number.
2027  *      char            *MacAddr        pointer where the MAC address is stored
2028  *
2029  * OUTPUT:
2030  *      Copy the MAC address to the location pointed to by MacAddr
2031  *
2032  * RETURN:
2033  *      N/A.
2034  *
2035  */
2036 static void eth_port_uc_addr_get(struct net_device *dev, unsigned char *p_addr)
2037 {
2038         struct mv643xx_private *mp = netdev_priv(dev);
2039         unsigned int mac_h;
2040         unsigned int mac_l;
2041
2042         mac_h = mv_read(MV643XX_ETH_MAC_ADDR_HIGH(mp->port_num));
2043         mac_l = mv_read(MV643XX_ETH_MAC_ADDR_LOW(mp->port_num));
2044
2045         p_addr[0] = (mac_h >> 24) & 0xff;
2046         p_addr[1] = (mac_h >> 16) & 0xff;
2047         p_addr[2] = (mac_h >> 8) & 0xff;
2048         p_addr[3] = mac_h & 0xff;
2049         p_addr[4] = (mac_l >> 8) & 0xff;
2050         p_addr[5] = mac_l & 0xff;
2051 }
2052
2053 /*
2054  * The entries in each table are indexed by a hash of a packet's MAC
2055  * address.  One bit in each entry determines whether the packet is
2056  * accepted.  There are 4 entries (each 8 bits wide) in each register
2057  * of the table.  The bits in each entry are defined as follows:
2058  *      0       Accept=1, Drop=0
2059  *      3-1     Queue                   (ETH_Q0=0)
2060  *      7-4     Reserved = 0;
2061  */
2062 static void eth_port_set_filter_table_entry(int table, unsigned char entry)
2063 {
2064         unsigned int table_reg;
2065         unsigned int tbl_offset;
2066         unsigned int reg_offset;
2067
2068         tbl_offset = (entry / 4) * 4;   /* Register offset of DA table entry */
2069         reg_offset = entry % 4;         /* Entry offset within the register */
2070
2071         /* Set "accepts frame bit" at specified table entry */
2072         table_reg = mv_read(table + tbl_offset);
2073         table_reg |= 0x01 << (8 * reg_offset);
2074         mv_write(table + tbl_offset, table_reg);
2075 }
2076
2077 /*
2078  * eth_port_mc_addr - Multicast address settings.
2079  *
2080  * The MV device supports multicast using two tables:
2081  * 1) Special Multicast Table for MAC addresses of the form
2082  *    0x01-00-5E-00-00-XX (where XX is between 0x00 and 0x_FF).
2083  *    The MAC DA[7:0] bits are used as a pointer to the Special Multicast
2084  *    Table entries in the DA-Filter table.
2085  * 2) Other Multicast Table for multicast of another type. A CRC-8bit
2086  *    is used as an index to the Other Multicast Table entries in the
2087  *    DA-Filter table.  This function calculates the CRC-8bit value.
2088  * In either case, eth_port_set_filter_table_entry() is then called
2089  * to set to set the actual table entry.
2090  */
2091 static void eth_port_mc_addr(unsigned int eth_port_num, unsigned char *p_addr)
2092 {
2093         unsigned int mac_h;
2094         unsigned int mac_l;
2095         unsigned char crc_result = 0;
2096         int table;
2097         int mac_array[48];
2098         int crc[8];
2099         int i;
2100
2101         if ((p_addr[0] == 0x01) && (p_addr[1] == 0x00) &&
2102             (p_addr[2] == 0x5E) && (p_addr[3] == 0x00) && (p_addr[4] == 0x00)) {
2103                 table = MV643XX_ETH_DA_FILTER_SPECIAL_MULTICAST_TABLE_BASE
2104                                         (eth_port_num);
2105                 eth_port_set_filter_table_entry(table, p_addr[5]);
2106                 return;
2107         }
2108
2109         /* Calculate CRC-8 out of the given address */
2110         mac_h = (p_addr[0] << 8) | (p_addr[1]);
2111         mac_l = (p_addr[2] << 24) | (p_addr[3] << 16) |
2112                         (p_addr[4] << 8) | (p_addr[5] << 0);
2113
2114         for (i = 0; i < 32; i++)
2115                 mac_array[i] = (mac_l >> i) & 0x1;
2116         for (i = 32; i < 48; i++)
2117                 mac_array[i] = (mac_h >> (i - 32)) & 0x1;
2118
2119         crc[0] = mac_array[45] ^ mac_array[43] ^ mac_array[40] ^ mac_array[39] ^
2120                  mac_array[35] ^ mac_array[34] ^ mac_array[31] ^ mac_array[30] ^
2121                  mac_array[28] ^ mac_array[23] ^ mac_array[21] ^ mac_array[19] ^
2122                  mac_array[18] ^ mac_array[16] ^ mac_array[14] ^ mac_array[12] ^
2123                  mac_array[8]  ^ mac_array[7]  ^ mac_array[6]  ^ mac_array[0];
2124
2125         crc[1] = mac_array[46] ^ mac_array[45] ^ mac_array[44] ^ mac_array[43] ^
2126                  mac_array[41] ^ mac_array[39] ^ mac_array[36] ^ mac_array[34] ^
2127                  mac_array[32] ^ mac_array[30] ^ mac_array[29] ^ mac_array[28] ^
2128                  mac_array[24] ^ mac_array[23] ^ mac_array[22] ^ mac_array[21] ^
2129                  mac_array[20] ^ mac_array[18] ^ mac_array[17] ^ mac_array[16] ^
2130                  mac_array[15] ^ mac_array[14] ^ mac_array[13] ^ mac_array[12] ^
2131                  mac_array[9]  ^ mac_array[6]  ^ mac_array[1]  ^ mac_array[0];
2132
2133         crc[2] = mac_array[47] ^ mac_array[46] ^ mac_array[44] ^ mac_array[43] ^
2134                  mac_array[42] ^ mac_array[39] ^ mac_array[37] ^ mac_array[34] ^
2135                  mac_array[33] ^ mac_array[29] ^ mac_array[28] ^ mac_array[25] ^
2136                  mac_array[24] ^ mac_array[22] ^ mac_array[17] ^ mac_array[15] ^
2137                  mac_array[13] ^ mac_array[12] ^ mac_array[10] ^ mac_array[8]  ^
2138                  mac_array[6]  ^ mac_array[2]  ^ mac_array[1]  ^ mac_array[0];
2139
2140         crc[3] = mac_array[47] ^ mac_array[45] ^ mac_array[44] ^ mac_array[43] ^
2141                  mac_array[40] ^ mac_array[38] ^ mac_array[35] ^ mac_array[34] ^
2142                  mac_array[30] ^ mac_array[29] ^ mac_array[26] ^ mac_array[25] ^
2143                  mac_array[23] ^ mac_array[18] ^ mac_array[16] ^ mac_array[14] ^
2144                  mac_array[13] ^ mac_array[11] ^ mac_array[9]  ^ mac_array[7]  ^
2145                  mac_array[3]  ^ mac_array[2]  ^ mac_array[1];
2146
2147         crc[4] = mac_array[46] ^ mac_array[45] ^ mac_array[44] ^ mac_array[41] ^
2148                  mac_array[39] ^ mac_array[36] ^ mac_array[35] ^ mac_array[31] ^
2149                  mac_array[30] ^ mac_array[27] ^ mac_array[26] ^ mac_array[24] ^
2150                  mac_array[19] ^ mac_array[17] ^ mac_array[15] ^ mac_array[14] ^
2151                  mac_array[12] ^ mac_array[10] ^ mac_array[8]  ^ mac_array[4]  ^
2152                  mac_array[3]  ^ mac_array[2];
2153
2154         crc[5] = mac_array[47] ^ mac_array[46] ^ mac_array[45] ^ mac_array[42] ^
2155                  mac_array[40] ^ mac_array[37] ^ mac_array[36] ^ mac_array[32] ^
2156                  mac_array[31] ^ mac_array[28] ^ mac_array[27] ^ mac_array[25] ^
2157                  mac_array[20] ^ mac_array[18] ^ mac_array[16] ^ mac_array[15] ^
2158                  mac_array[13] ^ mac_array[11] ^ mac_array[9]  ^ mac_array[5]  ^
2159                  mac_array[4]  ^ mac_array[3];
2160
2161         crc[6] = mac_array[47] ^ mac_array[46] ^ mac_array[43] ^ mac_array[41] ^
2162                  mac_array[38] ^ mac_array[37] ^ mac_array[33] ^ mac_array[32] ^
2163                  mac_array[29] ^ mac_array[28] ^ mac_array[26] ^ mac_array[21] ^
2164                  mac_array[19] ^ mac_array[17] ^ mac_array[16] ^ mac_array[14] ^
2165                  mac_array[12] ^ mac_array[10] ^ mac_array[6]  ^ mac_array[5]  ^
2166                  mac_array[4];
2167
2168         crc[7] = mac_array[47] ^ mac_array[44] ^ mac_array[42] ^ mac_array[39] ^
2169                  mac_array[38] ^ mac_array[34] ^ mac_array[33] ^ mac_array[30] ^
2170                  mac_array[29] ^ mac_array[27] ^ mac_array[22] ^ mac_array[20] ^
2171                  mac_array[18] ^ mac_array[17] ^ mac_array[15] ^ mac_array[13] ^
2172                  mac_array[11] ^ mac_array[7]  ^ mac_array[6]  ^ mac_array[5];
2173
2174         for (i = 0; i < 8; i++)
2175                 crc_result = crc_result | (crc[i] << i);
2176
2177         table = MV643XX_ETH_DA_FILTER_OTHER_MULTICAST_TABLE_BASE(eth_port_num);
2178         eth_port_set_filter_table_entry(table, crc_result);
2179 }
2180
2181 /*
2182  * Set the entire multicast list based on dev->mc_list.
2183  */
2184 static void eth_port_set_multicast_list(struct net_device *dev)
2185 {
2186
2187         struct dev_mc_list      *mc_list;
2188         int                     i;
2189         int                     table_index;
2190         struct mv643xx_private  *mp = netdev_priv(dev);
2191         unsigned int            eth_port_num = mp->port_num;
2192
2193         /* If the device is in promiscuous mode or in all multicast mode,
2194          * we will fully populate both multicast tables with accept.
2195          * This is guaranteed to yield a match on all multicast addresses...
2196          */
2197         if ((dev->flags & IFF_PROMISC) || (dev->flags & IFF_ALLMULTI)) {
2198                 for (table_index = 0; table_index <= 0xFC; table_index += 4) {
2199                         /* Set all entries in DA filter special multicast
2200                          * table (Ex_dFSMT)
2201                          * Set for ETH_Q0 for now
2202                          * Bits
2203                          * 0      Accept=1, Drop=0
2204                          * 3-1  Queue    ETH_Q0=0
2205                          * 7-4  Reserved = 0;
2206                          */
2207                         mv_write(MV643XX_ETH_DA_FILTER_SPECIAL_MULTICAST_TABLE_BASE(eth_port_num) + table_index, 0x01010101);
2208
2209                         /* Set all entries in DA filter other multicast
2210                          * table (Ex_dFOMT)
2211                          * Set for ETH_Q0 for now
2212                          * Bits
2213                          * 0      Accept=1, Drop=0
2214                          * 3-1  Queue    ETH_Q0=0
2215                          * 7-4  Reserved = 0;
2216                          */
2217                         mv_write(MV643XX_ETH_DA_FILTER_OTHER_MULTICAST_TABLE_BASE(eth_port_num) + table_index, 0x01010101);
2218                 }
2219                 return;
2220         }
2221
2222         /* We will clear out multicast tables every time we get the list.
2223          * Then add the entire new list...
2224          */
2225         for (table_index = 0; table_index <= 0xFC; table_index += 4) {
2226                 /* Clear DA filter special multicast table (Ex_dFSMT) */
2227                 mv_write(MV643XX_ETH_DA_FILTER_SPECIAL_MULTICAST_TABLE_BASE
2228                                 (eth_port_num) + table_index, 0);
2229
2230                 /* Clear DA filter other multicast table (Ex_dFOMT) */
2231                 mv_write(MV643XX_ETH_DA_FILTER_OTHER_MULTICAST_TABLE_BASE
2232                                 (eth_port_num) + table_index, 0);
2233         }
2234
2235         /* Get pointer to net_device multicast list and add each one... */
2236         for (i = 0, mc_list = dev->mc_list;
2237                         (i < 256) && (mc_list != NULL) && (i < dev->mc_count);
2238                         i++, mc_list = mc_list->next)
2239                 if (mc_list->dmi_addrlen == 6)
2240                         eth_port_mc_addr(eth_port_num, mc_list->dmi_addr);
2241 }
2242
2243 /*
2244  * eth_port_init_mac_tables - Clear all entrance in the UC, SMC and OMC tables
2245  *
2246  * DESCRIPTION:
2247  *      Go through all the DA filter tables (Unicast, Special Multicast &
2248  *      Other Multicast) and set each entry to 0.
2249  *
2250  * INPUT:
2251  *      unsigned int    eth_port_num    Ethernet Port number.
2252  *
2253  * OUTPUT:
2254  *      Multicast and Unicast packets are rejected.
2255  *
2256  * RETURN:
2257  *      None.
2258  */
2259 static void eth_port_init_mac_tables(unsigned int eth_port_num)
2260 {
2261         int table_index;
2262
2263         /* Clear DA filter unicast table (Ex_dFUT) */
2264         for (table_index = 0; table_index <= 0xC; table_index += 4)
2265                 mv_write(MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE
2266                                         (eth_port_num) + table_index, 0);
2267
2268         for (table_index = 0; table_index <= 0xFC; table_index += 4) {
2269                 /* Clear DA filter special multicast table (Ex_dFSMT) */
2270                 mv_write(MV643XX_ETH_DA_FILTER_SPECIAL_MULTICAST_TABLE_BASE
2271                                         (eth_port_num) + table_index, 0);
2272                 /* Clear DA filter other multicast table (Ex_dFOMT) */
2273                 mv_write(MV643XX_ETH_DA_FILTER_OTHER_MULTICAST_TABLE_BASE
2274                                         (eth_port_num) + table_index, 0);
2275         }
2276 }
2277
2278 /*
2279  * eth_clear_mib_counters - Clear all MIB counters
2280  *
2281  * DESCRIPTION:
2282  *      This function clears all MIB counters of a specific ethernet port.
2283  *      A read from the MIB counter will reset the counter.
2284  *
2285  * INPUT:
2286  *      unsigned int    eth_port_num    Ethernet Port number.
2287  *
2288  * OUTPUT:
2289  *      After reading all MIB counters, the counters resets.
2290  *
2291  * RETURN:
2292  *      MIB counter value.
2293  *
2294  */
2295 static void eth_clear_mib_counters(unsigned int eth_port_num)
2296 {
2297         int i;
2298
2299         /* Perform dummy reads from MIB counters */
2300         for (i = ETH_MIB_GOOD_OCTETS_RECEIVED_LOW; i < ETH_MIB_LATE_COLLISION;
2301                                                                         i += 4)
2302                 mv_read(MV643XX_ETH_MIB_COUNTERS_BASE(eth_port_num) + i);
2303 }
2304
2305 static inline u32 read_mib(struct mv643xx_private *mp, int offset)
2306 {
2307         return mv_read(MV643XX_ETH_MIB_COUNTERS_BASE(mp->port_num) + offset);
2308 }
2309
2310 static void eth_update_mib_counters(struct mv643xx_private *mp)
2311 {
2312         struct mv643xx_mib_counters *p = &mp->mib_counters;
2313         int offset;
2314
2315         p->good_octets_received +=
2316                 read_mib(mp, ETH_MIB_GOOD_OCTETS_RECEIVED_LOW);
2317         p->good_octets_received +=
2318                 (u64)read_mib(mp, ETH_MIB_GOOD_OCTETS_RECEIVED_HIGH) << 32;
2319
2320         for (offset = ETH_MIB_BAD_OCTETS_RECEIVED;
2321                         offset <= ETH_MIB_FRAMES_1024_TO_MAX_OCTETS;
2322                         offset += 4)
2323                 *(u32 *)((char *)p + offset) = read_mib(mp, offset);
2324
2325         p->good_octets_sent += read_mib(mp, ETH_MIB_GOOD_OCTETS_SENT_LOW);
2326         p->good_octets_sent +=
2327                 (u64)read_mib(mp, ETH_MIB_GOOD_OCTETS_SENT_HIGH) << 32;
2328
2329         for (offset = ETH_MIB_GOOD_FRAMES_SENT;
2330                         offset <= ETH_MIB_LATE_COLLISION;
2331                         offset += 4)
2332                 *(u32 *)((char *)p + offset) = read_mib(mp, offset);
2333 }
2334
2335 /*
2336  * ethernet_phy_detect - Detect whether a phy is present
2337  *
2338  * DESCRIPTION:
2339  *      This function tests whether there is a PHY present on
2340  *      the specified port.
2341  *
2342  * INPUT:
2343  *      unsigned int    eth_port_num    Ethernet Port number.
2344  *
2345  * OUTPUT:
2346  *      None
2347  *
2348  * RETURN:
2349  *      0 on success
2350  *      -ENODEV on failure
2351  *
2352  */
2353 static int ethernet_phy_detect(unsigned int port_num)
2354 {
2355         unsigned int phy_reg_data0;
2356         int auto_neg;
2357
2358         eth_port_read_smi_reg(port_num, 0, &phy_reg_data0);
2359         auto_neg = phy_reg_data0 & 0x1000;
2360         phy_reg_data0 ^= 0x1000;        /* invert auto_neg */
2361         eth_port_write_smi_reg(port_num, 0, phy_reg_data0);
2362
2363         eth_port_read_smi_reg(port_num, 0, &phy_reg_data0);
2364         if ((phy_reg_data0 & 0x1000) == auto_neg)
2365                 return -ENODEV;                         /* change didn't take */
2366
2367         phy_reg_data0 ^= 0x1000;
2368         eth_port_write_smi_reg(port_num, 0, phy_reg_data0);
2369         return 0;
2370 }
2371
2372 /*
2373  * ethernet_phy_get - Get the ethernet port PHY address.
2374  *
2375  * DESCRIPTION:
2376  *      This routine returns the given ethernet port PHY address.
2377  *
2378  * INPUT:
2379  *      unsigned int    eth_port_num    Ethernet Port number.
2380  *
2381  * OUTPUT:
2382  *      None.
2383  *
2384  * RETURN:
2385  *      PHY address.
2386  *
2387  */
2388 static int ethernet_phy_get(unsigned int eth_port_num)
2389 {
2390         unsigned int reg_data;
2391
2392         reg_data = mv_read(MV643XX_ETH_PHY_ADDR_REG);
2393
2394         return ((reg_data >> (5 * eth_port_num)) & 0x1f);
2395 }
2396
2397 /*
2398  * ethernet_phy_set - Set the ethernet port PHY address.
2399  *
2400  * DESCRIPTION:
2401  *      This routine sets the given ethernet port PHY address.
2402  *
2403  * INPUT:
2404  *      unsigned int    eth_port_num    Ethernet Port number.
2405  *      int             phy_addr        PHY address.
2406  *
2407  * OUTPUT:
2408  *      None.
2409  *
2410  * RETURN:
2411  *      None.
2412  *
2413  */
2414 static void ethernet_phy_set(unsigned int eth_port_num, int phy_addr)
2415 {
2416         u32 reg_data;
2417         int addr_shift = 5 * eth_port_num;
2418
2419         reg_data = mv_read(MV643XX_ETH_PHY_ADDR_REG);
2420         reg_data &= ~(0x1f << addr_shift);
2421         reg_data |= (phy_addr & 0x1f) << addr_shift;
2422         mv_write(MV643XX_ETH_PHY_ADDR_REG, reg_data);
2423 }
2424
2425 /*
2426  * ethernet_phy_reset - Reset Ethernet port PHY.
2427  *
2428  * DESCRIPTION:
2429  *      This routine utilizes the SMI interface to reset the ethernet port PHY.
2430  *
2431  * INPUT:
2432  *      unsigned int    eth_port_num    Ethernet Port number.
2433  *
2434  * OUTPUT:
2435  *      The PHY is reset.
2436  *
2437  * RETURN:
2438  *      None.
2439  *
2440  */
2441 static void ethernet_phy_reset(unsigned int eth_port_num)
2442 {
2443         unsigned int phy_reg_data;
2444
2445         /* Reset the PHY */
2446         eth_port_read_smi_reg(eth_port_num, 0, &phy_reg_data);
2447         phy_reg_data |= 0x8000; /* Set bit 15 to reset the PHY */
2448         eth_port_write_smi_reg(eth_port_num, 0, phy_reg_data);
2449
2450         /* wait for PHY to come out of reset */
2451         do {
2452                 udelay(1);
2453                 eth_port_read_smi_reg(eth_port_num, 0, &phy_reg_data);
2454         } while (phy_reg_data & 0x8000);
2455 }
2456
2457 static void mv643xx_eth_port_enable_tx(unsigned int port_num,
2458                                         unsigned int channels)
2459 {
2460         mv_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num), channels);
2461 }
2462
2463 static void mv643xx_eth_port_enable_rx(unsigned int port_num,
2464                                         unsigned int channels)
2465 {
2466         mv_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num), channels);
2467 }
2468
2469 static unsigned int mv643xx_eth_port_disable_tx(unsigned int port_num)
2470 {
2471         u32 channels;
2472
2473         /* Stop Tx port activity. Check port Tx activity. */
2474         channels = mv_read(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num))
2475                                                         & 0xFF;
2476         if (channels) {
2477                 /* Issue stop command for active channels only */
2478                 mv_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num),
2479                                                         (channels << 8));
2480
2481                 /* Wait for all Tx activity to terminate. */
2482                 /* Check port cause register that all Tx queues are stopped */
2483                 while (mv_read(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num))
2484                                                         & 0xFF)
2485                         udelay(PHY_WAIT_MICRO_SECONDS);
2486
2487                 /* Wait for Tx FIFO to empty */
2488                 while (mv_read(MV643XX_ETH_PORT_STATUS_REG(port_num)) &
2489                                                         ETH_PORT_TX_FIFO_EMPTY)
2490                         udelay(PHY_WAIT_MICRO_SECONDS);
2491         }
2492
2493         return channels;
2494 }
2495
2496 static unsigned int mv643xx_eth_port_disable_rx(unsigned int port_num)
2497 {
2498         u32 channels;
2499
2500         /* Stop Rx port activity. Check port Rx activity. */
2501         channels = mv_read(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num)
2502                                                         & 0xFF);
2503         if (channels) {
2504                 /* Issue stop command for active channels only */
2505                 mv_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num),
2506                                                         (channels << 8));
2507
2508                 /* Wait for all Rx activity to terminate. */
2509                 /* Check port cause register that all Rx queues are stopped */
2510                 while (mv_read(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num))
2511                                                         & 0xFF)
2512                         udelay(PHY_WAIT_MICRO_SECONDS);
2513         }
2514
2515         return channels;
2516 }
2517
2518 /*
2519  * eth_port_reset - Reset Ethernet port
2520  *
2521  * DESCRIPTION:
2522  *      This routine resets the chip by aborting any SDMA engine activity and
2523  *      clearing the MIB counters. The Receiver and the Transmit unit are in
2524  *      idle state after this command is performed and the port is disabled.
2525  *
2526  * INPUT:
2527  *      unsigned int    eth_port_num    Ethernet Port number.
2528  *
2529  * OUTPUT:
2530  *      Channel activity is halted.
2531  *
2532  * RETURN:
2533  *      None.
2534  *
2535  */
2536 static void eth_port_reset(unsigned int port_num)
2537 {
2538         unsigned int reg_data;
2539
2540         mv643xx_eth_port_disable_tx(port_num);
2541         mv643xx_eth_port_disable_rx(port_num);
2542
2543         /* Clear all MIB counters */
2544         eth_clear_mib_counters(port_num);
2545
2546         /* Reset the Enable bit in the Configuration Register */
2547         reg_data = mv_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
2548         reg_data &= ~(MV643XX_ETH_SERIAL_PORT_ENABLE            |
2549                         MV643XX_ETH_DO_NOT_FORCE_LINK_FAIL      |
2550                         MV643XX_ETH_FORCE_LINK_PASS);
2551         mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num), reg_data);
2552 }
2553
2554
2555 /*
2556  * eth_port_read_smi_reg - Read PHY registers
2557  *
2558  * DESCRIPTION:
2559  *      This routine utilize the SMI interface to interact with the PHY in
2560  *      order to perform PHY register read.
2561  *
2562  * INPUT:
2563  *      unsigned int    port_num        Ethernet Port number.
2564  *      unsigned int    phy_reg         PHY register address offset.
2565  *      unsigned int    *value          Register value buffer.
2566  *
2567  * OUTPUT:
2568  *      Write the value of a specified PHY register into given buffer.
2569  *
2570  * RETURN:
2571  *      false if the PHY is busy or read data is not in valid state.
2572  *      true otherwise.
2573  *
2574  */
2575 static void eth_port_read_smi_reg(unsigned int port_num,
2576                                 unsigned int phy_reg, unsigned int *value)
2577 {
2578         int phy_addr = ethernet_phy_get(port_num);
2579         unsigned long flags;
2580         int i;
2581
2582         /* the SMI register is a shared resource */
2583         spin_lock_irqsave(&mv643xx_eth_phy_lock, flags);
2584
2585         /* wait for the SMI register to become available */
2586         for (i = 0; mv_read(MV643XX_ETH_SMI_REG) & ETH_SMI_BUSY; i++) {
2587                 if (i == PHY_WAIT_ITERATIONS) {
2588                         printk("mv643xx PHY busy timeout, port %d\n", port_num);
2589                         goto out;
2590                 }
2591                 udelay(PHY_WAIT_MICRO_SECONDS);
2592         }
2593
2594         mv_write(MV643XX_ETH_SMI_REG,
2595                 (phy_addr << 16) | (phy_reg << 21) | ETH_SMI_OPCODE_READ);
2596
2597         /* now wait for the data to be valid */
2598         for (i = 0; !(mv_read(MV643XX_ETH_SMI_REG) & ETH_SMI_READ_VALID); i++) {
2599                 if (i == PHY_WAIT_ITERATIONS) {
2600                         printk("mv643xx PHY read timeout, port %d\n", port_num);
2601                         goto out;
2602                 }
2603                 udelay(PHY_WAIT_MICRO_SECONDS);
2604         }
2605
2606         *value = mv_read(MV643XX_ETH_SMI_REG) & 0xffff;
2607 out:
2608         spin_unlock_irqrestore(&mv643xx_eth_phy_lock, flags);
2609 }
2610
2611 /*
2612  * eth_port_write_smi_reg - Write to PHY registers
2613  *
2614  * DESCRIPTION:
2615  *      This routine utilize the SMI interface to interact with the PHY in
2616  *      order to perform writes to PHY registers.
2617  *
2618  * INPUT:
2619  *      unsigned int    eth_port_num    Ethernet Port number.
2620  *      unsigned int    phy_reg         PHY register address offset.
2621  *      unsigned int    value           Register value.
2622  *
2623  * OUTPUT:
2624  *      Write the given value to the specified PHY register.
2625  *
2626  * RETURN:
2627  *      false if the PHY is busy.
2628  *      true otherwise.
2629  *
2630  */
2631 static void eth_port_write_smi_reg(unsigned int eth_port_num,
2632                                    unsigned int phy_reg, unsigned int value)
2633 {
2634         int phy_addr;
2635         int i;
2636         unsigned long flags;
2637
2638         phy_addr = ethernet_phy_get(eth_port_num);
2639
2640         /* the SMI register is a shared resource */
2641         spin_lock_irqsave(&mv643xx_eth_phy_lock, flags);
2642
2643         /* wait for the SMI register to become available */
2644         for (i = 0; mv_read(MV643XX_ETH_SMI_REG) & ETH_SMI_BUSY; i++) {
2645                 if (i == PHY_WAIT_ITERATIONS) {
2646                         printk("mv643xx PHY busy timeout, port %d\n",
2647                                                                 eth_port_num);
2648                         goto out;
2649                 }
2650                 udelay(PHY_WAIT_MICRO_SECONDS);
2651         }
2652
2653         mv_write(MV643XX_ETH_SMI_REG, (phy_addr << 16) | (phy_reg << 21) |
2654                                 ETH_SMI_OPCODE_WRITE | (value & 0xffff));
2655 out:
2656         spin_unlock_irqrestore(&mv643xx_eth_phy_lock, flags);
2657 }
2658
2659 /*
2660  * Wrappers for MII support library.
2661  */
2662 static int mv643xx_mdio_read(struct net_device *dev, int phy_id, int location)
2663 {
2664         int val;
2665         struct mv643xx_private *mp = netdev_priv(dev);
2666
2667         eth_port_read_smi_reg(mp->port_num, location, &val);
2668         return val;
2669 }
2670
2671 static void mv643xx_mdio_write(struct net_device *dev, int phy_id, int location, int val)
2672 {
2673         struct mv643xx_private *mp = netdev_priv(dev);
2674         eth_port_write_smi_reg(mp->port_num, location, val);
2675 }
2676
2677 /*
2678  * eth_port_send - Send an Ethernet packet
2679  *
2680  * DESCRIPTION:
2681  *      This routine send a given packet described by p_pktinfo parameter. It
2682  *      supports transmitting of a packet spaned over multiple buffers. The
2683  *      routine updates 'curr' and 'first' indexes according to the packet
2684  *      segment passed to the routine. In case the packet segment is first,
2685  *      the 'first' index is update. In any case, the 'curr' index is updated.
2686  *      If the routine get into Tx resource error it assigns 'curr' index as
2687  *      'first'. This way the function can abort Tx process of multiple
2688  *      descriptors per packet.
2689  *
2690  * INPUT:
2691  *      struct mv643xx_private  *mp             Ethernet Port Control srtuct.
2692  *      struct pkt_info         *p_pkt_info     User packet buffer.
2693  *
2694  * OUTPUT:
2695  *      Tx ring 'curr' and 'first' indexes are updated.
2696  *
2697  * RETURN:
2698  *      ETH_QUEUE_FULL in case of Tx resource error.
2699  *      ETH_ERROR in case the routine can not access Tx desc ring.
2700  *      ETH_QUEUE_LAST_RESOURCE if the routine uses the last Tx resource.
2701  *      ETH_OK otherwise.
2702  *
2703  */
2704 #ifdef MV643XX_CHECKSUM_OFFLOAD_TX
2705 /*
2706  * Modified to include the first descriptor pointer in case of SG
2707  */
2708 static ETH_FUNC_RET_STATUS eth_port_send(struct mv643xx_private *mp,
2709                                          struct pkt_info *p_pkt_info)
2710 {
2711         int tx_desc_curr, tx_desc_used, tx_first_desc, tx_next_desc;
2712         struct eth_tx_desc *current_descriptor;
2713         struct eth_tx_desc *first_descriptor;
2714         u32 command;
2715
2716         /* Do not process Tx ring in case of Tx ring resource error */
2717         if (mp->tx_resource_err)
2718                 return ETH_QUEUE_FULL;
2719
2720         /*
2721          * The hardware requires that each buffer that is <= 8 bytes
2722          * in length must be aligned on an 8 byte boundary.
2723          */
2724         if (p_pkt_info->byte_cnt <= 8 && p_pkt_info->buf_ptr & 0x7) {
2725                 printk(KERN_ERR
2726                         "mv643xx_eth port %d: packet size <= 8 problem\n",
2727                         mp->port_num);
2728                 return ETH_ERROR;
2729         }
2730
2731         mp->tx_desc_count++;
2732         BUG_ON(mp->tx_desc_count > mp->tx_ring_size);
2733
2734         /* Get the Tx Desc ring indexes */
2735         tx_desc_curr = mp->tx_curr_desc_q;
2736         tx_desc_used = mp->tx_used_desc_q;
2737
2738         current_descriptor = &mp->p_tx_desc_area[tx_desc_curr];
2739
2740         tx_next_desc = (tx_desc_curr + 1) % mp->tx_ring_size;
2741
2742         current_descriptor->buf_ptr = p_pkt_info->buf_ptr;
2743         current_descriptor->byte_cnt = p_pkt_info->byte_cnt;
2744         current_descriptor->l4i_chk = p_pkt_info->l4i_chk;
2745         mp->tx_skb[tx_desc_curr] = p_pkt_info->return_info;
2746
2747         command = p_pkt_info->cmd_sts | ETH_ZERO_PADDING | ETH_GEN_CRC |
2748                                                         ETH_BUFFER_OWNED_BY_DMA;
2749         if (command & ETH_TX_FIRST_DESC) {
2750                 tx_first_desc = tx_desc_curr;
2751                 mp->tx_first_desc_q = tx_first_desc;
2752                 first_descriptor = current_descriptor;
2753                 mp->tx_first_command = command;
2754         } else {
2755                 tx_first_desc = mp->tx_first_desc_q;
2756                 first_descriptor = &mp->p_tx_desc_area[tx_first_desc];
2757                 BUG_ON(first_descriptor == NULL);
2758                 current_descriptor->cmd_sts = command;
2759         }
2760
2761         if (command & ETH_TX_LAST_DESC) {
2762                 wmb();
2763                 first_descriptor->cmd_sts = mp->tx_first_command;
2764
2765                 wmb();
2766                 mv643xx_eth_port_enable_tx(mp->port_num, mp->port_tx_queue_command);
2767
2768                 /*
2769                  * Finish Tx packet. Update first desc in case of Tx resource
2770                  * error */
2771                 tx_first_desc = tx_next_desc;
2772                 mp->tx_first_desc_q = tx_first_desc;
2773         }
2774
2775         /* Check for ring index overlap in the Tx desc ring */
2776         if (tx_next_desc == tx_desc_used) {
2777                 mp->tx_resource_err = 1;
2778                 mp->tx_curr_desc_q = tx_first_desc;
2779
2780                 return ETH_QUEUE_LAST_RESOURCE;
2781         }
2782
2783         mp->tx_curr_desc_q = tx_next_desc;
2784
2785         return ETH_OK;
2786 }
2787 #else
2788 static ETH_FUNC_RET_STATUS eth_port_send(struct mv643xx_private *mp,
2789                                          struct pkt_info *p_pkt_info)
2790 {
2791         int tx_desc_curr;
2792         int tx_desc_used;
2793         struct eth_tx_desc *current_descriptor;
2794         unsigned int command_status;
2795
2796         /* Do not process Tx ring in case of Tx ring resource error */
2797         if (mp->tx_resource_err)
2798                 return ETH_QUEUE_FULL;
2799
2800         mp->tx_desc_count++;
2801         BUG_ON(mp->tx_desc_count > mp->tx_ring_size);
2802
2803         /* Get the Tx Desc ring indexes */
2804         tx_desc_curr = mp->tx_curr_desc_q;
2805         tx_desc_used = mp->tx_used_desc_q;
2806         current_descriptor = &mp->p_tx_desc_area[tx_desc_curr];
2807
2808         command_status = p_pkt_info->cmd_sts | ETH_ZERO_PADDING | ETH_GEN_CRC;
2809         current_descriptor->buf_ptr = p_pkt_info->buf_ptr;
2810         current_descriptor->byte_cnt = p_pkt_info->byte_cnt;
2811         mp->tx_skb[tx_desc_curr] = p_pkt_info->return_info;
2812
2813         /* Set last desc with DMA ownership and interrupt enable. */
2814         wmb();
2815         current_descriptor->cmd_sts = command_status |
2816                         ETH_BUFFER_OWNED_BY_DMA | ETH_TX_ENABLE_INTERRUPT;
2817
2818         wmb();
2819         mv643xx_eth_port_enable_tx(mp->port_num, mp->port_tx_queue_command);
2820
2821         /* Finish Tx packet. Update first desc in case of Tx resource error */
2822         tx_desc_curr = (tx_desc_curr + 1) % mp->tx_ring_size;
2823
2824         /* Update the current descriptor */
2825         mp->tx_curr_desc_q = tx_desc_curr;
2826
2827         /* Check for ring index overlap in the Tx desc ring */
2828         if (tx_desc_curr == tx_desc_used) {
2829                 mp->tx_resource_err = 1;
2830                 return ETH_QUEUE_LAST_RESOURCE;
2831         }
2832
2833         return ETH_OK;
2834 }
2835 #endif
2836
2837 /*
2838  * eth_tx_return_desc - Free all used Tx descriptors
2839  *
2840  * DESCRIPTION:
2841  *      This routine returns the transmitted packet information to the caller.
2842  *      It uses the 'first' index to support Tx desc return in case a transmit
2843  *      of a packet spanned over multiple buffer still in process.
2844  *      In case the Tx queue was in "resource error" condition, where there are
2845  *      no available Tx resources, the function resets the resource error flag.
2846  *
2847  * INPUT:
2848  *      struct mv643xx_private  *mp             Ethernet Port Control srtuct.
2849  *      struct pkt_info         *p_pkt_info     User packet buffer.
2850  *
2851  * OUTPUT:
2852  *      Tx ring 'first' and 'used' indexes are updated.
2853  *
2854  * RETURN:
2855  *      ETH_OK on success
2856  *      ETH_ERROR otherwise.
2857  *
2858  */
2859 static ETH_FUNC_RET_STATUS eth_tx_return_desc(struct mv643xx_private *mp,
2860                                                 struct pkt_info *p_pkt_info)
2861 {
2862         int tx_desc_used;
2863         int tx_busy_desc;
2864         struct eth_tx_desc *p_tx_desc_used;
2865         unsigned int command_status;
2866         unsigned long flags;
2867         int err = ETH_OK;
2868
2869         spin_lock_irqsave(&mp->lock, flags);
2870
2871 #ifdef MV643XX_CHECKSUM_OFFLOAD_TX
2872         tx_busy_desc = mp->tx_first_desc_q;
2873 #else
2874         tx_busy_desc = mp->tx_curr_desc_q;
2875 #endif
2876
2877         /* Get the Tx Desc ring indexes */
2878         tx_desc_used = mp->tx_used_desc_q;
2879
2880         p_tx_desc_used = &mp->p_tx_desc_area[tx_desc_used];
2881
2882         /* Sanity check */
2883         if (p_tx_desc_used == NULL) {
2884                 err = ETH_ERROR;
2885                 goto out;
2886         }
2887
2888         /* Stop release. About to overlap the current available Tx descriptor */
2889         if (tx_desc_used == tx_busy_desc && !mp->tx_resource_err) {
2890                 err = ETH_ERROR;
2891                 goto out;
2892         }
2893
2894         command_status = p_tx_desc_used->cmd_sts;
2895
2896         /* Still transmitting... */
2897         if (command_status & (ETH_BUFFER_OWNED_BY_DMA)) {
2898                 err = ETH_ERROR;
2899                 goto out;
2900         }
2901
2902         /* Pass the packet information to the caller */
2903         p_pkt_info->cmd_sts = command_status;
2904         p_pkt_info->return_info = mp->tx_skb[tx_desc_used];
2905         p_pkt_info->buf_ptr = p_tx_desc_used->buf_ptr;
2906         p_pkt_info->byte_cnt = p_tx_desc_used->byte_cnt;
2907         mp->tx_skb[tx_desc_used] = NULL;
2908
2909         /* Update the next descriptor to release. */
2910         mp->tx_used_desc_q = (tx_desc_used + 1) % mp->tx_ring_size;
2911
2912         /* Any Tx return cancels the Tx resource error status */
2913         mp->tx_resource_err = 0;
2914
2915         BUG_ON(mp->tx_desc_count == 0);
2916         mp->tx_desc_count--;
2917
2918 out:
2919         spin_unlock_irqrestore(&mp->lock, flags);
2920
2921         return err;
2922 }
2923
2924 /*
2925  * eth_port_receive - Get received information from Rx ring.
2926  *
2927  * DESCRIPTION:
2928  *      This routine returns the received data to the caller. There is no
2929  *      data copying during routine operation. All information is returned
2930  *      using pointer to packet information struct passed from the caller.
2931  *      If the routine exhausts Rx ring resources then the resource error flag
2932  *      is set.
2933  *
2934  * INPUT:
2935  *      struct mv643xx_private  *mp             Ethernet Port Control srtuct.
2936  *      struct pkt_info         *p_pkt_info     User packet buffer.
2937  *
2938  * OUTPUT:
2939  *      Rx ring current and used indexes are updated.
2940  *
2941  * RETURN:
2942  *      ETH_ERROR in case the routine can not access Rx desc ring.
2943  *      ETH_QUEUE_FULL if Rx ring resources are exhausted.
2944  *      ETH_END_OF_JOB if there is no received data.
2945  *      ETH_OK otherwise.
2946  */
2947 static ETH_FUNC_RET_STATUS eth_port_receive(struct mv643xx_private *mp,
2948                                                 struct pkt_info *p_pkt_info)
2949 {
2950         int rx_next_curr_desc, rx_curr_desc, rx_used_desc;
2951         volatile struct eth_rx_desc *p_rx_desc;
2952         unsigned int command_status;
2953         unsigned long flags;
2954
2955         /* Do not process Rx ring in case of Rx ring resource error */
2956         if (mp->rx_resource_err)
2957                 return ETH_QUEUE_FULL;
2958
2959         spin_lock_irqsave(&mp->lock, flags);
2960
2961         /* Get the Rx Desc ring 'curr and 'used' indexes */
2962         rx_curr_desc = mp->rx_curr_desc_q;
2963         rx_used_desc = mp->rx_used_desc_q;
2964
2965         p_rx_desc = &mp->p_rx_desc_area[rx_curr_desc];
2966
2967         /* The following parameters are used to save readings from memory */
2968         command_status = p_rx_desc->cmd_sts;
2969         rmb();
2970
2971         /* Nothing to receive... */
2972         if (command_status & (ETH_BUFFER_OWNED_BY_DMA)) {
2973                 spin_unlock_irqrestore(&mp->lock, flags);
2974                 return ETH_END_OF_JOB;
2975         }
2976
2977         p_pkt_info->byte_cnt = (p_rx_desc->byte_cnt) - RX_BUF_OFFSET;
2978         p_pkt_info->cmd_sts = command_status;
2979         p_pkt_info->buf_ptr = (p_rx_desc->buf_ptr) + RX_BUF_OFFSET;
2980         p_pkt_info->return_info = mp->rx_skb[rx_curr_desc];
2981         p_pkt_info->l4i_chk = p_rx_desc->buf_size;
2982
2983         /*
2984          * Clean the return info field to indicate that the
2985          * packet has been moved to the upper layers
2986          */
2987         mp->rx_skb[rx_curr_desc] = NULL;
2988
2989         /* Update current index in data structure */
2990         rx_next_curr_desc = (rx_curr_desc + 1) % mp->rx_ring_size;
2991         mp->rx_curr_desc_q = rx_next_curr_desc;
2992
2993         /* Rx descriptors exhausted. Set the Rx ring resource error flag */
2994         if (rx_next_curr_desc == rx_used_desc)
2995                 mp->rx_resource_err = 1;
2996
2997         spin_unlock_irqrestore(&mp->lock, flags);
2998
2999         return ETH_OK;
3000 }
3001
3002 /*
3003  * eth_rx_return_buff - Returns a Rx buffer back to the Rx ring.
3004  *
3005  * DESCRIPTION:
3006  *      This routine returns a Rx buffer back to the Rx ring. It retrieves the
3007  *      next 'used' descriptor and attached the returned buffer to it.
3008  *      In case the Rx ring was in "resource error" condition, where there are
3009  *      no available Rx resources, the function resets the resource error flag.
3010  *
3011  * INPUT:
3012  *      struct mv643xx_private  *mp             Ethernet Port Control srtuct.
3013  *      struct pkt_info         *p_pkt_info     Information on returned buffer.
3014  *
3015  * OUTPUT:
3016  *      New available Rx resource in Rx descriptor ring.
3017  *
3018  * RETURN:
3019  *      ETH_ERROR in case the routine can not access Rx desc ring.
3020  *      ETH_OK otherwise.
3021  */
3022 static ETH_FUNC_RET_STATUS eth_rx_return_buff(struct mv643xx_private *mp,
3023                                                 struct pkt_info *p_pkt_info)
3024 {
3025         int used_rx_desc;       /* Where to return Rx resource */
3026         volatile struct eth_rx_desc *p_used_rx_desc;
3027         unsigned long flags;
3028
3029         spin_lock_irqsave(&mp->lock, flags);
3030
3031         /* Get 'used' Rx descriptor */
3032         used_rx_desc = mp->rx_used_desc_q;
3033         p_used_rx_desc = &mp->p_rx_desc_area[used_rx_desc];
3034
3035         p_used_rx_desc->buf_ptr = p_pkt_info->buf_ptr;
3036         p_used_rx_desc->buf_size = p_pkt_info->byte_cnt;
3037         mp->rx_skb[used_rx_desc] = p_pkt_info->return_info;
3038
3039         /* Flush the write pipe */
3040
3041         /* Return the descriptor to DMA ownership */
3042         wmb();
3043         p_used_rx_desc->cmd_sts =
3044                         ETH_BUFFER_OWNED_BY_DMA | ETH_RX_ENABLE_INTERRUPT;
3045         wmb();
3046
3047         /* Move the used descriptor pointer to the next descriptor */
3048         mp->rx_used_desc_q = (used_rx_desc + 1) % mp->rx_ring_size;
3049
3050         /* Any Rx return cancels the Rx resource error status */
3051         mp->rx_resource_err = 0;
3052
3053         spin_unlock_irqrestore(&mp->lock, flags);
3054
3055         return ETH_OK;
3056 }
3057
3058 /************* Begin ethtool support *************************/
3059
3060 struct mv643xx_stats {
3061         char stat_string[ETH_GSTRING_LEN];
3062         int sizeof_stat;
3063         int stat_offset;
3064 };
3065
3066 #define MV643XX_STAT(m) sizeof(((struct mv643xx_private *)0)->m), \
3067                                         offsetof(struct mv643xx_private, m)
3068
3069 static const struct mv643xx_stats mv643xx_gstrings_stats[] = {
3070         { "rx_packets", MV643XX_STAT(stats.rx_packets) },
3071         { "tx_packets", MV643XX_STAT(stats.tx_packets) },
3072         { "rx_bytes", MV643XX_STAT(stats.rx_bytes) },
3073         { "tx_bytes", MV643XX_STAT(stats.tx_bytes) },
3074         { "rx_errors", MV643XX_STAT(stats.rx_errors) },
3075         { "tx_errors", MV643XX_STAT(stats.tx_errors) },
3076         { "rx_dropped", MV643XX_STAT(stats.rx_dropped) },
3077         { "tx_dropped", MV643XX_STAT(stats.tx_dropped) },
3078         { "good_octets_received", MV643XX_STAT(mib_counters.good_octets_received) },
3079         { "bad_octets_received", MV643XX_STAT(mib_counters.bad_octets_received) },
3080         { "internal_mac_transmit_err", MV643XX_STAT(mib_counters.internal_mac_transmit_err) },
3081         { "good_frames_received", MV643XX_STAT(mib_counters.good_frames_received) },
3082         { "bad_frames_received", MV643XX_STAT(mib_counters.bad_frames_received) },
3083         { "broadcast_frames_received", MV643XX_STAT(mib_counters.broadcast_frames_received) },
3084         { "multicast_frames_received", MV643XX_STAT(mib_counters.multicast_frames_received) },
3085         { "frames_64_octets", MV643XX_STAT(mib_counters.frames_64_octets) },
3086         { "frames_65_to_127_octets", MV643XX_STAT(mib_counters.frames_65_to_127_octets) },
3087         { "frames_128_to_255_octets", MV643XX_STAT(mib_counters.frames_128_to_255_octets) },
3088         { "frames_256_to_511_octets", MV643XX_STAT(mib_counters.frames_256_to_511_octets) },
3089         { "frames_512_to_1023_octets", MV643XX_STAT(mib_counters.frames_512_to_1023_octets) },
3090         { "frames_1024_to_max_octets", MV643XX_STAT(mib_counters.frames_1024_to_max_octets) },
3091         { "good_octets_sent", MV643XX_STAT(mib_counters.good_octets_sent) },
3092         { "good_frames_sent", MV643XX_STAT(mib_counters.good_frames_sent) },
3093         { "excessive_collision", MV643XX_STAT(mib_counters.excessive_collision) },
3094         { "multicast_frames_sent", MV643XX_STAT(mib_counters.multicast_frames_sent) },
3095         { "broadcast_frames_sent", MV643XX_STAT(mib_counters.broadcast_frames_sent) },
3096         { "unrec_mac_control_received", MV643XX_STAT(mib_counters.unrec_mac_control_received) },
3097         { "fc_sent", MV643XX_STAT(mib_counters.fc_sent) },
3098         { "good_fc_received", MV643XX_STAT(mib_counters.good_fc_received) },
3099         { "bad_fc_received", MV643XX_STAT(mib_counters.bad_fc_received) },
3100         { "undersize_received", MV643XX_STAT(mib_counters.undersize_received) },
3101         { "fragments_received", MV643XX_STAT(mib_counters.fragments_received) },
3102         { "oversize_received", MV643XX_STAT(mib_counters.oversize_received) },
3103         { "jabber_received", MV643XX_STAT(mib_counters.jabber_received) },
3104         { "mac_receive_error", MV643XX_STAT(mib_counters.mac_receive_error) },
3105         { "bad_crc_event", MV643XX_STAT(mib_counters.bad_crc_event) },
3106         { "collision", MV643XX_STAT(mib_counters.collision) },
3107         { "late_collision", MV643XX_STAT(mib_counters.late_collision) },
3108 };
3109
3110 #define MV643XX_STATS_LEN       \
3111         sizeof(mv643xx_gstrings_stats) / sizeof(struct mv643xx_stats)
3112
3113 static void mv643xx_get_drvinfo(struct net_device *netdev,
3114                                 struct ethtool_drvinfo *drvinfo)
3115 {
3116         strncpy(drvinfo->driver,  mv643xx_driver_name, 32);
3117         strncpy(drvinfo->version, mv643xx_driver_version, 32);
3118         strncpy(drvinfo->fw_version, "N/A", 32);
3119         strncpy(drvinfo->bus_info, "mv643xx", 32);
3120         drvinfo->n_stats = MV643XX_STATS_LEN;
3121 }
3122
3123 static int mv643xx_get_stats_count(struct net_device *netdev)
3124 {
3125         return MV643XX_STATS_LEN;
3126 }
3127
3128 static void mv643xx_get_ethtool_stats(struct net_device *netdev,
3129                                 struct ethtool_stats *stats, uint64_t *data)
3130 {
3131         struct mv643xx_private *mp = netdev->priv;
3132         int i;
3133
3134         eth_update_mib_counters(mp);
3135
3136         for (i = 0; i < MV643XX_STATS_LEN; i++) {
3137                 char *p = (char *)mp+mv643xx_gstrings_stats[i].stat_offset;
3138                 data[i] = (mv643xx_gstrings_stats[i].sizeof_stat ==
3139                         sizeof(uint64_t)) ? *(uint64_t *)p : *(uint32_t *)p;
3140         }
3141 }
3142
3143 static void mv643xx_get_strings(struct net_device *netdev, uint32_t stringset,
3144                                 uint8_t *data)
3145 {
3146         int i;
3147
3148         switch(stringset) {
3149         case ETH_SS_STATS:
3150                 for (i=0; i < MV643XX_STATS_LEN; i++) {
3151                         memcpy(data + i * ETH_GSTRING_LEN,
3152                                         mv643xx_gstrings_stats[i].stat_string,
3153                                         ETH_GSTRING_LEN);
3154                 }
3155                 break;
3156         }
3157 }
3158
3159 static u32 mv643xx_eth_get_link(struct net_device *dev)
3160 {
3161         struct mv643xx_private *mp = netdev_priv(dev);
3162
3163         return mii_link_ok(&mp->mii);
3164 }
3165
3166 static int mv643xx_eth_nway_restart(struct net_device *dev)
3167 {
3168         struct mv643xx_private *mp = netdev_priv(dev);
3169
3170         return mii_nway_restart(&mp->mii);
3171 }
3172
3173 static int mv643xx_eth_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
3174 {
3175         struct mv643xx_private *mp = netdev_priv(dev);
3176
3177         return generic_mii_ioctl(&mp->mii, if_mii(ifr), cmd, NULL);
3178 }
3179
3180 static struct ethtool_ops mv643xx_ethtool_ops = {
3181         .get_settings           = mv643xx_get_settings,
3182         .set_settings           = mv643xx_set_settings,
3183         .get_drvinfo            = mv643xx_get_drvinfo,
3184         .get_link               = mv643xx_eth_get_link,
3185         .get_sg                 = ethtool_op_get_sg,
3186         .set_sg                 = ethtool_op_set_sg,
3187         .get_strings            = mv643xx_get_strings,
3188         .get_stats_count        = mv643xx_get_stats_count,
3189         .get_ethtool_stats      = mv643xx_get_ethtool_stats,
3190         .get_strings            = mv643xx_get_strings,
3191         .get_stats_count        = mv643xx_get_stats_count,
3192         .get_ethtool_stats      = mv643xx_get_ethtool_stats,
3193         .nway_reset             = mv643xx_eth_nway_restart,
3194 };
3195
3196 /************* End ethtool support *************************/