drivers/net/ethernet/micrel/ks8842.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ks8842.c timberdale KS8842 ethernet driver
   4  * Copyright (c) 2009 Intel Corporation
   5  */
   6
   7 /* Supports:
   8  * The Micrel KS8842 behind the timberdale FPGA
   9  * The genuine Micrel KS8841/42 device with ISA 16/32bit bus interface
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #include <linux/interrupt.h>
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/netdevice.h>
  19 #include <linux/etherdevice.h>
  20 #include <linux/ethtool.h>
  21 #include <linux/ks8842.h>
  22 #include <linux/dmaengine.h>
  23 #include <linux/dma-mapping.h>
  24 #include <linux/scatterlist.h>
  25
  26 #define DRV_NAME "ks8842"
  27
  28 /* Timberdale specific Registers */
  29 #define REG_TIMB_RST            0x1c
  30 #define REG_TIMB_FIFO           0x20
  31 #define REG_TIMB_ISR            0x24
  32 #define REG_TIMB_IER            0x28
  33 #define REG_TIMB_IAR            0x2C
  34 #define REQ_TIMB_DMA_RESUME     0x30
  35
  36 /* KS8842 registers */
  37
  38 #define REG_SELECT_BANK 0x0e
  39
  40 /* bank 0 registers */
  41 #define REG_QRFCR       0x04
  42
  43 /* bank 2 registers */
  44 #define REG_MARL        0x00
  45 #define REG_MARM        0x02
  46 #define REG_MARH        0x04
  47
  48 /* bank 3 registers */
  49 #define REG_GRR         0x06
  50
  51 /* bank 16 registers */
  52 #define REG_TXCR        0x00
  53 #define REG_TXSR        0x02
  54 #define REG_RXCR        0x04
  55 #define REG_TXMIR       0x08
  56 #define REG_RXMIR       0x0A
  57
  58 /* bank 17 registers */
  59 #define REG_TXQCR       0x00
  60 #define REG_RXQCR       0x02
  61 #define REG_TXFDPR      0x04
  62 #define REG_RXFDPR      0x06
  63 #define REG_QMU_DATA_LO 0x08
  64 #define REG_QMU_DATA_HI 0x0A
  65
  66 /* bank 18 registers */
  67 #define REG_IER         0x00
  68 #define IRQ_LINK_CHANGE 0x8000
  69 #define IRQ_TX          0x4000
  70 #define IRQ_RX          0x2000
  71 #define IRQ_RX_OVERRUN  0x0800
  72 #define IRQ_TX_STOPPED  0x0200
  73 #define IRQ_RX_STOPPED  0x0100
  74 #define IRQ_RX_ERROR    0x0080
  75 #define ENABLED_IRQS    (IRQ_LINK_CHANGE | IRQ_TX | IRQ_RX | IRQ_RX_STOPPED | \
  76                 IRQ_TX_STOPPED | IRQ_RX_OVERRUN | IRQ_RX_ERROR)
  77 /* When running via timberdale in DMA mode, the RX interrupt should be
  78    enabled in the KS8842, but not in the FPGA IP, since the IP handles
  79    RX DMA internally.
  80    TX interrupts are not needed it is handled by the FPGA the driver is
  81    notified via DMA callbacks.
  82 */
  83 #define ENABLED_IRQS_DMA_IP     (IRQ_LINK_CHANGE | IRQ_RX_STOPPED | \
  84         IRQ_TX_STOPPED | IRQ_RX_OVERRUN | IRQ_RX_ERROR)
  85 #define ENABLED_IRQS_DMA        (ENABLED_IRQS_DMA_IP | IRQ_RX)
  86 #define REG_ISR         0x02
  87 #define REG_RXSR        0x04
  88 #define RXSR_VALID      0x8000
  89 #define RXSR_BROADCAST  0x80
  90 #define RXSR_MULTICAST  0x40
  91 #define RXSR_UNICAST    0x20
  92 #define RXSR_FRAMETYPE  0x08
  93 #define RXSR_TOO_LONG   0x04
  94 #define RXSR_RUNT       0x02
  95 #define RXSR_CRC_ERROR  0x01
  96 #define RXSR_ERROR      (RXSR_TOO_LONG | RXSR_RUNT | RXSR_CRC_ERROR)
  97
  98 /* bank 32 registers */
  99 #define REG_SW_ID_AND_ENABLE    0x00
 100 #define REG_SGCR1               0x02
 101 #define REG_SGCR2               0x04
 102 #define REG_SGCR3               0x06
 103
 104 /* bank 39 registers */
 105 #define REG_MACAR1              0x00
 106 #define REG_MACAR2              0x02
 107 #define REG_MACAR3              0x04
 108
 109 /* bank 45 registers */
 110 #define REG_P1MBCR              0x00
 111 #define REG_P1MBSR              0x02
 112
 113 /* bank 46 registers */
 114 #define REG_P2MBCR              0x00
 115 #define REG_P2MBSR              0x02
 116
 117 /* bank 48 registers */
 118 #define REG_P1CR2               0x02
 119
 120 /* bank 49 registers */
 121 #define REG_P1CR4               0x02
 122 #define REG_P1SR                0x04
 123
 124 /* flags passed by platform_device for configuration */
 125 #define MICREL_KS884X           0x01    /* 0=Timeberdale(FPGA), 1=Micrel */
 126 #define KS884X_16BIT            0x02    /*  1=16bit, 0=32bit */
 127
 128 #define DMA_BUFFER_SIZE         2048
 129
 130 struct ks8842_tx_dma_ctl {
 131         struct dma_chan *chan;
 132         struct dma_async_tx_descriptor *adesc;
 133         void *buf;
 134         struct scatterlist sg;
 135         int channel;
 136 };
 137
 138 struct ks8842_rx_dma_ctl {
 139         struct dma_chan *chan;
 140         struct dma_async_tx_descriptor *adesc;
 141         struct sk_buff  *skb;
 142         struct scatterlist sg;
 143         struct tasklet_struct tasklet;
 144         int channel;
 145 };
 146
 147 #define KS8842_USE_DMA(adapter) (((adapter)->dma_tx.channel != -1) && \
 148          ((adapter)->dma_rx.channel != -1))
 149
 150 struct ks8842_adapter {
 151         void __iomem    *hw_addr;
 152         int             irq;
 153         unsigned long   conf_flags;     /* copy of platform_device config */
 154         struct tasklet_struct   tasklet;
 155         spinlock_t      lock; /* spinlock to be interrupt safe */
 156         struct work_struct timeout_work;
 157         struct net_device *netdev;
 158         struct device *dev;
 159         struct ks8842_tx_dma_ctl        dma_tx;
 160         struct ks8842_rx_dma_ctl        dma_rx;
 161 };
 162
 163 static void ks8842_dma_rx_cb(void *data);
 164 static void ks8842_dma_tx_cb(void *data);
 165
 166 static inline void ks8842_resume_dma(struct ks8842_adapter *adapter)
 167 {
 168         iowrite32(1, adapter->hw_addr + REQ_TIMB_DMA_RESUME);
 169 }
 170
 171 static inline void ks8842_select_bank(struct ks8842_adapter *adapter, u16 bank)
 172 {
 173         iowrite16(bank, adapter->hw_addr + REG_SELECT_BANK);
 174 }
 175
 176 static inline void ks8842_write8(struct ks8842_adapter *adapter, u16 bank,
 177         u8 value, int offset)
 178 {
 179         ks8842_select_bank(adapter, bank);
 180         iowrite8(value, adapter->hw_addr + offset);
 181 }
 182
 183 static inline void ks8842_write16(struct ks8842_adapter *adapter, u16 bank,
 184         u16 value, int offset)
 185 {
 186         ks8842_select_bank(adapter, bank);
 187         iowrite16(value, adapter->hw_addr + offset);
 188 }
 189
 190 static inline void ks8842_enable_bits(struct ks8842_adapter *adapter, u16 bank,
 191         u16 bits, int offset)
 192 {
 193         u16 reg;
 194         ks8842_select_bank(adapter, bank);
 195         reg = ioread16(adapter->hw_addr + offset);
 196         reg |= bits;
 197         iowrite16(reg, adapter->hw_addr + offset);
 198 }
 199
 200 static inline void ks8842_clear_bits(struct ks8842_adapter *adapter, u16 bank,
 201         u16 bits, int offset)
 202 {
 203         u16 reg;
 204         ks8842_select_bank(adapter, bank);
 205         reg = ioread16(adapter->hw_addr + offset);
 206         reg &= ~bits;
 207         iowrite16(reg, adapter->hw_addr + offset);
 208 }
 209
 210 static inline void ks8842_write32(struct ks8842_adapter *adapter, u16 bank,
 211         u32 value, int offset)
 212 {
 213         ks8842_select_bank(adapter, bank);
 214         iowrite32(value, adapter->hw_addr + offset);
 215 }
 216
 217 static inline u8 ks8842_read8(struct ks8842_adapter *adapter, u16 bank,
 218         int offset)
 219 {
 220         ks8842_select_bank(adapter, bank);
 221         return ioread8(adapter->hw_addr + offset);
 222 }
 223
 224 static inline u16 ks8842_read16(struct ks8842_adapter *adapter, u16 bank,
 225         int offset)
 226 {
 227         ks8842_select_bank(adapter, bank);
 228         return ioread16(adapter->hw_addr + offset);
 229 }
 230
 231 static inline u32 ks8842_read32(struct ks8842_adapter *adapter, u16 bank,
 232         int offset)
 233 {
 234         ks8842_select_bank(adapter, bank);
 235         return ioread32(adapter->hw_addr + offset);
 236 }
 237
 238 static void ks8842_reset(struct ks8842_adapter *adapter)
 239 {
 240         if (adapter->conf_flags & MICREL_KS884X) {
 241                 ks8842_write16(adapter, 3, 1, REG_GRR);
 242                 msleep(10);
 243                 iowrite16(0, adapter->hw_addr + REG_GRR);
 244         } else {
 245                 /* The KS8842 goes haywire when doing softare reset
 246                 * a work around in the timberdale IP is implemented to
 247                 * do a hardware reset instead
 248                 ks8842_write16(adapter, 3, 1, REG_GRR);
 249                 msleep(10);
 250                 iowrite16(0, adapter->hw_addr + REG_GRR);
 251                 */
 252                 iowrite32(0x1, adapter->hw_addr + REG_TIMB_RST);
 253                 msleep(20);
 254         }
 255 }
 256
 257 static void ks8842_update_link_status(struct net_device *netdev,
 258         struct ks8842_adapter *adapter)
 259 {
 260         /* check the status of the link */
 261         if (ks8842_read16(adapter, 45, REG_P1MBSR) & 0x4) {
 262                 netif_carrier_on(netdev);
 263                 netif_wake_queue(netdev);
 264         } else {
 265                 netif_stop_queue(netdev);
 266                 netif_carrier_off(netdev);
 267         }
 268 }
 269
 270 static void ks8842_enable_tx(struct ks8842_adapter *adapter)
 271 {
 272         ks8842_enable_bits(adapter, 16, 0x01, REG_TXCR);
 273 }
 274
 275 static void ks8842_disable_tx(struct ks8842_adapter *adapter)
 276 {
 277         ks8842_clear_bits(adapter, 16, 0x01, REG_TXCR);
 278 }
 279
 280 static void ks8842_enable_rx(struct ks8842_adapter *adapter)
 281 {
 282         ks8842_enable_bits(adapter, 16, 0x01, REG_RXCR);
 283 }
 284
 285 static void ks8842_disable_rx(struct ks8842_adapter *adapter)
 286 {
 287         ks8842_clear_bits(adapter, 16, 0x01, REG_RXCR);
 288 }
 289
 290 static void ks8842_reset_hw(struct ks8842_adapter *adapter)
 291 {
 292         /* reset the HW */
 293         ks8842_reset(adapter);
 294
 295         /* Enable QMU Transmit flow control / transmit padding / Transmit CRC */
 296         ks8842_write16(adapter, 16, 0x000E, REG_TXCR);
 297
 298         /* enable the receiver, uni + multi + broadcast + flow ctrl
 299                 + crc strip */
 300         ks8842_write16(adapter, 16, 0x8 | 0x20 | 0x40 | 0x80 | 0x400,
 301                 REG_RXCR);
 302
 303         /* TX frame pointer autoincrement */
 304         ks8842_write16(adapter, 17, 0x4000, REG_TXFDPR);
 305
 306         /* RX frame pointer autoincrement */
 307         ks8842_write16(adapter, 17, 0x4000, REG_RXFDPR);
 308
 309         /* RX 2 kb high watermark */
 310         ks8842_write16(adapter, 0, 0x1000, REG_QRFCR);
 311
 312         /* aggressive back off in half duplex */
 313         ks8842_enable_bits(adapter, 32, 1 << 8, REG_SGCR1);
 314
 315         /* enable no excessive collison drop */
 316         ks8842_enable_bits(adapter, 32, 1 << 3, REG_SGCR2);
 317
 318         /* Enable port 1 force flow control / back pressure / transmit / recv */
 319         ks8842_write16(adapter, 48, 0x1E07, REG_P1CR2);
 320
 321         /* restart port auto-negotiation */
 322         ks8842_enable_bits(adapter, 49, 1 << 13, REG_P1CR4);
 323
 324         /* Enable the transmitter */
 325         ks8842_enable_tx(adapter);
 326
 327         /* Enable the receiver */
 328         ks8842_enable_rx(adapter);
 329
 330         /* clear all interrupts */
 331         ks8842_write16(adapter, 18, 0xffff, REG_ISR);
 332
 333         /* enable interrupts */
 334         if (KS8842_USE_DMA(adapter)) {
 335                 /* When running in DMA Mode the RX interrupt is not enabled in
 336                    timberdale because RX data is received by DMA callbacks
 337                    it must still be enabled in the KS8842 because it indicates
 338                    to timberdale when there is RX data for it's DMA FIFOs */
 339                 iowrite16(ENABLED_IRQS_DMA_IP, adapter->hw_addr + REG_TIMB_IER);
 340                 ks8842_write16(adapter, 18, ENABLED_IRQS_DMA, REG_IER);
 341         } else {
 342                 if (!(adapter->conf_flags & MICREL_KS884X))
 343                         iowrite16(ENABLED_IRQS,
 344                                 adapter->hw_addr + REG_TIMB_IER);
 345                 ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
 346         }
 347         /* enable the switch */
 348         ks8842_write16(adapter, 32, 0x1, REG_SW_ID_AND_ENABLE);
 349 }
 350
 351 static void ks8842_read_mac_addr(struct ks8842_adapter *adapter, u8 *dest)
 352 {
 353         int i;
 354         u16 mac;
 355
 356         for (i = 0; i < ETH_ALEN; i++)
 357                 dest[ETH_ALEN - i - 1] = ks8842_read8(adapter, 2, REG_MARL + i);
 358
 359         if (adapter->conf_flags & MICREL_KS884X) {
 360                 /*
 361                 the sequence of saving mac addr between MAC and Switch is
 362                 different.
 363                 */
 364
 365                 mac = ks8842_read16(adapter, 2, REG_MARL);
 366                 ks8842_write16(adapter, 39, mac, REG_MACAR3);
 367                 mac = ks8842_read16(adapter, 2, REG_MARM);
 368                 ks8842_write16(adapter, 39, mac, REG_MACAR2);
 369                 mac = ks8842_read16(adapter, 2, REG_MARH);
 370                 ks8842_write16(adapter, 39, mac, REG_MACAR1);
 371         } else {
 372
 373                 /* make sure the switch port uses the same MAC as the QMU */
 374                 mac = ks8842_read16(adapter, 2, REG_MARL);
 375                 ks8842_write16(adapter, 39, mac, REG_MACAR1);
 376                 mac = ks8842_read16(adapter, 2, REG_MARM);
 377                 ks8842_write16(adapter, 39, mac, REG_MACAR2);
 378                 mac = ks8842_read16(adapter, 2, REG_MARH);
 379                 ks8842_write16(adapter, 39, mac, REG_MACAR3);
 380         }
 381 }
 382
 383 static void ks8842_write_mac_addr(struct ks8842_adapter *adapter, u8 *mac)
 384 {
 385         unsigned long flags;
 386         unsigned i;
 387
 388         spin_lock_irqsave(&adapter->lock, flags);
 389         for (i = 0; i < ETH_ALEN; i++) {
 390                 ks8842_write8(adapter, 2, mac[ETH_ALEN - i - 1], REG_MARL + i);
 391                 if (!(adapter->conf_flags & MICREL_KS884X))
 392                         ks8842_write8(adapter, 39, mac[ETH_ALEN - i - 1],
 393                                 REG_MACAR1 + i);
 394         }
 395
 396         if (adapter->conf_flags & MICREL_KS884X) {
 397                 /*
 398                 the sequence of saving mac addr between MAC and Switch is
 399                 different.
 400                 */
 401
 402                 u16 mac;
 403
 404                 mac = ks8842_read16(adapter, 2, REG_MARL);
 405                 ks8842_write16(adapter, 39, mac, REG_MACAR3);
 406                 mac = ks8842_read16(adapter, 2, REG_MARM);
 407                 ks8842_write16(adapter, 39, mac, REG_MACAR2);
 408                 mac = ks8842_read16(adapter, 2, REG_MARH);
 409                 ks8842_write16(adapter, 39, mac, REG_MACAR1);
 410         }
 411         spin_unlock_irqrestore(&adapter->lock, flags);
 412 }
 413
 414 static inline u16 ks8842_tx_fifo_space(struct ks8842_adapter *adapter)
 415 {
 416         return ks8842_read16(adapter, 16, REG_TXMIR) & 0x1fff;
 417 }
 418
 419 static int ks8842_tx_frame_dma(struct sk_buff *skb, struct net_device *netdev)
 420 {
 421         struct ks8842_adapter *adapter = netdev_priv(netdev);
 422         struct ks8842_tx_dma_ctl *ctl = &adapter->dma_tx;
 423         u8 *buf = ctl->buf;
 424
 425         if (ctl->adesc) {
 426                 netdev_dbg(netdev, "%s: TX ongoing\n", __func__);
 427                 /* transfer ongoing */
 428                 return NETDEV_TX_BUSY;
 429         }
 430
 431         sg_dma_len(&ctl->sg) = skb->len + sizeof(u32);
 432
 433         /* copy data to the TX buffer */
 434         /* the control word, enable IRQ, port 1 and the length */
 435         *buf++ = 0x00;
 436         *buf++ = 0x01; /* Port 1 */
 437         *buf++ = skb->len & 0xff;
 438         *buf++ = (skb->len >> 8) & 0xff;
 439         skb_copy_from_linear_data(skb, buf, skb->len);
 440
 441         dma_sync_single_range_for_device(adapter->dev,
 442                 sg_dma_address(&ctl->sg), 0, sg_dma_len(&ctl->sg),
 443                 DMA_TO_DEVICE);
 444
 445         /* make sure the length is a multiple of 4 */
 446         if (sg_dma_len(&ctl->sg) % 4)
 447                 sg_dma_len(&ctl->sg) += 4 - sg_dma_len(&ctl->sg) % 4;
 448
 449         ctl->adesc = dmaengine_prep_slave_sg(ctl->chan,
 450                 &ctl->sg, 1, DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT);
 451         if (!ctl->adesc)
 452                 return NETDEV_TX_BUSY;
 453
 454         ctl->adesc->callback_param = netdev;
 455         ctl->adesc->callback = ks8842_dma_tx_cb;
 456         ctl->adesc->tx_submit(ctl->adesc);
 457
 458         netdev->stats.tx_bytes += skb->len;
 459
 460         dev_kfree_skb(skb);
 461
 462         return NETDEV_TX_OK;
 463 }
 464
 465 static int ks8842_tx_frame(struct sk_buff *skb, struct net_device *netdev)
 466 {
 467         struct ks8842_adapter *adapter = netdev_priv(netdev);
 468         int len = skb->len;
 469
 470         netdev_dbg(netdev, "%s: len %u head %p data %p tail %p end %p\n",
 471                 __func__, skb->len, skb->head, skb->data,
 472                 skb_tail_pointer(skb), skb_end_pointer(skb));
 473
 474         /* check FIFO buffer space, we need space for CRC and command bits */
 475         if (ks8842_tx_fifo_space(adapter) < len + 8)
 476                 return NETDEV_TX_BUSY;
 477
 478         if (adapter->conf_flags & KS884X_16BIT) {
 479                 u16 *ptr16 = (u16 *)skb->data;
 480                 ks8842_write16(adapter, 17, 0x8000 | 0x100, REG_QMU_DATA_LO);
 481                 ks8842_write16(adapter, 17, (u16)len, REG_QMU_DATA_HI);
 482                 netdev->stats.tx_bytes += len;
 483
 484                 /* copy buffer */
 485                 while (len > 0) {
 486                         iowrite16(*ptr16++, adapter->hw_addr + REG_QMU_DATA_LO);
 487                         iowrite16(*ptr16++, adapter->hw_addr + REG_QMU_DATA_HI);
 488                         len -= sizeof(u32);
 489                 }
 490         } else {
 491
 492                 u32 *ptr = (u32 *)skb->data;
 493                 u32 ctrl;
 494                 /* the control word, enable IRQ, port 1 and the length */
 495                 ctrl = 0x8000 | 0x100 | (len << 16);
 496                 ks8842_write32(adapter, 17, ctrl, REG_QMU_DATA_LO);
 497
 498                 netdev->stats.tx_bytes += len;
 499
 500                 /* copy buffer */
 501                 while (len > 0) {
 502                         iowrite32(*ptr, adapter->hw_addr + REG_QMU_DATA_LO);
 503                         len -= sizeof(u32);
 504                         ptr++;
 505                 }
 506         }
 507
 508         /* enqueue packet */
 509         ks8842_write16(adapter, 17, 1, REG_TXQCR);
 510
 511         dev_kfree_skb(skb);
 512
 513         return NETDEV_TX_OK;
 514 }
 515
 516 static void ks8842_update_rx_err_counters(struct net_device *netdev, u32 status)
 517 {
 518         netdev_dbg(netdev, "RX error, status: %x\n", status);
 519
 520         netdev->stats.rx_errors++;
 521         if (status & RXSR_TOO_LONG)
 522                 netdev->stats.rx_length_errors++;
 523         if (status & RXSR_CRC_ERROR)
 524                 netdev->stats.rx_crc_errors++;
 525         if (status & RXSR_RUNT)
 526                 netdev->stats.rx_frame_errors++;
 527 }
 528
 529 static void ks8842_update_rx_counters(struct net_device *netdev, u32 status,
 530         int len)
 531 {
 532         netdev_dbg(netdev, "RX packet, len: %d\n", len);
 533
 534         netdev->stats.rx_packets++;
 535         netdev->stats.rx_bytes += len;
 536         if (status & RXSR_MULTICAST)
 537                 netdev->stats.multicast++;
 538 }
 539
 540 static int __ks8842_start_new_rx_dma(struct net_device *netdev)
 541 {
 542         struct ks8842_adapter *adapter = netdev_priv(netdev);
 543         struct ks8842_rx_dma_ctl *ctl = &adapter->dma_rx;
 544         struct scatterlist *sg = &ctl->sg;
 545         int err;
 546
 547         ctl->skb = netdev_alloc_skb(netdev, DMA_BUFFER_SIZE);
 548         if (ctl->skb) {
 549                 sg_init_table(sg, 1);
 550                 sg_dma_address(sg) = dma_map_single(adapter->dev,
 551                         ctl->skb->data, DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
 552                 if (dma_mapping_error(adapter->dev, sg_dma_address(sg))) {
 553                         err = -ENOMEM;
 554                         sg_dma_address(sg) = 0;
 555                         goto out;
 556                 }
 557
 558                 sg_dma_len(sg) = DMA_BUFFER_SIZE;
 559
 560                 ctl->adesc = dmaengine_prep_slave_sg(ctl->chan,
 561                         sg, 1, DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT);
 562
 563                 if (!ctl->adesc) {
 564                         err = -ENOMEM;
 565                         goto out;
 566                 }
 567
 568                 ctl->adesc->callback_param = netdev;
 569                 ctl->adesc->callback = ks8842_dma_rx_cb;
 570                 ctl->adesc->tx_submit(ctl->adesc);
 571         } else {
 572                 err = -ENOMEM;
 573                 sg_dma_address(sg) = 0;
 574                 goto out;
 575         }
 576
 577         return 0;
 578 out:
 579         if (sg_dma_address(sg))
 580                 dma_unmap_single(adapter->dev, sg_dma_address(sg),
 581                         DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
 582         sg_dma_address(sg) = 0;
 583         dev_kfree_skb(ctl->skb);
 584         ctl->skb = NULL;
 585
 586         printk(KERN_ERR DRV_NAME": Failed to start RX DMA: %d\n", err);
 587         return err;
 588 }
 589
 590 static void ks8842_rx_frame_dma_tasklet(unsigned long arg)
 591 {
 592         struct net_device *netdev = (struct net_device *)arg;
 593         struct ks8842_adapter *adapter = netdev_priv(netdev);
 594         struct ks8842_rx_dma_ctl *ctl = &adapter->dma_rx;
 595         struct sk_buff *skb = ctl->skb;
 596         dma_addr_t addr = sg_dma_address(&ctl->sg);
 597         u32 status;
 598
 599         ctl->adesc = NULL;
 600
 601         /* kick next transfer going */
 602         __ks8842_start_new_rx_dma(netdev);
 603
 604         /* now handle the data we got */
 605         dma_unmap_single(adapter->dev, addr, DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
 606
 607         status = *((u32 *)skb->data);
 608
 609         netdev_dbg(netdev, "%s - rx_data: status: %x\n",
 610                 __func__, status & 0xffff);
 611
 612         /* check the status */
 613         if ((status & RXSR_VALID) && !(status & RXSR_ERROR)) {
 614                 int len = (status >> 16) & 0x7ff;
 615
 616                 ks8842_update_rx_counters(netdev, status, len);
 617
 618                 /* reserve 4 bytes which is the status word */
 619                 skb_reserve(skb, 4);
 620                 skb_put(skb, len);
 621
 622                 skb->protocol = eth_type_trans(skb, netdev);
 623                 netif_rx(skb);
 624         } else {
 625                 ks8842_update_rx_err_counters(netdev, status);
 626                 dev_kfree_skb(skb);
 627         }
 628 }
 629
 630 static void ks8842_rx_frame(struct net_device *netdev,
 631         struct ks8842_adapter *adapter)
 632 {
 633         u32 status;
 634         int len;
 635
 636         if (adapter->conf_flags & KS884X_16BIT) {
 637                 status = ks8842_read16(adapter, 17, REG_QMU_DATA_LO);
 638                 len = ks8842_read16(adapter, 17, REG_QMU_DATA_HI);
 639                 netdev_dbg(netdev, "%s - rx_data: status: %x\n",
 640                            __func__, status);
 641         } else {
 642                 status = ks8842_read32(adapter, 17, REG_QMU_DATA_LO);
 643                 len = (status >> 16) & 0x7ff;
 644                 status &= 0xffff;
 645                 netdev_dbg(netdev, "%s - rx_data: status: %x\n",
 646                            __func__, status);
 647         }
 648
 649         /* check the status */
 650         if ((status & RXSR_VALID) && !(status & RXSR_ERROR)) {
 651                 struct sk_buff *skb = netdev_alloc_skb_ip_align(netdev, len + 3);
 652
 653                 if (skb) {
 654
 655                         ks8842_update_rx_counters(netdev, status, len);
 656
 657                         if (adapter->conf_flags & KS884X_16BIT) {
 658                                 u16 *data16 = skb_put(skb, len);
 659                                 ks8842_select_bank(adapter, 17);
 660                                 while (len > 0) {
 661                                         *data16++ = ioread16(adapter->hw_addr +
 662                                                 REG_QMU_DATA_LO);
 663                                         *data16++ = ioread16(adapter->hw_addr +
 664                                                 REG_QMU_DATA_HI);
 665                                         len -= sizeof(u32);
 666                                 }
 667                         } else {
 668                                 u32 *data = skb_put(skb, len);
 669
 670                                 ks8842_select_bank(adapter, 17);
 671                                 while (len > 0) {
 672                                         *data++ = ioread32(adapter->hw_addr +
 673                                                 REG_QMU_DATA_LO);
 674                                         len -= sizeof(u32);
 675                                 }
 676                         }
 677                         skb->protocol = eth_type_trans(skb, netdev);
 678                         netif_rx(skb);
 679                 } else
 680                         netdev->stats.rx_dropped++;
 681         } else
 682                 ks8842_update_rx_err_counters(netdev, status);
 683
 684         /* set high watermark to 3K */
 685         ks8842_clear_bits(adapter, 0, 1 << 12, REG_QRFCR);
 686
 687         /* release the frame */
 688         ks8842_write16(adapter, 17, 0x01, REG_RXQCR);
 689
 690         /* set high watermark to 2K */
 691         ks8842_enable_bits(adapter, 0, 1 << 12, REG_QRFCR);
 692 }
 693
 694 static void ks8842_handle_rx(struct net_device *netdev,
 695         struct ks8842_adapter *adapter)
 696 {
 697         u16 rx_data = ks8842_read16(adapter, 16, REG_RXMIR) & 0x1fff;
 698         netdev_dbg(netdev, "%s Entry - rx_data: %d\n", __func__, rx_data);
 699         while (rx_data) {
 700                 ks8842_rx_frame(netdev, adapter);
 701                 rx_data = ks8842_read16(adapter, 16, REG_RXMIR) & 0x1fff;
 702         }
 703 }
 704
 705 static void ks8842_handle_tx(struct net_device *netdev,
 706         struct ks8842_adapter *adapter)
 707 {
 708         u16 sr = ks8842_read16(adapter, 16, REG_TXSR);
 709         netdev_dbg(netdev, "%s - entry, sr: %x\n", __func__, sr);
 710         netdev->stats.tx_packets++;
 711         if (netif_queue_stopped(netdev))
 712                 netif_wake_queue(netdev);
 713 }
 714
 715 static void ks8842_handle_rx_overrun(struct net_device *netdev,
 716         struct ks8842_adapter *adapter)
 717 {
 718         netdev_dbg(netdev, "%s: entry\n", __func__);
 719         netdev->stats.rx_errors++;
 720         netdev->stats.rx_fifo_errors++;
 721 }
 722
 723 static void ks8842_tasklet(unsigned long arg)
 724 {
 725         struct net_device *netdev = (struct net_device *)arg;
 726         struct ks8842_adapter *adapter = netdev_priv(netdev);
 727         u16 isr;
 728         unsigned long flags;
 729         u16 entry_bank;
 730
 731         /* read current bank to be able to set it back */
 732         spin_lock_irqsave(&adapter->lock, flags);
 733         entry_bank = ioread16(adapter->hw_addr + REG_SELECT_BANK);
 734         spin_unlock_irqrestore(&adapter->lock, flags);
 735
 736         isr = ks8842_read16(adapter, 18, REG_ISR);
 737         netdev_dbg(netdev, "%s - ISR: 0x%x\n", __func__, isr);
 738
 739         /* when running in DMA mode, do not ack RX interrupts, it is handled
 740            internally by timberdale, otherwise it's DMA FIFO:s would stop
 741         */
 742         if (KS8842_USE_DMA(adapter))
 743                 isr &= ~IRQ_RX;
 744
 745         /* Ack */
 746         ks8842_write16(adapter, 18, isr, REG_ISR);
 747
 748         if (!(adapter->conf_flags & MICREL_KS884X))
 749                 /* Ack in the timberdale IP as well */
 750                 iowrite32(0x1, adapter->hw_addr + REG_TIMB_IAR);
 751
 752         if (!netif_running(netdev))
 753                 return;
 754
 755         if (isr & IRQ_LINK_CHANGE)
 756                 ks8842_update_link_status(netdev, adapter);
 757
 758         /* should not get IRQ_RX when running DMA mode */
 759         if (isr & (IRQ_RX | IRQ_RX_ERROR) && !KS8842_USE_DMA(adapter))
 760                 ks8842_handle_rx(netdev, adapter);
 761
 762         /* should only happen when in PIO mode */
 763         if (isr & IRQ_TX)
 764                 ks8842_handle_tx(netdev, adapter);
 765
 766         if (isr & IRQ_RX_OVERRUN)
 767                 ks8842_handle_rx_overrun(netdev, adapter);
 768
 769         if (isr & IRQ_TX_STOPPED) {
 770                 ks8842_disable_tx(adapter);
 771                 ks8842_enable_tx(adapter);
 772         }
 773
 774         if (isr & IRQ_RX_STOPPED) {
 775                 ks8842_disable_rx(adapter);
 776                 ks8842_enable_rx(adapter);
 777         }
 778
 779         /* re-enable interrupts, put back the bank selection register */
 780         spin_lock_irqsave(&adapter->lock, flags);
 781         if (KS8842_USE_DMA(adapter))
 782                 ks8842_write16(adapter, 18, ENABLED_IRQS_DMA, REG_IER);
 783         else
 784                 ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
 785         iowrite16(entry_bank, adapter->hw_addr + REG_SELECT_BANK);
 786
 787         /* Make sure timberdale continues DMA operations, they are stopped while
 788            we are handling the ks8842 because we might change bank */
 789         if (KS8842_USE_DMA(adapter))
 790                 ks8842_resume_dma(adapter);
 791
 792         spin_unlock_irqrestore(&adapter->lock, flags);
 793 }
 794
 795 static irqreturn_t ks8842_irq(int irq, void *devid)
 796 {
 797         struct net_device *netdev = devid;
 798         struct ks8842_adapter *adapter = netdev_priv(netdev);
 799         u16 isr;
 800         u16 entry_bank = ioread16(adapter->hw_addr + REG_SELECT_BANK);
 801         irqreturn_t ret = IRQ_NONE;
 802
 803         isr = ks8842_read16(adapter, 18, REG_ISR);
 804         netdev_dbg(netdev, "%s - ISR: 0x%x\n", __func__, isr);
 805
 806         if (isr) {
 807                 if (KS8842_USE_DMA(adapter))
 808                         /* disable all but RX IRQ, since the FPGA relies on it*/
 809                         ks8842_write16(adapter, 18, IRQ_RX, REG_IER);
 810                 else
 811                         /* disable IRQ */
 812                         ks8842_write16(adapter, 18, 0x00, REG_IER);
 813
 814                 /* schedule tasklet */
 815                 tasklet_schedule(&adapter->tasklet);
 816
 817                 ret = IRQ_HANDLED;
 818         }
 819
 820         iowrite16(entry_bank, adapter->hw_addr + REG_SELECT_BANK);
 821
 822         /* After an interrupt, tell timberdale to continue DMA operations.
 823            DMA is disabled while we are handling the ks8842 because we might
 824            change bank */
 825         ks8842_resume_dma(adapter);
 826
 827         return ret;
 828 }
 829
 830 static void ks8842_dma_rx_cb(void *data)
 831 {
 832         struct net_device       *netdev = data;
 833         struct ks8842_adapter   *adapter = netdev_priv(netdev);
 834
 835         netdev_dbg(netdev, "RX DMA finished\n");
 836         /* schedule tasklet */
 837         if (adapter->dma_rx.adesc)
 838                 tasklet_schedule(&adapter->dma_rx.tasklet);
 839 }
 840
 841 static void ks8842_dma_tx_cb(void *data)
 842 {
 843         struct net_device               *netdev = data;
 844         struct ks8842_adapter           *adapter = netdev_priv(netdev);
 845         struct ks8842_tx_dma_ctl        *ctl = &adapter->dma_tx;
 846
 847         netdev_dbg(netdev, "TX DMA finished\n");
 848
 849         if (!ctl->adesc)
 850                 return;
 851
 852         netdev->stats.tx_packets++;
 853         ctl->adesc = NULL;
 854
 855         if (netif_queue_stopped(netdev))
 856                 netif_wake_queue(netdev);
 857 }
 858
 859 static void ks8842_stop_dma(struct ks8842_adapter *adapter)
 860 {
 861         struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
 862         struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
 863
 864         tx_ctl->adesc = NULL;
 865         if (tx_ctl->chan)
 866                 dmaengine_terminate_all(tx_ctl->chan);
 867
 868         rx_ctl->adesc = NULL;
 869         if (rx_ctl->chan)
 870                 dmaengine_terminate_all(rx_ctl->chan);
 871
 872         if (sg_dma_address(&rx_ctl->sg))
 873                 dma_unmap_single(adapter->dev, sg_dma_address(&rx_ctl->sg),
 874                         DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
 875         sg_dma_address(&rx_ctl->sg) = 0;
 876
 877         dev_kfree_skb(rx_ctl->skb);
 878         rx_ctl->skb = NULL;
 879 }
 880
 881 static void ks8842_dealloc_dma_bufs(struct ks8842_adapter *adapter)
 882 {
 883         struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
 884         struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
 885
 886         ks8842_stop_dma(adapter);
 887
 888         if (tx_ctl->chan)
 889                 dma_release_channel(tx_ctl->chan);
 890         tx_ctl->chan = NULL;
 891
 892         if (rx_ctl->chan)
 893                 dma_release_channel(rx_ctl->chan);
 894         rx_ctl->chan = NULL;
 895
 896         tasklet_kill(&rx_ctl->tasklet);
 897
 898         if (sg_dma_address(&tx_ctl->sg))
 899                 dma_unmap_single(adapter->dev, sg_dma_address(&tx_ctl->sg),
 900                         DMA_BUFFER_SIZE, DMA_TO_DEVICE);
 901         sg_dma_address(&tx_ctl->sg) = 0;
 902
 903         kfree(tx_ctl->buf);
 904         tx_ctl->buf = NULL;
 905 }
 906
 907 static bool ks8842_dma_filter_fn(struct dma_chan *chan, void *filter_param)
 908 {
 909         return chan->chan_id == (long)filter_param;
 910 }
 911
 912 static int ks8842_alloc_dma_bufs(struct net_device *netdev)
 913 {
 914         struct ks8842_adapter *adapter = netdev_priv(netdev);
 915         struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
 916         struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
 917         int err;
 918
 919         dma_cap_mask_t mask;
 920
 921         dma_cap_zero(mask);
 922         dma_cap_set(DMA_SLAVE, mask);
 923         dma_cap_set(DMA_PRIVATE, mask);
 924
 925         sg_init_table(&tx_ctl->sg, 1);
 926
 927         tx_ctl->chan = dma_request_channel(mask, ks8842_dma_filter_fn,
 928                                            (void *)(long)tx_ctl->channel);
 929         if (!tx_ctl->chan) {
 930                 err = -ENODEV;
 931                 goto err;
 932         }
 933
 934         /* allocate DMA buffer */
 935         tx_ctl->buf = kmalloc(DMA_BUFFER_SIZE, GFP_KERNEL);
 936         if (!tx_ctl->buf) {
 937                 err = -ENOMEM;
 938                 goto err;
 939         }
 940
 941         sg_dma_address(&tx_ctl->sg) = dma_map_single(adapter->dev,
 942                 tx_ctl->buf, DMA_BUFFER_SIZE, DMA_TO_DEVICE);
 943         if (dma_mapping_error(adapter->dev, sg_dma_address(&tx_ctl->sg))) {
 944                 err = -ENOMEM;
 945                 sg_dma_address(&tx_ctl->sg) = 0;
 946                 goto err;
 947         }
 948
 949         rx_ctl->chan = dma_request_channel(mask, ks8842_dma_filter_fn,
 950                                            (void *)(long)rx_ctl->channel);
 951         if (!rx_ctl->chan) {
 952                 err = -ENODEV;
 953                 goto err;
 954         }
 955
 956         tasklet_init(&rx_ctl->tasklet, ks8842_rx_frame_dma_tasklet,
 957                 (unsigned long)netdev);
 958
 959         return 0;
 960 err:
 961         ks8842_dealloc_dma_bufs(adapter);
 962         return err;
 963 }
 964
 965 /* Netdevice operations */
 966
 967 static int ks8842_open(struct net_device *netdev)
 968 {
 969         struct ks8842_adapter *adapter = netdev_priv(netdev);
 970         int err;
 971
 972         netdev_dbg(netdev, "%s - entry\n", __func__);
 973
 974         if (KS8842_USE_DMA(adapter)) {
 975                 err = ks8842_alloc_dma_bufs(netdev);
 976
 977                 if (!err) {
 978                         /* start RX dma */
 979                         err = __ks8842_start_new_rx_dma(netdev);
 980                         if (err)
 981                                 ks8842_dealloc_dma_bufs(adapter);
 982                 }
 983
 984                 if (err) {
 985                         printk(KERN_WARNING DRV_NAME
 986                                 ": Failed to initiate DMA, running PIO\n");
 987                         ks8842_dealloc_dma_bufs(adapter);
 988                         adapter->dma_rx.channel = -1;
 989                         adapter->dma_tx.channel = -1;
 990                 }
 991         }
 992
 993         /* reset the HW */
 994         ks8842_reset_hw(adapter);
 995
 996         ks8842_write_mac_addr(adapter, netdev->dev_addr);
 997
 998         ks8842_update_link_status(netdev, adapter);
 999
1000         err = request_irq(adapter->irq, ks8842_irq, IRQF_SHARED, DRV_NAME,
1001                 netdev);
1002         if (err) {
1003                 pr_err("Failed to request IRQ: %d: %d\n", adapter->irq, err);
1004                 return err;
1005         }
1006
1007         return 0;
1008 }
1009
1010 static int ks8842_close(struct net_device *netdev)
1011 {
1012         struct ks8842_adapter *adapter = netdev_priv(netdev);
1013
1014         netdev_dbg(netdev, "%s - entry\n", __func__);
1015
1016         cancel_work_sync(&adapter->timeout_work);
1017
1018         if (KS8842_USE_DMA(adapter))
1019                 ks8842_dealloc_dma_bufs(adapter);
1020
1021         /* free the irq */
1022         free_irq(adapter->irq, netdev);
1023
1024         /* disable the switch */
1025         ks8842_write16(adapter, 32, 0x0, REG_SW_ID_AND_ENABLE);
1026
1027         return 0;
1028 }
1029
1030 static netdev_tx_t ks8842_xmit_frame(struct sk_buff *skb,
1031                                      struct net_device *netdev)
1032 {
1033         int ret;
1034         struct ks8842_adapter *adapter = netdev_priv(netdev);
1035
1036         netdev_dbg(netdev, "%s: entry\n", __func__);
1037
1038         if (KS8842_USE_DMA(adapter)) {
1039                 unsigned long flags;
1040                 ret = ks8842_tx_frame_dma(skb, netdev);
1041                 /* for now only allow one transfer at the time */
1042                 spin_lock_irqsave(&adapter->lock, flags);
1043                 if (adapter->dma_tx.adesc)
1044                         netif_stop_queue(netdev);
1045                 spin_unlock_irqrestore(&adapter->lock, flags);
1046                 return ret;
1047         }
1048
1049         ret = ks8842_tx_frame(skb, netdev);
1050
1051         if (ks8842_tx_fifo_space(adapter) <  netdev->mtu + 8)
1052                 netif_stop_queue(netdev);
1053
1054         return ret;
1055 }
1056
1057 static int ks8842_set_mac(struct net_device *netdev, void *p)
1058 {
1059         struct ks8842_adapter *adapter = netdev_priv(netdev);
1060         struct sockaddr *addr = p;
1061         char *mac = (u8 *)addr->sa_data;
1062
1063         netdev_dbg(netdev, "%s: entry\n", __func__);
1064
1065         if (!is_valid_ether_addr(addr->sa_data))
1066                 return -EADDRNOTAVAIL;
1067
1068         memcpy(netdev->dev_addr, mac, netdev->addr_len);
1069
1070         ks8842_write_mac_addr(adapter, mac);
1071         return 0;
1072 }
1073
1074 static void ks8842_tx_timeout_work(struct work_struct *work)
1075 {
1076         struct ks8842_adapter *adapter =
1077                 container_of(work, struct ks8842_adapter, timeout_work);
1078         struct net_device *netdev = adapter->netdev;
1079         unsigned long flags;
1080
1081         netdev_dbg(netdev, "%s: entry\n", __func__);
1082
1083         spin_lock_irqsave(&adapter->lock, flags);
1084
1085         if (KS8842_USE_DMA(adapter))
1086                 ks8842_stop_dma(adapter);
1087
1088         /* disable interrupts */
1089         ks8842_write16(adapter, 18, 0, REG_IER);
1090         ks8842_write16(adapter, 18, 0xFFFF, REG_ISR);
1091
1092         netif_stop_queue(netdev);
1093
1094         spin_unlock_irqrestore(&adapter->lock, flags);
1095
1096         ks8842_reset_hw(adapter);
1097
1098         ks8842_write_mac_addr(adapter, netdev->dev_addr);
1099
1100         ks8842_update_link_status(netdev, adapter);
1101
1102         if (KS8842_USE_DMA(adapter))
1103                 __ks8842_start_new_rx_dma(netdev);
1104 }
1105
1106 static void ks8842_tx_timeout(struct net_device *netdev, unsigned int txqueue)
1107 {
1108         struct ks8842_adapter *adapter = netdev_priv(netdev);
1109
1110         netdev_dbg(netdev, "%s: entry\n", __func__);
1111
1112         schedule_work(&adapter->timeout_work);
1113 }
1114
1115 static const struct net_device_ops ks8842_netdev_ops = {
1116         .ndo_open               = ks8842_open,
1117         .ndo_stop               = ks8842_close,
1118         .ndo_start_xmit         = ks8842_xmit_frame,
1119         .ndo_set_mac_address    = ks8842_set_mac,
1120         .ndo_tx_timeout         = ks8842_tx_timeout,
1121         .ndo_validate_addr      = eth_validate_addr
1122 };
1123
1124 static const struct ethtool_ops ks8842_ethtool_ops = {
1125         .get_link               = ethtool_op_get_link,
1126 };
1127
1128 static int ks8842_probe(struct platform_device *pdev)
1129 {
1130         int err = -ENOMEM;
1131         struct resource *iomem;
1132         struct net_device *netdev;
1133         struct ks8842_adapter *adapter;
1134         struct ks8842_platform_data *pdata = dev_get_platdata(&pdev->dev);
1135         u16 id;
1136         unsigned i;
1137
1138         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1139         if (!request_mem_region(iomem->start, resource_size(iomem), DRV_NAME))
1140                 goto err_mem_region;
1141
1142         netdev = alloc_etherdev(sizeof(struct ks8842_adapter));
1143         if (!netdev)
1144                 goto err_alloc_etherdev;
1145
1146         SET_NETDEV_DEV(netdev, &pdev->dev);
1147
1148         adapter = netdev_priv(netdev);
1149         adapter->netdev = netdev;
1150         INIT_WORK(&adapter->timeout_work, ks8842_tx_timeout_work);
1151         adapter->hw_addr = ioremap(iomem->start, resource_size(iomem));
1152         adapter->conf_flags = iomem->flags;
1153
1154         if (!adapter->hw_addr)
1155                 goto err_ioremap;
1156
1157         adapter->irq = platform_get_irq(pdev, 0);
1158         if (adapter->irq < 0) {
1159                 err = adapter->irq;
1160                 goto err_get_irq;
1161         }
1162
1163         adapter->dev = (pdev->dev.parent) ? pdev->dev.parent : &pdev->dev;
1164
1165         /* DMA is only supported when accessed via timberdale */
1166         if (!(adapter->conf_flags & MICREL_KS884X) && pdata &&
1167                 (pdata->tx_dma_channel != -1) &&
1168                 (pdata->rx_dma_channel != -1)) {
1169                 adapter->dma_rx.channel = pdata->rx_dma_channel;
1170                 adapter->dma_tx.channel = pdata->tx_dma_channel;
1171         } else {
1172                 adapter->dma_rx.channel = -1;
1173                 adapter->dma_tx.channel = -1;
1174         }
1175
1176         tasklet_init(&adapter->tasklet, ks8842_tasklet, (unsigned long)netdev);
1177         spin_lock_init(&adapter->lock);
1178
1179         netdev->netdev_ops = &ks8842_netdev_ops;
1180         netdev->ethtool_ops = &ks8842_ethtool_ops;
1181
1182         /* Check if a mac address was given */
1183         i = netdev->addr_len;
1184         if (pdata) {
1185                 for (i = 0; i < netdev->addr_len; i++)
1186                         if (pdata->macaddr[i] != 0)
1187                                 break;
1188
1189                 if (i < netdev->addr_len)
1190                         /* an address was passed, use it */
1191                         memcpy(netdev->dev_addr, pdata->macaddr,
1192                                 netdev->addr_len);
1193         }
1194
1195         if (i == netdev->addr_len) {
1196                 ks8842_read_mac_addr(adapter, netdev->dev_addr);
1197
1198                 if (!is_valid_ether_addr(netdev->dev_addr))
1199                         eth_hw_addr_random(netdev);
1200         }
1201
1202         id = ks8842_read16(adapter, 32, REG_SW_ID_AND_ENABLE);
1203
1204         strcpy(netdev->name, "eth%d");
1205         err = register_netdev(netdev);
1206         if (err)
1207                 goto err_register;
1208
1209         platform_set_drvdata(pdev, netdev);
1210
1211         pr_info("Found chip, family: 0x%x, id: 0x%x, rev: 0x%x\n",
1212                 (id >> 8) & 0xff, (id >> 4) & 0xf, (id >> 1) & 0x7);
1213
1214         return 0;
1215
1216 err_register:
1217 err_get_irq:
1218         iounmap(adapter->hw_addr);
1219 err_ioremap:
1220         free_netdev(netdev);
1221 err_alloc_etherdev:
1222         release_mem_region(iomem->start, resource_size(iomem));
1223 err_mem_region:
1224         return err;
1225 }
1226
1227 static int ks8842_remove(struct platform_device *pdev)
1228 {
1229         struct net_device *netdev = platform_get_drvdata(pdev);
1230         struct ks8842_adapter *adapter = netdev_priv(netdev);
1231         struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1232
1233         unregister_netdev(netdev);
1234         tasklet_kill(&adapter->tasklet);
1235         iounmap(adapter->hw_addr);
1236         free_netdev(netdev);
1237         release_mem_region(iomem->start, resource_size(iomem));
1238         return 0;
1239 }
1240
1241
1242 static struct platform_driver ks8842_platform_driver = {
1243         .driver = {
1244                 .name   = DRV_NAME,
1245         },
1246         .probe          = ks8842_probe,
1247         .remove         = ks8842_remove,
1248 };
1249
1250 module_platform_driver(ks8842_platform_driver);
1251
1252 MODULE_DESCRIPTION("Timberdale KS8842 ethernet driver");
1253 MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
1254 MODULE_LICENSE("GPL v2");
1255 MODULE_ALIAS("platform:ks8842");
1256