linux/drivers/net/ethernet/micrel/ks8695net.c
<<
>>
Prefs
   1/*
   2 * Micrel KS8695 (Centaur) Ethernet.
   3 *
   4 * This program is free software; you can redistribute it and/or
   5 * modify it under the terms of the GNU General Public License as
   6 * published by the Free Software Foundation; either version 2 of the
   7 * License, or (at your option) any later version.
   8 *
   9 * This program is distributed in the hope that it will be useful, but
  10 * WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 * General Public License for more details.
  13 *
  14 * Copyright 2008 Simtec Electronics
  15 *                Daniel Silverstone <dsilvers@simtec.co.uk>
  16 *                Vincent Sanders <vince@simtec.co.uk>
  17 */
  18
  19#include <linux/dma-mapping.h>
  20#include <linux/module.h>
  21#include <linux/ioport.h>
  22#include <linux/netdevice.h>
  23#include <linux/etherdevice.h>
  24#include <linux/interrupt.h>
  25#include <linux/skbuff.h>
  26#include <linux/spinlock.h>
  27#include <linux/crc32.h>
  28#include <linux/mii.h>
  29#include <linux/ethtool.h>
  30#include <linux/delay.h>
  31#include <linux/platform_device.h>
  32#include <linux/irq.h>
  33#include <linux/io.h>
  34#include <linux/slab.h>
  35
  36#include <asm/irq.h>
  37
  38#include <mach/regs-switch.h>
  39#include <mach/regs-misc.h>
  40#include <asm/mach/irq.h>
  41#include <mach/regs-irq.h>
  42
  43#include "ks8695net.h"
  44
  45#define MODULENAME      "ks8695_ether"
  46#define MODULEVERSION   "1.02"
  47
  48/*
  49 * Transmit and device reset timeout, default 5 seconds.
  50 */
  51static int watchdog = 5000;
  52
  53/* Hardware structures */
  54
  55/**
  56 *      struct rx_ring_desc - Receive descriptor ring element
  57 *      @status: The status of the descriptor element (E.g. who owns it)
  58 *      @length: The number of bytes in the block pointed to by data_ptr
  59 *      @data_ptr: The physical address of the data block to receive into
  60 *      @next_desc: The physical address of the next descriptor element.
  61 */
  62struct rx_ring_desc {
  63        __le32  status;
  64        __le32  length;
  65        __le32  data_ptr;
  66        __le32  next_desc;
  67};
  68
  69/**
  70 *      struct tx_ring_desc - Transmit descriptor ring element
  71 *      @owner: Who owns the descriptor
  72 *      @status: The number of bytes in the block pointed to by data_ptr
  73 *      @data_ptr: The physical address of the data block to receive into
  74 *      @next_desc: The physical address of the next descriptor element.
  75 */
  76struct tx_ring_desc {
  77        __le32  owner;
  78        __le32  status;
  79        __le32  data_ptr;
  80        __le32  next_desc;
  81};
  82
  83/**
  84 *      struct ks8695_skbuff - sk_buff wrapper for rx/tx rings.
  85 *      @skb: The buffer in the ring
  86 *      @dma_ptr: The mapped DMA pointer of the buffer
  87 *      @length: The number of bytes mapped to dma_ptr
  88 */
  89struct ks8695_skbuff {
  90        struct sk_buff  *skb;
  91        dma_addr_t      dma_ptr;
  92        u32             length;
  93};
  94
  95/* Private device structure */
  96
  97#define MAX_TX_DESC 8
  98#define MAX_TX_DESC_MASK 0x7
  99#define MAX_RX_DESC 16
 100#define MAX_RX_DESC_MASK 0xf
 101
 102/*napi_weight have better more than rx DMA buffers*/
 103#define NAPI_WEIGHT   64
 104
 105#define MAX_RXBUF_SIZE 0x700
 106
 107#define TX_RING_DMA_SIZE (sizeof(struct tx_ring_desc) * MAX_TX_DESC)
 108#define RX_RING_DMA_SIZE (sizeof(struct rx_ring_desc) * MAX_RX_DESC)
 109#define RING_DMA_SIZE (TX_RING_DMA_SIZE + RX_RING_DMA_SIZE)
 110
 111/**
 112 *      enum ks8695_dtype - Device type
 113 *      @KS8695_DTYPE_WAN: This device is a WAN interface
 114 *      @KS8695_DTYPE_LAN: This device is a LAN interface
 115 *      @KS8695_DTYPE_HPNA: This device is an HPNA interface
 116 */
 117enum ks8695_dtype {
 118        KS8695_DTYPE_WAN,
 119        KS8695_DTYPE_LAN,
 120        KS8695_DTYPE_HPNA,
 121};
 122
 123/**
 124 *      struct ks8695_priv - Private data for the KS8695 Ethernet
 125 *      @in_suspend: Flag to indicate if we're suspending/resuming
 126 *      @ndev: The net_device for this interface
 127 *      @dev: The platform device object for this interface
 128 *      @dtype: The type of this device
 129 *      @io_regs: The ioremapped registers for this interface
 130 *      @napi : Add support NAPI for Rx
 131 *      @rx_irq_name: The textual name of the RX IRQ from the platform data
 132 *      @tx_irq_name: The textual name of the TX IRQ from the platform data
 133 *      @link_irq_name: The textual name of the link IRQ from the
 134 *                      platform data if available
 135 *      @rx_irq: The IRQ number for the RX IRQ
 136 *      @tx_irq: The IRQ number for the TX IRQ
 137 *      @link_irq: The IRQ number for the link IRQ if available
 138 *      @regs_req: The resource request for the registers region
 139 *      @phyiface_req: The resource request for the phy/switch region
 140 *                     if available
 141 *      @phyiface_regs: The ioremapped registers for the phy/switch if available
 142 *      @ring_base: The base pointer of the dma coherent memory for the rings
 143 *      @ring_base_dma: The DMA mapped equivalent of ring_base
 144 *      @tx_ring: The pointer in ring_base of the TX ring
 145 *      @tx_ring_used: The number of slots in the TX ring which are occupied
 146 *      @tx_ring_next_slot: The next slot to fill in the TX ring
 147 *      @tx_ring_dma: The DMA mapped equivalent of tx_ring
 148 *      @tx_buffers: The sk_buff mappings for the TX ring
 149 *      @txq_lock: A lock to protect the tx_buffers tx_ring_used etc variables
 150 *      @rx_ring: The pointer in ring_base of the RX ring
 151 *      @rx_ring_dma: The DMA mapped equivalent of rx_ring
 152 *      @rx_buffers: The sk_buff mappings for the RX ring
 153 *      @next_rx_desc_read: The next RX descriptor to read from on IRQ
 154 *      @rx_lock: A lock to protect Rx irq function
 155 *      @msg_enable: The flags for which messages to emit
 156 */
 157struct ks8695_priv {
 158        int in_suspend;
 159        struct net_device *ndev;
 160        struct device *dev;
 161        enum ks8695_dtype dtype;
 162        void __iomem *io_regs;
 163
 164        struct napi_struct      napi;
 165
 166        const char *rx_irq_name, *tx_irq_name, *link_irq_name;
 167        int rx_irq, tx_irq, link_irq;
 168
 169        struct resource *regs_req, *phyiface_req;
 170        void __iomem *phyiface_regs;
 171
 172        void *ring_base;
 173        dma_addr_t ring_base_dma;
 174
 175        struct tx_ring_desc *tx_ring;
 176        int tx_ring_used;
 177        int tx_ring_next_slot;
 178        dma_addr_t tx_ring_dma;
 179        struct ks8695_skbuff tx_buffers[MAX_TX_DESC];
 180        spinlock_t txq_lock;
 181
 182        struct rx_ring_desc *rx_ring;
 183        dma_addr_t rx_ring_dma;
 184        struct ks8695_skbuff rx_buffers[MAX_RX_DESC];
 185        int next_rx_desc_read;
 186        spinlock_t rx_lock;
 187
 188        int msg_enable;
 189};
 190
 191/* Register access */
 192
 193/**
 194 *      ks8695_readreg - Read from a KS8695 ethernet register
 195 *      @ksp: The device to read from
 196 *      @reg: The register to read
 197 */
 198static inline u32
 199ks8695_readreg(struct ks8695_priv *ksp, int reg)
 200{
 201        return readl(ksp->io_regs + reg);
 202}
 203
 204/**
 205 *      ks8695_writereg - Write to a KS8695 ethernet register
 206 *      @ksp: The device to write to
 207 *      @reg: The register to write
 208 *      @value: The value to write to the register
 209 */
 210static inline void
 211ks8695_writereg(struct ks8695_priv *ksp, int reg, u32 value)
 212{
 213        writel(value, ksp->io_regs + reg);
 214}
 215
 216/* Utility functions */
 217
 218/**
 219 *      ks8695_port_type - Retrieve port-type as user-friendly string
 220 *      @ksp: The device to return the type for
 221 *
 222 *      Returns a string indicating which of the WAN, LAN or HPNA
 223 *      ports this device is likely to represent.
 224 */
 225static const char *
 226ks8695_port_type(struct ks8695_priv *ksp)
 227{
 228        switch (ksp->dtype) {
 229        case KS8695_DTYPE_LAN:
 230                return "LAN";
 231        case KS8695_DTYPE_WAN:
 232                return "WAN";
 233        case KS8695_DTYPE_HPNA:
 234                return "HPNA";
 235        }
 236
 237        return "UNKNOWN";
 238}
 239
 240/**
 241 *      ks8695_update_mac - Update the MAC registers in the device
 242 *      @ksp: The device to update
 243 *
 244 *      Updates the MAC registers in the KS8695 device from the address in the
 245 *      net_device structure associated with this interface.
 246 */
 247static void
 248ks8695_update_mac(struct ks8695_priv *ksp)
 249{
 250        /* Update the HW with the MAC from the net_device */
 251        struct net_device *ndev = ksp->ndev;
 252        u32 machigh, maclow;
 253
 254        maclow  = ((ndev->dev_addr[2] << 24) | (ndev->dev_addr[3] << 16) |
 255                   (ndev->dev_addr[4] <<  8) | (ndev->dev_addr[5] <<  0));
 256        machigh = ((ndev->dev_addr[0] <<  8) | (ndev->dev_addr[1] <<  0));
 257
 258        ks8695_writereg(ksp, KS8695_MAL, maclow);
 259        ks8695_writereg(ksp, KS8695_MAH, machigh);
 260
 261}
 262
 263/**
 264 *      ks8695_refill_rxbuffers - Re-fill the RX buffer ring
 265 *      @ksp: The device to refill
 266 *
 267 *      Iterates the RX ring of the device looking for empty slots.
 268 *      For each empty slot, we allocate and map a new SKB and give it
 269 *      to the hardware.
 270 *      This can be called from interrupt context safely.
 271 */
 272static void
 273ks8695_refill_rxbuffers(struct ks8695_priv *ksp)
 274{
 275        /* Run around the RX ring, filling in any missing sk_buff's */
 276        int buff_n;
 277
 278        for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) {
 279                if (!ksp->rx_buffers[buff_n].skb) {
 280                        struct sk_buff *skb =
 281                                netdev_alloc_skb(ksp->ndev, MAX_RXBUF_SIZE);
 282                        dma_addr_t mapping;
 283
 284                        ksp->rx_buffers[buff_n].skb = skb;
 285                        if (skb == NULL) {
 286                                /* Failed to allocate one, perhaps
 287                                 * we'll try again later.
 288                                 */
 289                                break;
 290                        }
 291
 292                        mapping = dma_map_single(ksp->dev, skb->data,
 293                                                 MAX_RXBUF_SIZE,
 294                                                 DMA_FROM_DEVICE);
 295                        if (unlikely(dma_mapping_error(ksp->dev, mapping))) {
 296                                /* Failed to DMA map this SKB, try later */
 297                                dev_kfree_skb_irq(skb);
 298                                ksp->rx_buffers[buff_n].skb = NULL;
 299                                break;
 300                        }
 301                        ksp->rx_buffers[buff_n].dma_ptr = mapping;
 302                        ksp->rx_buffers[buff_n].length = MAX_RXBUF_SIZE;
 303
 304                        /* Record this into the DMA ring */
 305                        ksp->rx_ring[buff_n].data_ptr = cpu_to_le32(mapping);
 306                        ksp->rx_ring[buff_n].length =
 307                                cpu_to_le32(MAX_RXBUF_SIZE);
 308
 309                        wmb();
 310
 311                        /* And give ownership over to the hardware */
 312                        ksp->rx_ring[buff_n].status = cpu_to_le32(RDES_OWN);
 313                }
 314        }
 315}
 316
 317/* Maximum number of multicast addresses which the KS8695 HW supports */
 318#define KS8695_NR_ADDRESSES     16
 319
 320/**
 321 *      ks8695_init_partial_multicast - Init the mcast addr registers
 322 *      @ksp: The device to initialise
 323 *      @addr: The multicast address list to use
 324 *      @nr_addr: The number of addresses in the list
 325 *
 326 *      This routine is a helper for ks8695_set_multicast - it writes
 327 *      the additional-address registers in the KS8695 ethernet device
 328 *      and cleans up any others left behind.
 329 */
 330static void
 331ks8695_init_partial_multicast(struct ks8695_priv *ksp,
 332                              struct net_device *ndev)
 333{
 334        u32 low, high;
 335        int i;
 336        struct netdev_hw_addr *ha;
 337
 338        i = 0;
 339        netdev_for_each_mc_addr(ha, ndev) {
 340                /* Ran out of space in chip? */
 341                BUG_ON(i == KS8695_NR_ADDRESSES);
 342
 343                low = (ha->addr[2] << 24) | (ha->addr[3] << 16) |
 344                      (ha->addr[4] << 8) | (ha->addr[5]);
 345                high = (ha->addr[0] << 8) | (ha->addr[1]);
 346
 347                ks8695_writereg(ksp, KS8695_AAL_(i), low);
 348                ks8695_writereg(ksp, KS8695_AAH_(i), AAH_E | high);
 349                i++;
 350        }
 351
 352        /* Clear the remaining Additional Station Addresses */
 353        for (; i < KS8695_NR_ADDRESSES; i++) {
 354                ks8695_writereg(ksp, KS8695_AAL_(i), 0);
 355                ks8695_writereg(ksp, KS8695_AAH_(i), 0);
 356        }
 357}
 358
 359/* Interrupt handling */
 360
 361/**
 362 *      ks8695_tx_irq - Transmit IRQ handler
 363 *      @irq: The IRQ which went off (ignored)
 364 *      @dev_id: The net_device for the interrupt
 365 *
 366 *      Process the TX ring, clearing out any transmitted slots.
 367 *      Allows the net_device to pass us new packets once slots are
 368 *      freed.
 369 */
 370static irqreturn_t
 371ks8695_tx_irq(int irq, void *dev_id)
 372{
 373        struct net_device *ndev = (struct net_device *)dev_id;
 374        struct ks8695_priv *ksp = netdev_priv(ndev);
 375        int buff_n;
 376
 377        for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) {
 378                if (ksp->tx_buffers[buff_n].skb &&
 379                    !(ksp->tx_ring[buff_n].owner & cpu_to_le32(TDES_OWN))) {
 380                        rmb();
 381                        /* An SKB which is not owned by HW is present */
 382                        /* Update the stats for the net_device */
 383                        ndev->stats.tx_packets++;
 384                        ndev->stats.tx_bytes += ksp->tx_buffers[buff_n].length;
 385
 386                        /* Free the packet from the ring */
 387                        ksp->tx_ring[buff_n].data_ptr = 0;
 388
 389                        /* Free the sk_buff */
 390                        dma_unmap_single(ksp->dev,
 391                                         ksp->tx_buffers[buff_n].dma_ptr,
 392                                         ksp->tx_buffers[buff_n].length,
 393                                         DMA_TO_DEVICE);
 394                        dev_kfree_skb_irq(ksp->tx_buffers[buff_n].skb);
 395                        ksp->tx_buffers[buff_n].skb = NULL;
 396                        ksp->tx_ring_used--;
 397                }
 398        }
 399
 400        netif_wake_queue(ndev);
 401
 402        return IRQ_HANDLED;
 403}
 404
 405/**
 406 *      ks8695_get_rx_enable_bit - Get rx interrupt enable/status bit
 407 *      @ksp: Private data for the KS8695 Ethernet
 408 *
 409 *    For KS8695 document:
 410 *    Interrupt Enable Register (offset 0xE204)
 411 *        Bit29 : WAN MAC Receive Interrupt Enable
 412 *        Bit16 : LAN MAC Receive Interrupt Enable
 413 *    Interrupt Status Register (Offset 0xF208)
 414 *        Bit29: WAN MAC Receive Status
 415 *        Bit16: LAN MAC Receive Status
 416 *    So, this Rx interrupt enable/status bit number is equal
 417 *    as Rx IRQ number.
 418 */
 419static inline u32 ks8695_get_rx_enable_bit(struct ks8695_priv *ksp)
 420{
 421        return ksp->rx_irq;
 422}
 423
 424/**
 425 *      ks8695_rx_irq - Receive IRQ handler
 426 *      @irq: The IRQ which went off (ignored)
 427 *      @dev_id: The net_device for the interrupt
 428 *
 429 *      Inform NAPI that packet reception needs to be scheduled
 430 */
 431
 432static irqreturn_t
 433ks8695_rx_irq(int irq, void *dev_id)
 434{
 435        struct net_device *ndev = (struct net_device *)dev_id;
 436        struct ks8695_priv *ksp = netdev_priv(ndev);
 437
 438        spin_lock(&ksp->rx_lock);
 439
 440        if (napi_schedule_prep(&ksp->napi)) {
 441                unsigned long status = readl(KS8695_IRQ_VA + KS8695_INTEN);
 442                unsigned long mask_bit = 1 << ks8695_get_rx_enable_bit(ksp);
 443                /*disable rx interrupt*/
 444                status &= ~mask_bit;
 445                writel(status , KS8695_IRQ_VA + KS8695_INTEN);
 446                __napi_schedule(&ksp->napi);
 447        }
 448
 449        spin_unlock(&ksp->rx_lock);
 450        return IRQ_HANDLED;
 451}
 452
 453/**
 454 *      ks8695_rx - Receive packets called by NAPI poll method
 455 *      @ksp: Private data for the KS8695 Ethernet
 456 *      @budget: Number of packets allowed to process
 457 */
 458static int ks8695_rx(struct ks8695_priv *ksp, int budget)
 459{
 460        struct net_device *ndev = ksp->ndev;
 461        struct sk_buff *skb;
 462        int buff_n;
 463        u32 flags;
 464        int pktlen;
 465        int received = 0;
 466
 467        buff_n = ksp->next_rx_desc_read;
 468        while (received < budget
 469                        && ksp->rx_buffers[buff_n].skb
 470                        && (!(ksp->rx_ring[buff_n].status &
 471                                        cpu_to_le32(RDES_OWN)))) {
 472                        rmb();
 473                        flags = le32_to_cpu(ksp->rx_ring[buff_n].status);
 474
 475                        /* Found an SKB which we own, this means we
 476                         * received a packet
 477                         */
 478                        if ((flags & (RDES_FS | RDES_LS)) !=
 479                            (RDES_FS | RDES_LS)) {
 480                                /* This packet is not the first and
 481                                 * the last segment.  Therefore it is
 482                                 * a "spanning" packet and we can't
 483                                 * handle it
 484                                 */
 485                                goto rx_failure;
 486                        }
 487
 488                        if (flags & (RDES_ES | RDES_RE)) {
 489                                /* It's an error packet */
 490                                ndev->stats.rx_errors++;
 491                                if (flags & RDES_TL)
 492                                        ndev->stats.rx_length_errors++;
 493                                if (flags & RDES_RF)
 494                                        ndev->stats.rx_length_errors++;
 495                                if (flags & RDES_CE)
 496                                        ndev->stats.rx_crc_errors++;
 497                                if (flags & RDES_RE)
 498                                        ndev->stats.rx_missed_errors++;
 499
 500                                goto rx_failure;
 501                        }
 502
 503                        pktlen = flags & RDES_FLEN;
 504                        pktlen -= 4; /* Drop the CRC */
 505
 506                        /* Retrieve the sk_buff */
 507                        skb = ksp->rx_buffers[buff_n].skb;
 508
 509                        /* Clear it from the ring */
 510                        ksp->rx_buffers[buff_n].skb = NULL;
 511                        ksp->rx_ring[buff_n].data_ptr = 0;
 512
 513                        /* Unmap the SKB */
 514                        dma_unmap_single(ksp->dev,
 515                                         ksp->rx_buffers[buff_n].dma_ptr,
 516                                         ksp->rx_buffers[buff_n].length,
 517                                         DMA_FROM_DEVICE);
 518
 519                        /* Relinquish the SKB to the network layer */
 520                        skb_put(skb, pktlen);
 521                        skb->protocol = eth_type_trans(skb, ndev);
 522                        netif_receive_skb(skb);
 523
 524                        /* Record stats */
 525                        ndev->stats.rx_packets++;
 526                        ndev->stats.rx_bytes += pktlen;
 527                        goto rx_finished;
 528
 529rx_failure:
 530                        /* This ring entry is an error, but we can
 531                         * re-use the skb
 532                         */
 533                        /* Give the ring entry back to the hardware */
 534                        ksp->rx_ring[buff_n].status = cpu_to_le32(RDES_OWN);
 535rx_finished:
 536                        received++;
 537                        buff_n = (buff_n + 1) & MAX_RX_DESC_MASK;
 538        }
 539
 540        /* And note which RX descriptor we last did */
 541        ksp->next_rx_desc_read = buff_n;
 542
 543        /* And refill the buffers */
 544        ks8695_refill_rxbuffers(ksp);
 545
 546        /* Kick the RX DMA engine, in case it became suspended */
 547        ks8695_writereg(ksp, KS8695_DRSC, 0);
 548
 549        return received;
 550}
 551
 552
 553/**
 554 *      ks8695_poll - Receive packet by NAPI poll method
 555 *      @ksp: Private data for the KS8695 Ethernet
 556 *      @budget: The remaining number packets for network subsystem
 557 *
 558 *     Invoked by the network core when it requests for new
 559 *     packets from the driver
 560 */
 561static int ks8695_poll(struct napi_struct *napi, int budget)
 562{
 563        struct ks8695_priv *ksp = container_of(napi, struct ks8695_priv, napi);
 564        unsigned long  work_done;
 565
 566        unsigned long isr = readl(KS8695_IRQ_VA + KS8695_INTEN);
 567        unsigned long mask_bit = 1 << ks8695_get_rx_enable_bit(ksp);
 568
 569        work_done = ks8695_rx(ksp, budget);
 570
 571        if (work_done < budget) {
 572                unsigned long flags;
 573                spin_lock_irqsave(&ksp->rx_lock, flags);
 574                __napi_complete(napi);
 575                /*enable rx interrupt*/
 576                writel(isr | mask_bit, KS8695_IRQ_VA + KS8695_INTEN);
 577                spin_unlock_irqrestore(&ksp->rx_lock, flags);
 578        }
 579        return work_done;
 580}
 581
 582/**
 583 *      ks8695_link_irq - Link change IRQ handler
 584 *      @irq: The IRQ which went off (ignored)
 585 *      @dev_id: The net_device for the interrupt
 586 *
 587 *      The WAN interface can generate an IRQ when the link changes,
 588 *      report this to the net layer and the user.
 589 */
 590static irqreturn_t
 591ks8695_link_irq(int irq, void *dev_id)
 592{
 593        struct net_device *ndev = (struct net_device *)dev_id;
 594        struct ks8695_priv *ksp = netdev_priv(ndev);
 595        u32 ctrl;
 596
 597        ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
 598        if (ctrl & WMC_WLS) {
 599                netif_carrier_on(ndev);
 600                if (netif_msg_link(ksp))
 601                        dev_info(ksp->dev,
 602                                 "%s: Link is now up (10%sMbps/%s-duplex)\n",
 603                                 ndev->name,
 604                                 (ctrl & WMC_WSS) ? "0" : "",
 605                                 (ctrl & WMC_WDS) ? "Full" : "Half");
 606        } else {
 607                netif_carrier_off(ndev);
 608                if (netif_msg_link(ksp))
 609                        dev_info(ksp->dev, "%s: Link is now down.\n",
 610                                 ndev->name);
 611        }
 612
 613        return IRQ_HANDLED;
 614}
 615
 616
 617/* KS8695 Device functions */
 618
 619/**
 620 *      ks8695_reset - Reset a KS8695 ethernet interface
 621 *      @ksp: The interface to reset
 622 *
 623 *      Perform an engine reset of the interface and re-program it
 624 *      with sensible defaults.
 625 */
 626static void
 627ks8695_reset(struct ks8695_priv *ksp)
 628{
 629        int reset_timeout = watchdog;
 630        /* Issue the reset via the TX DMA control register */
 631        ks8695_writereg(ksp, KS8695_DTXC, DTXC_TRST);
 632        while (reset_timeout--) {
 633                if (!(ks8695_readreg(ksp, KS8695_DTXC) & DTXC_TRST))
 634                        break;
 635                msleep(1);
 636        }
 637
 638        if (reset_timeout < 0) {
 639                dev_crit(ksp->dev,
 640                         "Timeout waiting for DMA engines to reset\n");
 641                /* And blithely carry on */
 642        }
 643
 644        /* Definitely wait long enough before attempting to program
 645         * the engines
 646         */
 647        msleep(10);
 648
 649        /* RX: unicast and broadcast */
 650        ks8695_writereg(ksp, KS8695_DRXC, DRXC_RU | DRXC_RB);
 651        /* TX: pad and add CRC */
 652        ks8695_writereg(ksp, KS8695_DTXC, DTXC_TEP | DTXC_TAC);
 653}
 654
 655/**
 656 *      ks8695_shutdown - Shut down a KS8695 ethernet interface
 657 *      @ksp: The interface to shut down
 658 *
 659 *      This disables packet RX/TX, cleans up IRQs, drains the rings,
 660 *      and basically places the interface into a clean shutdown
 661 *      state.
 662 */
 663static void
 664ks8695_shutdown(struct ks8695_priv *ksp)
 665{
 666        u32 ctrl;
 667        int buff_n;
 668
 669        /* Disable packet transmission */
 670        ctrl = ks8695_readreg(ksp, KS8695_DTXC);
 671        ks8695_writereg(ksp, KS8695_DTXC, ctrl & ~DTXC_TE);
 672
 673        /* Disable packet reception */
 674        ctrl = ks8695_readreg(ksp, KS8695_DRXC);
 675        ks8695_writereg(ksp, KS8695_DRXC, ctrl & ~DRXC_RE);
 676
 677        /* Release the IRQs */
 678        free_irq(ksp->rx_irq, ksp->ndev);
 679        free_irq(ksp->tx_irq, ksp->ndev);
 680        if (ksp->link_irq != -1)
 681                free_irq(ksp->link_irq, ksp->ndev);
 682
 683        /* Throw away any pending TX packets */
 684        for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) {
 685                if (ksp->tx_buffers[buff_n].skb) {
 686                        /* Remove this SKB from the TX ring */
 687                        ksp->tx_ring[buff_n].owner = 0;
 688                        ksp->tx_ring[buff_n].status = 0;
 689                        ksp->tx_ring[buff_n].data_ptr = 0;
 690
 691                        /* Unmap and bin this SKB */
 692                        dma_unmap_single(ksp->dev,
 693                                         ksp->tx_buffers[buff_n].dma_ptr,
 694                                         ksp->tx_buffers[buff_n].length,
 695                                         DMA_TO_DEVICE);
 696                        dev_kfree_skb_irq(ksp->tx_buffers[buff_n].skb);
 697                        ksp->tx_buffers[buff_n].skb = NULL;
 698                }
 699        }
 700
 701        /* Purge the RX buffers */
 702        for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) {
 703                if (ksp->rx_buffers[buff_n].skb) {
 704                        /* Remove the SKB from the RX ring */
 705                        ksp->rx_ring[buff_n].status = 0;
 706                        ksp->rx_ring[buff_n].data_ptr = 0;
 707
 708                        /* Unmap and bin the SKB */
 709                        dma_unmap_single(ksp->dev,
 710                                         ksp->rx_buffers[buff_n].dma_ptr,
 711                                         ksp->rx_buffers[buff_n].length,
 712                                         DMA_FROM_DEVICE);
 713                        dev_kfree_skb_irq(ksp->rx_buffers[buff_n].skb);
 714                        ksp->rx_buffers[buff_n].skb = NULL;
 715                }
 716        }
 717}
 718
 719
 720/**
 721 *      ks8695_setup_irq - IRQ setup helper function
 722 *      @irq: The IRQ number to claim
 723 *      @irq_name: The name to give the IRQ claimant
 724 *      @handler: The function to call to handle the IRQ
 725 *      @ndev: The net_device to pass in as the dev_id argument to the handler
 726 *
 727 *      Return 0 on success.
 728 */
 729static int
 730ks8695_setup_irq(int irq, const char *irq_name,
 731                 irq_handler_t handler, struct net_device *ndev)
 732{
 733        int ret;
 734
 735        ret = request_irq(irq, handler, IRQF_SHARED, irq_name, ndev);
 736
 737        if (ret) {
 738                dev_err(&ndev->dev, "failure to request IRQ %d\n", irq);
 739                return ret;
 740        }
 741
 742        return 0;
 743}
 744
 745/**
 746 *      ks8695_init_net - Initialise a KS8695 ethernet interface
 747 *      @ksp: The interface to initialise
 748 *
 749 *      This routine fills the RX ring, initialises the DMA engines,
 750 *      allocates the IRQs and then starts the packet TX and RX
 751 *      engines.
 752 */
 753static int
 754ks8695_init_net(struct ks8695_priv *ksp)
 755{
 756        int ret;
 757        u32 ctrl;
 758
 759        ks8695_refill_rxbuffers(ksp);
 760
 761        /* Initialise the DMA engines */
 762        ks8695_writereg(ksp, KS8695_RDLB, (u32) ksp->rx_ring_dma);
 763        ks8695_writereg(ksp, KS8695_TDLB, (u32) ksp->tx_ring_dma);
 764
 765        /* Request the IRQs */
 766        ret = ks8695_setup_irq(ksp->rx_irq, ksp->rx_irq_name,
 767                               ks8695_rx_irq, ksp->ndev);
 768        if (ret)
 769                return ret;
 770        ret = ks8695_setup_irq(ksp->tx_irq, ksp->tx_irq_name,
 771                               ks8695_tx_irq, ksp->ndev);
 772        if (ret)
 773                return ret;
 774        if (ksp->link_irq != -1) {
 775                ret = ks8695_setup_irq(ksp->link_irq, ksp->link_irq_name,
 776                                       ks8695_link_irq, ksp->ndev);
 777                if (ret)
 778                        return ret;
 779        }
 780
 781        /* Set up the ring indices */
 782        ksp->next_rx_desc_read = 0;
 783        ksp->tx_ring_next_slot = 0;
 784        ksp->tx_ring_used = 0;
 785
 786        /* Bring up transmission */
 787        ctrl = ks8695_readreg(ksp, KS8695_DTXC);
 788        /* Enable packet transmission */
 789        ks8695_writereg(ksp, KS8695_DTXC, ctrl | DTXC_TE);
 790
 791        /* Bring up the reception */
 792        ctrl = ks8695_readreg(ksp, KS8695_DRXC);
 793        /* Enable packet reception */
 794        ks8695_writereg(ksp, KS8695_DRXC, ctrl | DRXC_RE);
 795        /* And start the DMA engine */
 796        ks8695_writereg(ksp, KS8695_DRSC, 0);
 797
 798        /* All done */
 799        return 0;
 800}
 801
 802/**
 803 *      ks8695_release_device - HW resource release for KS8695 e-net
 804 *      @ksp: The device to be freed
 805 *
 806 *      This unallocates io memory regions, dma-coherent regions etc
 807 *      which were allocated in ks8695_probe.
 808 */
 809static void
 810ks8695_release_device(struct ks8695_priv *ksp)
 811{
 812        /* Unmap the registers */
 813        iounmap(ksp->io_regs);
 814        if (ksp->phyiface_regs)
 815                iounmap(ksp->phyiface_regs);
 816
 817        /* And release the request */
 818        release_resource(ksp->regs_req);
 819        kfree(ksp->regs_req);
 820        if (ksp->phyiface_req) {
 821                release_resource(ksp->phyiface_req);
 822                kfree(ksp->phyiface_req);
 823        }
 824
 825        /* Free the ring buffers */
 826        dma_free_coherent(ksp->dev, RING_DMA_SIZE,
 827                          ksp->ring_base, ksp->ring_base_dma);
 828}
 829
 830/* Ethtool support */
 831
 832/**
 833 *      ks8695_get_msglevel - Get the messages enabled for emission
 834 *      @ndev: The network device to read from
 835 */
 836static u32
 837ks8695_get_msglevel(struct net_device *ndev)
 838{
 839        struct ks8695_priv *ksp = netdev_priv(ndev);
 840
 841        return ksp->msg_enable;
 842}
 843
 844/**
 845 *      ks8695_set_msglevel - Set the messages enabled for emission
 846 *      @ndev: The network device to configure
 847 *      @value: The messages to set for emission
 848 */
 849static void
 850ks8695_set_msglevel(struct net_device *ndev, u32 value)
 851{
 852        struct ks8695_priv *ksp = netdev_priv(ndev);
 853
 854        ksp->msg_enable = value;
 855}
 856
 857/**
 858 *      ks8695_wan_get_settings - Get device-specific settings.
 859 *      @ndev: The network device to read settings from
 860 *      @cmd: The ethtool structure to read into
 861 */
 862static int
 863ks8695_wan_get_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
 864{
 865        struct ks8695_priv *ksp = netdev_priv(ndev);
 866        u32 ctrl;
 867
 868        /* All ports on the KS8695 support these... */
 869        cmd->supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
 870                          SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
 871                          SUPPORTED_TP | SUPPORTED_MII);
 872        cmd->transceiver = XCVR_INTERNAL;
 873
 874        cmd->advertising = ADVERTISED_TP | ADVERTISED_MII;
 875        cmd->port = PORT_MII;
 876        cmd->supported |= (SUPPORTED_Autoneg | SUPPORTED_Pause);
 877        cmd->phy_address = 0;
 878
 879        ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
 880        if ((ctrl & WMC_WAND) == 0) {
 881                /* auto-negotiation is enabled */
 882                cmd->advertising |= ADVERTISED_Autoneg;
 883                if (ctrl & WMC_WANA100F)
 884                        cmd->advertising |= ADVERTISED_100baseT_Full;
 885                if (ctrl & WMC_WANA100H)
 886                        cmd->advertising |= ADVERTISED_100baseT_Half;
 887                if (ctrl & WMC_WANA10F)
 888                        cmd->advertising |= ADVERTISED_10baseT_Full;
 889                if (ctrl & WMC_WANA10H)
 890                        cmd->advertising |= ADVERTISED_10baseT_Half;
 891                if (ctrl & WMC_WANAP)
 892                        cmd->advertising |= ADVERTISED_Pause;
 893                cmd->autoneg = AUTONEG_ENABLE;
 894
 895                ethtool_cmd_speed_set(cmd,
 896                                      (ctrl & WMC_WSS) ? SPEED_100 : SPEED_10);
 897                cmd->duplex = (ctrl & WMC_WDS) ?
 898                        DUPLEX_FULL : DUPLEX_HALF;
 899        } else {
 900                /* auto-negotiation is disabled */
 901                cmd->autoneg = AUTONEG_DISABLE;
 902
 903                ethtool_cmd_speed_set(cmd, ((ctrl & WMC_WANF100) ?
 904                                            SPEED_100 : SPEED_10));
 905                cmd->duplex = (ctrl & WMC_WANFF) ?
 906                        DUPLEX_FULL : DUPLEX_HALF;
 907        }
 908
 909        return 0;
 910}
 911
 912/**
 913 *      ks8695_wan_set_settings - Set device-specific settings.
 914 *      @ndev: The network device to configure
 915 *      @cmd: The settings to configure
 916 */
 917static int
 918ks8695_wan_set_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
 919{
 920        struct ks8695_priv *ksp = netdev_priv(ndev);
 921        u32 ctrl;
 922
 923        if ((cmd->speed != SPEED_10) && (cmd->speed != SPEED_100))
 924                return -EINVAL;
 925        if ((cmd->duplex != DUPLEX_HALF) && (cmd->duplex != DUPLEX_FULL))
 926                return -EINVAL;
 927        if (cmd->port != PORT_MII)
 928                return -EINVAL;
 929        if (cmd->transceiver != XCVR_INTERNAL)
 930                return -EINVAL;
 931        if ((cmd->autoneg != AUTONEG_DISABLE) &&
 932            (cmd->autoneg != AUTONEG_ENABLE))
 933                return -EINVAL;
 934
 935        if (cmd->autoneg == AUTONEG_ENABLE) {
 936                if ((cmd->advertising & (ADVERTISED_10baseT_Half |
 937                                ADVERTISED_10baseT_Full |
 938                                ADVERTISED_100baseT_Half |
 939                                ADVERTISED_100baseT_Full)) == 0)
 940                        return -EINVAL;
 941
 942                ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
 943
 944                ctrl &= ~(WMC_WAND | WMC_WANA100F | WMC_WANA100H |
 945                          WMC_WANA10F | WMC_WANA10H);
 946                if (cmd->advertising & ADVERTISED_100baseT_Full)
 947                        ctrl |= WMC_WANA100F;
 948                if (cmd->advertising & ADVERTISED_100baseT_Half)
 949                        ctrl |= WMC_WANA100H;
 950                if (cmd->advertising & ADVERTISED_10baseT_Full)
 951                        ctrl |= WMC_WANA10F;
 952                if (cmd->advertising & ADVERTISED_10baseT_Half)
 953                        ctrl |= WMC_WANA10H;
 954
 955                /* force a re-negotiation */
 956                ctrl |= WMC_WANR;
 957                writel(ctrl, ksp->phyiface_regs + KS8695_WMC);
 958        } else {
 959                ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
 960
 961                /* disable auto-negotiation */
 962                ctrl |= WMC_WAND;
 963                ctrl &= ~(WMC_WANF100 | WMC_WANFF);
 964
 965                if (cmd->speed == SPEED_100)
 966                        ctrl |= WMC_WANF100;
 967                if (cmd->duplex == DUPLEX_FULL)
 968                        ctrl |= WMC_WANFF;
 969
 970                writel(ctrl, ksp->phyiface_regs + KS8695_WMC);
 971        }
 972
 973        return 0;
 974}
 975
 976/**
 977 *      ks8695_wan_nwayreset - Restart the autonegotiation on the port.
 978 *      @ndev: The network device to restart autoneotiation on
 979 */
 980static int
 981ks8695_wan_nwayreset(struct net_device *ndev)
 982{
 983        struct ks8695_priv *ksp = netdev_priv(ndev);
 984        u32 ctrl;
 985
 986        ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
 987
 988        if ((ctrl & WMC_WAND) == 0)
 989                writel(ctrl | WMC_WANR,
 990                       ksp->phyiface_regs + KS8695_WMC);
 991        else
 992                /* auto-negotiation not enabled */
 993                return -EINVAL;
 994
 995        return 0;
 996}
 997
 998/**
 999 *      ks8695_wan_get_pause - Retrieve network pause/flow-control advertising
1000 *      @ndev: The device to retrieve settings from
1001 *      @param: The structure to fill out with the information
1002 */
1003static void
1004ks8695_wan_get_pause(struct net_device *ndev, struct ethtool_pauseparam *param)
1005{
1006        struct ks8695_priv *ksp = netdev_priv(ndev);
1007        u32 ctrl;
1008
1009        ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
1010
1011        /* advertise Pause */
1012        param->autoneg = (ctrl & WMC_WANAP);
1013
1014        /* current Rx Flow-control */
1015        ctrl = ks8695_readreg(ksp, KS8695_DRXC);
1016        param->rx_pause = (ctrl & DRXC_RFCE);
1017
1018        /* current Tx Flow-control */
1019        ctrl = ks8695_readreg(ksp, KS8695_DTXC);
1020        param->tx_pause = (ctrl & DTXC_TFCE);
1021}
1022
1023/**
1024 *      ks8695_get_drvinfo - Retrieve driver information
1025 *      @ndev: The network device to retrieve info about
1026 *      @info: The info structure to fill out.
1027 */
1028static void
1029ks8695_get_drvinfo(struct net_device *ndev, struct ethtool_drvinfo *info)
1030{
1031        strlcpy(info->driver, MODULENAME, sizeof(info->driver));
1032        strlcpy(info->version, MODULEVERSION, sizeof(info->version));
1033        strlcpy(info->bus_info, dev_name(ndev->dev.parent),
1034                sizeof(info->bus_info));
1035}
1036
1037static const struct ethtool_ops ks8695_ethtool_ops = {
1038        .get_msglevel   = ks8695_get_msglevel,
1039        .set_msglevel   = ks8695_set_msglevel,
1040        .get_drvinfo    = ks8695_get_drvinfo,
1041};
1042
1043static const struct ethtool_ops ks8695_wan_ethtool_ops = {
1044        .get_msglevel   = ks8695_get_msglevel,
1045        .set_msglevel   = ks8695_set_msglevel,
1046        .get_settings   = ks8695_wan_get_settings,
1047        .set_settings   = ks8695_wan_set_settings,
1048        .nway_reset     = ks8695_wan_nwayreset,
1049        .get_link       = ethtool_op_get_link,
1050        .get_pauseparam = ks8695_wan_get_pause,
1051        .get_drvinfo    = ks8695_get_drvinfo,
1052};
1053
1054/* Network device interface functions */
1055
1056/**
1057 *      ks8695_set_mac - Update MAC in net dev and HW
1058 *      @ndev: The network device to update
1059 *      @addr: The new MAC address to set
1060 */
1061static int
1062ks8695_set_mac(struct net_device *ndev, void *addr)
1063{
1064        struct ks8695_priv *ksp = netdev_priv(ndev);
1065        struct sockaddr *address = addr;
1066
1067        if (!is_valid_ether_addr(address->sa_data))
1068                return -EADDRNOTAVAIL;
1069
1070        memcpy(ndev->dev_addr, address->sa_data, ndev->addr_len);
1071
1072        ks8695_update_mac(ksp);
1073
1074        dev_dbg(ksp->dev, "%s: Updated MAC address to %pM\n",
1075                ndev->name, ndev->dev_addr);
1076
1077        return 0;
1078}
1079
1080/**
1081 *      ks8695_set_multicast - Set up the multicast behaviour of the interface
1082 *      @ndev: The net_device to configure
1083 *
1084 *      This routine, called by the net layer, configures promiscuity
1085 *      and multicast reception behaviour for the interface.
1086 */
1087static void
1088ks8695_set_multicast(struct net_device *ndev)
1089{
1090        struct ks8695_priv *ksp = netdev_priv(ndev);
1091        u32 ctrl;
1092
1093        ctrl = ks8695_readreg(ksp, KS8695_DRXC);
1094
1095        if (ndev->flags & IFF_PROMISC) {
1096                /* enable promiscuous mode */
1097                ctrl |= DRXC_RA;
1098        } else if (ndev->flags & ~IFF_PROMISC) {
1099                /* disable promiscuous mode */
1100                ctrl &= ~DRXC_RA;
1101        }
1102
1103        if (ndev->flags & IFF_ALLMULTI) {
1104                /* enable all multicast mode */
1105                ctrl |= DRXC_RM;
1106        } else if (netdev_mc_count(ndev) > KS8695_NR_ADDRESSES) {
1107                /* more specific multicast addresses than can be
1108                 * handled in hardware
1109                 */
1110                ctrl |= DRXC_RM;
1111        } else {
1112                /* enable specific multicasts */
1113                ctrl &= ~DRXC_RM;
1114                ks8695_init_partial_multicast(ksp, ndev);
1115        }
1116
1117        ks8695_writereg(ksp, KS8695_DRXC, ctrl);
1118}
1119
1120/**
1121 *      ks8695_timeout - Handle a network tx/rx timeout.
1122 *      @ndev: The net_device which timed out.
1123 *
1124 *      A network transaction timed out, reset the device.
1125 */
1126static void
1127ks8695_timeout(struct net_device *ndev)
1128{
1129        struct ks8695_priv *ksp = netdev_priv(ndev);
1130
1131        netif_stop_queue(ndev);
1132        ks8695_shutdown(ksp);
1133
1134        ks8695_reset(ksp);
1135
1136        ks8695_update_mac(ksp);
1137
1138        /* We ignore the return from this since it managed to init
1139         * before it probably will be okay to init again.
1140         */
1141        ks8695_init_net(ksp);
1142
1143        /* Reconfigure promiscuity etc */
1144        ks8695_set_multicast(ndev);
1145
1146        /* And start the TX queue once more */
1147        netif_start_queue(ndev);
1148}
1149
1150/**
1151 *      ks8695_start_xmit - Start a packet transmission
1152 *      @skb: The packet to transmit
1153 *      @ndev: The network device to send the packet on
1154 *
1155 *      This routine, called by the net layer, takes ownership of the
1156 *      sk_buff and adds it to the TX ring. It then kicks the TX DMA
1157 *      engine to ensure transmission begins.
1158 */
1159static int
1160ks8695_start_xmit(struct sk_buff *skb, struct net_device *ndev)
1161{
1162        struct ks8695_priv *ksp = netdev_priv(ndev);
1163        int buff_n;
1164        dma_addr_t dmap;
1165
1166        spin_lock_irq(&ksp->txq_lock);
1167
1168        if (ksp->tx_ring_used == MAX_TX_DESC) {
1169                /* Somehow we got entered when we have no room */
1170                spin_unlock_irq(&ksp->txq_lock);
1171                return NETDEV_TX_BUSY;
1172        }
1173
1174        buff_n = ksp->tx_ring_next_slot;
1175
1176        BUG_ON(ksp->tx_buffers[buff_n].skb);
1177
1178        dmap = dma_map_single(ksp->dev, skb->data, skb->len, DMA_TO_DEVICE);
1179        if (unlikely(dma_mapping_error(ksp->dev, dmap))) {
1180                /* Failed to DMA map this SKB, give it back for now */
1181                spin_unlock_irq(&ksp->txq_lock);
1182                dev_dbg(ksp->dev, "%s: Could not map DMA memory for "\
1183                        "transmission, trying later\n", ndev->name);
1184                return NETDEV_TX_BUSY;
1185        }
1186
1187        ksp->tx_buffers[buff_n].dma_ptr = dmap;
1188        /* Mapped okay, store the buffer pointer and length for later */
1189        ksp->tx_buffers[buff_n].skb = skb;
1190        ksp->tx_buffers[buff_n].length = skb->len;
1191
1192        /* Fill out the TX descriptor */
1193        ksp->tx_ring[buff_n].data_ptr =
1194                cpu_to_le32(ksp->tx_buffers[buff_n].dma_ptr);
1195        ksp->tx_ring[buff_n].status =
1196                cpu_to_le32(TDES_IC | TDES_FS | TDES_LS |
1197                            (skb->len & TDES_TBS));
1198
1199        wmb();
1200
1201        /* Hand it over to the hardware */
1202        ksp->tx_ring[buff_n].owner = cpu_to_le32(TDES_OWN);
1203
1204        if (++ksp->tx_ring_used == MAX_TX_DESC)
1205                netif_stop_queue(ndev);
1206
1207        /* Kick the TX DMA in case it decided to go IDLE */
1208        ks8695_writereg(ksp, KS8695_DTSC, 0);
1209
1210        /* And update the next ring slot */
1211        ksp->tx_ring_next_slot = (buff_n + 1) & MAX_TX_DESC_MASK;
1212
1213        spin_unlock_irq(&ksp->txq_lock);
1214        return NETDEV_TX_OK;
1215}
1216
1217/**
1218 *      ks8695_stop - Stop (shutdown) a KS8695 ethernet interface
1219 *      @ndev: The net_device to stop
1220 *
1221 *      This disables the TX queue and cleans up a KS8695 ethernet
1222 *      device.
1223 */
1224static int
1225ks8695_stop(struct net_device *ndev)
1226{
1227        struct ks8695_priv *ksp = netdev_priv(ndev);
1228
1229        netif_stop_queue(ndev);
1230        napi_disable(&ksp->napi);
1231
1232        ks8695_shutdown(ksp);
1233
1234        return 0;
1235}
1236
1237/**
1238 *      ks8695_open - Open (bring up) a KS8695 ethernet interface
1239 *      @ndev: The net_device to open
1240 *
1241 *      This resets, configures the MAC, initialises the RX ring and
1242 *      DMA engines and starts the TX queue for a KS8695 ethernet
1243 *      device.
1244 */
1245static int
1246ks8695_open(struct net_device *ndev)
1247{
1248        struct ks8695_priv *ksp = netdev_priv(ndev);
1249        int ret;
1250
1251        ks8695_reset(ksp);
1252
1253        ks8695_update_mac(ksp);
1254
1255        ret = ks8695_init_net(ksp);
1256        if (ret) {
1257                ks8695_shutdown(ksp);
1258                return ret;
1259        }
1260
1261        napi_enable(&ksp->napi);
1262        netif_start_queue(ndev);
1263
1264        return 0;
1265}
1266
1267/* Platform device driver */
1268
1269/**
1270 *      ks8695_init_switch - Init LAN switch to known good defaults.
1271 *      @ksp: The device to initialise
1272 *
1273 *      This initialises the LAN switch in the KS8695 to a known-good
1274 *      set of defaults.
1275 */
1276static void
1277ks8695_init_switch(struct ks8695_priv *ksp)
1278{
1279        u32 ctrl;
1280
1281        /* Default value for SEC0 according to datasheet */
1282        ctrl = 0x40819e00;
1283
1284        /* LED0 = Speed  LED1 = Link/Activity */
1285        ctrl &= ~(SEC0_LLED1S | SEC0_LLED0S);
1286        ctrl |= (LLED0S_LINK | LLED1S_LINK_ACTIVITY);
1287
1288        /* Enable Switch */
1289        ctrl |= SEC0_ENABLE;
1290
1291        writel(ctrl, ksp->phyiface_regs + KS8695_SEC0);
1292
1293        /* Defaults for SEC1 */
1294        writel(0x9400100, ksp->phyiface_regs + KS8695_SEC1);
1295}
1296
1297/**
1298 *      ks8695_init_wan_phy - Initialise the WAN PHY to sensible defaults
1299 *      @ksp: The device to initialise
1300 *
1301 *      This initialises a KS8695's WAN phy to sensible values for
1302 *      autonegotiation etc.
1303 */
1304static void
1305ks8695_init_wan_phy(struct ks8695_priv *ksp)
1306{
1307        u32 ctrl;
1308
1309        /* Support auto-negotiation */
1310        ctrl = (WMC_WANAP | WMC_WANA100F | WMC_WANA100H |
1311                WMC_WANA10F | WMC_WANA10H);
1312
1313        /* LED0 = Activity , LED1 = Link */
1314        ctrl |= (WLED0S_ACTIVITY | WLED1S_LINK);
1315
1316        /* Restart Auto-negotiation */
1317        ctrl |= WMC_WANR;
1318
1319        writel(ctrl, ksp->phyiface_regs + KS8695_WMC);
1320
1321        writel(0, ksp->phyiface_regs + KS8695_WPPM);
1322        writel(0, ksp->phyiface_regs + KS8695_PPS);
1323}
1324
1325static const struct net_device_ops ks8695_netdev_ops = {
1326        .ndo_open               = ks8695_open,
1327        .ndo_stop               = ks8695_stop,
1328        .ndo_start_xmit         = ks8695_start_xmit,
1329        .ndo_tx_timeout         = ks8695_timeout,
1330        .ndo_set_mac_address    = ks8695_set_mac,
1331        .ndo_validate_addr      = eth_validate_addr,
1332        .ndo_set_rx_mode        = ks8695_set_multicast,
1333};
1334
1335/**
1336 *      ks8695_probe - Probe and initialise a KS8695 ethernet interface
1337 *      @pdev: The platform device to probe
1338 *
1339 *      Initialise a KS8695 ethernet device from platform data.
1340 *
1341 *      This driver requires at least one IORESOURCE_MEM for the
1342 *      registers and two IORESOURCE_IRQ for the RX and TX IRQs
1343 *      respectively. It can optionally take an additional
1344 *      IORESOURCE_MEM for the switch or phy in the case of the lan or
1345 *      wan ports, and an IORESOURCE_IRQ for the link IRQ for the wan
1346 *      port.
1347 */
1348static int
1349ks8695_probe(struct platform_device *pdev)
1350{
1351        struct ks8695_priv *ksp;
1352        struct net_device *ndev;
1353        struct resource *regs_res, *phyiface_res;
1354        struct resource *rxirq_res, *txirq_res, *linkirq_res;
1355        int ret = 0;
1356        int buff_n;
1357        u32 machigh, maclow;
1358
1359        /* Initialise a net_device */
1360        ndev = alloc_etherdev(sizeof(struct ks8695_priv));
1361        if (!ndev)
1362                return -ENOMEM;
1363
1364        SET_NETDEV_DEV(ndev, &pdev->dev);
1365
1366        dev_dbg(&pdev->dev, "ks8695_probe() called\n");
1367
1368        /* Configure our private structure a little */
1369        ksp = netdev_priv(ndev);
1370
1371        ksp->dev = &pdev->dev;
1372        ksp->ndev = ndev;
1373        ksp->msg_enable = NETIF_MSG_LINK;
1374
1375        /* Retrieve resources */
1376        regs_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1377        phyiface_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1378
1379        rxirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1380        txirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
1381        linkirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 2);
1382
1383        if (!(regs_res && rxirq_res && txirq_res)) {
1384                dev_err(ksp->dev, "insufficient resources\n");
1385                ret = -ENOENT;
1386                goto failure;
1387        }
1388
1389        ksp->regs_req = request_mem_region(regs_res->start,
1390                                           resource_size(regs_res),
1391                                           pdev->name);
1392
1393        if (!ksp->regs_req) {
1394                dev_err(ksp->dev, "cannot claim register space\n");
1395                ret = -EIO;
1396                goto failure;
1397        }
1398
1399        ksp->io_regs = ioremap(regs_res->start, resource_size(regs_res));
1400
1401        if (!ksp->io_regs) {
1402                dev_err(ksp->dev, "failed to ioremap registers\n");
1403                ret = -EINVAL;
1404                goto failure;
1405        }
1406
1407        if (phyiface_res) {
1408                ksp->phyiface_req =
1409                        request_mem_region(phyiface_res->start,
1410                                           resource_size(phyiface_res),
1411                                           phyiface_res->name);
1412
1413                if (!ksp->phyiface_req) {
1414                        dev_err(ksp->dev,
1415                                "cannot claim switch register space\n");
1416                        ret = -EIO;
1417                        goto failure;
1418                }
1419
1420                ksp->phyiface_regs = ioremap(phyiface_res->start,
1421                                             resource_size(phyiface_res));
1422
1423                if (!ksp->phyiface_regs) {
1424                        dev_err(ksp->dev,
1425                                "failed to ioremap switch registers\n");
1426                        ret = -EINVAL;
1427                        goto failure;
1428                }
1429        }
1430
1431        ksp->rx_irq = rxirq_res->start;
1432        ksp->rx_irq_name = rxirq_res->name ? rxirq_res->name : "Ethernet RX";
1433        ksp->tx_irq = txirq_res->start;
1434        ksp->tx_irq_name = txirq_res->name ? txirq_res->name : "Ethernet TX";
1435        ksp->link_irq = (linkirq_res ? linkirq_res->start : -1);
1436        ksp->link_irq_name = (linkirq_res && linkirq_res->name) ?
1437                linkirq_res->name : "Ethernet Link";
1438
1439        /* driver system setup */
1440        ndev->netdev_ops = &ks8695_netdev_ops;
1441        ndev->watchdog_timeo     = msecs_to_jiffies(watchdog);
1442
1443        netif_napi_add(ndev, &ksp->napi, ks8695_poll, NAPI_WEIGHT);
1444
1445        /* Retrieve the default MAC addr from the chip. */
1446        /* The bootloader should have left it in there for us. */
1447
1448        machigh = ks8695_readreg(ksp, KS8695_MAH);
1449        maclow = ks8695_readreg(ksp, KS8695_MAL);
1450
1451        ndev->dev_addr[0] = (machigh >> 8) & 0xFF;
1452        ndev->dev_addr[1] = machigh & 0xFF;
1453        ndev->dev_addr[2] = (maclow >> 24) & 0xFF;
1454        ndev->dev_addr[3] = (maclow >> 16) & 0xFF;
1455        ndev->dev_addr[4] = (maclow >> 8) & 0xFF;
1456        ndev->dev_addr[5] = maclow & 0xFF;
1457
1458        if (!is_valid_ether_addr(ndev->dev_addr))
1459                dev_warn(ksp->dev, "%s: Invalid ethernet MAC address. Please "
1460                         "set using ifconfig\n", ndev->name);
1461
1462        /* In order to be efficient memory-wise, we allocate both
1463         * rings in one go.
1464         */
1465        ksp->ring_base = dma_alloc_coherent(&pdev->dev, RING_DMA_SIZE,
1466                                            &ksp->ring_base_dma, GFP_KERNEL);
1467        if (!ksp->ring_base) {
1468                ret = -ENOMEM;
1469                goto failure;
1470        }
1471
1472        /* Specify the TX DMA ring buffer */
1473        ksp->tx_ring = ksp->ring_base;
1474        ksp->tx_ring_dma = ksp->ring_base_dma;
1475
1476        /* And initialise the queue's lock */
1477        spin_lock_init(&ksp->txq_lock);
1478        spin_lock_init(&ksp->rx_lock);
1479
1480        /* Specify the RX DMA ring buffer */
1481        ksp->rx_ring = ksp->ring_base + TX_RING_DMA_SIZE;
1482        ksp->rx_ring_dma = ksp->ring_base_dma + TX_RING_DMA_SIZE;
1483
1484        /* Zero the descriptor rings */
1485        memset(ksp->tx_ring, 0, TX_RING_DMA_SIZE);
1486        memset(ksp->rx_ring, 0, RX_RING_DMA_SIZE);
1487
1488        /* Build the rings */
1489        for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) {
1490                ksp->tx_ring[buff_n].next_desc =
1491                        cpu_to_le32(ksp->tx_ring_dma +
1492                                    (sizeof(struct tx_ring_desc) *
1493                                     ((buff_n + 1) & MAX_TX_DESC_MASK)));
1494        }
1495
1496        for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) {
1497                ksp->rx_ring[buff_n].next_desc =
1498                        cpu_to_le32(ksp->rx_ring_dma +
1499                                    (sizeof(struct rx_ring_desc) *
1500                                     ((buff_n + 1) & MAX_RX_DESC_MASK)));
1501        }
1502
1503        /* Initialise the port (physically) */
1504        if (ksp->phyiface_regs && ksp->link_irq == -1) {
1505                ks8695_init_switch(ksp);
1506                ksp->dtype = KS8695_DTYPE_LAN;
1507                ndev->ethtool_ops = &ks8695_ethtool_ops;
1508        } else if (ksp->phyiface_regs && ksp->link_irq != -1) {
1509                ks8695_init_wan_phy(ksp);
1510                ksp->dtype = KS8695_DTYPE_WAN;
1511                ndev->ethtool_ops = &ks8695_wan_ethtool_ops;
1512        } else {
1513                /* No initialisation since HPNA does not have a PHY */
1514                ksp->dtype = KS8695_DTYPE_HPNA;
1515                ndev->ethtool_ops = &ks8695_ethtool_ops;
1516        }
1517
1518        /* And bring up the net_device with the net core */
1519        platform_set_drvdata(pdev, ndev);
1520        ret = register_netdev(ndev);
1521
1522        if (ret == 0) {
1523                dev_info(ksp->dev, "ks8695 ethernet (%s) MAC: %pM\n",
1524                         ks8695_port_type(ksp), ndev->dev_addr);
1525        } else {
1526                /* Report the failure to register the net_device */
1527                dev_err(ksp->dev, "ks8695net: failed to register netdev.\n");
1528                goto failure;
1529        }
1530
1531        /* All is well */
1532        return 0;
1533
1534        /* Error exit path */
1535failure:
1536        ks8695_release_device(ksp);
1537        free_netdev(ndev);
1538
1539        return ret;
1540}
1541
1542/**
1543 *      ks8695_drv_suspend - Suspend a KS8695 ethernet platform device.
1544 *      @pdev: The device to suspend
1545 *      @state: The suspend state
1546 *
1547 *      This routine detaches and shuts down a KS8695 ethernet device.
1548 */
1549static int
1550ks8695_drv_suspend(struct platform_device *pdev, pm_message_t state)
1551{
1552        struct net_device *ndev = platform_get_drvdata(pdev);
1553        struct ks8695_priv *ksp = netdev_priv(ndev);
1554
1555        ksp->in_suspend = 1;
1556
1557        if (netif_running(ndev)) {
1558                netif_device_detach(ndev);
1559                ks8695_shutdown(ksp);
1560        }
1561
1562        return 0;
1563}
1564
1565/**
1566 *      ks8695_drv_resume - Resume a KS8695 ethernet platform device.
1567 *      @pdev: The device to resume
1568 *
1569 *      This routine re-initialises and re-attaches a KS8695 ethernet
1570 *      device.
1571 */
1572static int
1573ks8695_drv_resume(struct platform_device *pdev)
1574{
1575        struct net_device *ndev = platform_get_drvdata(pdev);
1576        struct ks8695_priv *ksp = netdev_priv(ndev);
1577
1578        if (netif_running(ndev)) {
1579                ks8695_reset(ksp);
1580                ks8695_init_net(ksp);
1581                ks8695_set_multicast(ndev);
1582                netif_device_attach(ndev);
1583        }
1584
1585        ksp->in_suspend = 0;
1586
1587        return 0;
1588}
1589
1590/**
1591 *      ks8695_drv_remove - Remove a KS8695 net device on driver unload.
1592 *      @pdev: The platform device to remove
1593 *
1594 *      This unregisters and releases a KS8695 ethernet device.
1595 */
1596static int
1597ks8695_drv_remove(struct platform_device *pdev)
1598{
1599        struct net_device *ndev = platform_get_drvdata(pdev);
1600        struct ks8695_priv *ksp = netdev_priv(ndev);
1601
1602        netif_napi_del(&ksp->napi);
1603
1604        unregister_netdev(ndev);
1605        ks8695_release_device(ksp);
1606        free_netdev(ndev);
1607
1608        dev_dbg(&pdev->dev, "released and freed device\n");
1609        return 0;
1610}
1611
1612static struct platform_driver ks8695_driver = {
1613        .driver = {
1614                .name   = MODULENAME,
1615                .owner  = THIS_MODULE,
1616        },
1617        .probe          = ks8695_probe,
1618        .remove         = ks8695_drv_remove,
1619        .suspend        = ks8695_drv_suspend,
1620        .resume         = ks8695_drv_resume,
1621};
1622
1623module_platform_driver(ks8695_driver);
1624
1625MODULE_AUTHOR("Simtec Electronics");
1626MODULE_DESCRIPTION("Micrel KS8695 (Centaur) Ethernet driver");
1627MODULE_LICENSE("GPL");
1628MODULE_ALIAS("platform:" MODULENAME);
1629
1630module_param(watchdog, int, 0400);
1631MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds");
1632