drivers/net/ethernet/micrel/ks8842.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
ks8842_resume_dma
ks8842_select_bank
ks8842_write8
ks8842_write16
ks8842_enable_bits
ks8842_clear_bits
ks8842_write32
ks8842_read8
ks8842_read16
ks8842_read32
ks8842_reset
ks8842_update_link_status
ks8842_enable_tx
ks8842_disable_tx
ks8842_enable_rx
ks8842_disable_rx
ks8842_reset_hw
ks8842_read_mac_addr
ks8842_write_mac_addr
ks8842_tx_fifo_space
ks8842_tx_frame_dma
ks8842_tx_frame
ks8842_update_rx_err_counters
ks8842_update_rx_counters
__ks8842_start_new_rx_dma
ks8842_rx_frame_dma_tasklet
ks8842_rx_frame
ks8842_handle_rx
ks8842_handle_tx
ks8842_handle_rx_overrun
ks8842_tasklet
ks8842_irq
ks8842_dma_rx_cb
ks8842_dma_tx_cb
ks8842_stop_dma
ks8842_dealloc_dma_bufs
ks8842_dma_filter_fn
ks8842_alloc_dma_bufs
ks8842_open
ks8842_close
ks8842_xmit_frame
ks8842_set_mac
ks8842_tx_timeout_work
ks8842_tx_timeout
ks8842_probe
ks8842_remove
   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)
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
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/net/ethernet/micrel/ks8842.c

DEFINITIONS
