drivers/net/ethernet/micrel/ks8842.c

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