drivers/net/arm/ks8695net.c

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