Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * ks8842.c timberdale KS8842 ethernet driver
0004  * Copyright (c) 2009 Intel Corporation
0005  */
0006 
0007 /* Supports:
0008  * The Micrel KS8842 behind the timberdale FPGA
0009  * The genuine Micrel KS8841/42 device with ISA 16/32bit bus interface
0010  */
0011 
0012 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0013 
0014 #include <linux/interrupt.h>
0015 #include <linux/kernel.h>
0016 #include <linux/module.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/netdevice.h>
0019 #include <linux/etherdevice.h>
0020 #include <linux/ethtool.h>
0021 #include <linux/ks8842.h>
0022 #include <linux/dmaengine.h>
0023 #include <linux/dma-mapping.h>
0024 #include <linux/scatterlist.h>
0025 
0026 #define DRV_NAME "ks8842"
0027 
0028 /* Timberdale specific Registers */
0029 #define REG_TIMB_RST        0x1c
0030 #define REG_TIMB_FIFO       0x20
0031 #define REG_TIMB_ISR        0x24
0032 #define REG_TIMB_IER        0x28
0033 #define REG_TIMB_IAR        0x2C
0034 #define REQ_TIMB_DMA_RESUME 0x30
0035 
0036 /* KS8842 registers */
0037 
0038 #define REG_SELECT_BANK 0x0e
0039 
0040 /* bank 0 registers */
0041 #define REG_QRFCR   0x04
0042 
0043 /* bank 2 registers */
0044 #define REG_MARL    0x00
0045 #define REG_MARM    0x02
0046 #define REG_MARH    0x04
0047 
0048 /* bank 3 registers */
0049 #define REG_GRR     0x06
0050 
0051 /* bank 16 registers */
0052 #define REG_TXCR    0x00
0053 #define REG_TXSR    0x02
0054 #define REG_RXCR    0x04
0055 #define REG_TXMIR   0x08
0056 #define REG_RXMIR   0x0A
0057 
0058 /* bank 17 registers */
0059 #define REG_TXQCR   0x00
0060 #define REG_RXQCR   0x02
0061 #define REG_TXFDPR  0x04
0062 #define REG_RXFDPR  0x06
0063 #define REG_QMU_DATA_LO 0x08
0064 #define REG_QMU_DATA_HI 0x0A
0065 
0066 /* bank 18 registers */
0067 #define REG_IER     0x00
0068 #define IRQ_LINK_CHANGE 0x8000
0069 #define IRQ_TX      0x4000
0070 #define IRQ_RX      0x2000
0071 #define IRQ_RX_OVERRUN  0x0800
0072 #define IRQ_TX_STOPPED  0x0200
0073 #define IRQ_RX_STOPPED  0x0100
0074 #define IRQ_RX_ERROR    0x0080
0075 #define ENABLED_IRQS    (IRQ_LINK_CHANGE | IRQ_TX | IRQ_RX | IRQ_RX_STOPPED | \
0076         IRQ_TX_STOPPED | IRQ_RX_OVERRUN | IRQ_RX_ERROR)
0077 /* When running via timberdale in DMA mode, the RX interrupt should be
0078    enabled in the KS8842, but not in the FPGA IP, since the IP handles
0079    RX DMA internally.
0080    TX interrupts are not needed it is handled by the FPGA the driver is
0081    notified via DMA callbacks.
0082 */
0083 #define ENABLED_IRQS_DMA_IP (IRQ_LINK_CHANGE | IRQ_RX_STOPPED | \
0084     IRQ_TX_STOPPED | IRQ_RX_OVERRUN | IRQ_RX_ERROR)
0085 #define ENABLED_IRQS_DMA    (ENABLED_IRQS_DMA_IP | IRQ_RX)
0086 #define REG_ISR     0x02
0087 #define REG_RXSR    0x04
0088 #define RXSR_VALID  0x8000
0089 #define RXSR_BROADCAST  0x80
0090 #define RXSR_MULTICAST  0x40
0091 #define RXSR_UNICAST    0x20
0092 #define RXSR_FRAMETYPE  0x08
0093 #define RXSR_TOO_LONG   0x04
0094 #define RXSR_RUNT   0x02
0095 #define RXSR_CRC_ERROR  0x01
0096 #define RXSR_ERROR  (RXSR_TOO_LONG | RXSR_RUNT | RXSR_CRC_ERROR)
0097 
0098 /* bank 32 registers */
0099 #define REG_SW_ID_AND_ENABLE    0x00
0100 #define REG_SGCR1       0x02
0101 #define REG_SGCR2       0x04
0102 #define REG_SGCR3       0x06
0103 
0104 /* bank 39 registers */
0105 #define REG_MACAR1      0x00
0106 #define REG_MACAR2      0x02
0107 #define REG_MACAR3      0x04
0108 
0109 /* bank 45 registers */
0110 #define REG_P1MBCR      0x00
0111 #define REG_P1MBSR      0x02
0112 
0113 /* bank 46 registers */
0114 #define REG_P2MBCR      0x00
0115 #define REG_P2MBSR      0x02
0116 
0117 /* bank 48 registers */
0118 #define REG_P1CR2       0x02
0119 
0120 /* bank 49 registers */
0121 #define REG_P1CR4       0x02
0122 #define REG_P1SR        0x04
0123 
0124 /* flags passed by platform_device for configuration */
0125 #define MICREL_KS884X       0x01    /* 0=Timeberdale(FPGA), 1=Micrel */
0126 #define KS884X_16BIT        0x02    /*  1=16bit, 0=32bit */
0127 
0128 #define DMA_BUFFER_SIZE     2048
0129 
0130 struct ks8842_tx_dma_ctl {
0131     struct dma_chan *chan;
0132     struct dma_async_tx_descriptor *adesc;
0133     void *buf;
0134     struct scatterlist sg;
0135     int channel;
0136 };
0137 
0138 struct ks8842_rx_dma_ctl {
0139     struct dma_chan *chan;
0140     struct dma_async_tx_descriptor *adesc;
0141     struct sk_buff  *skb;
0142     struct scatterlist sg;
0143     struct tasklet_struct tasklet;
0144     int channel;
0145 };
0146 
0147 #define KS8842_USE_DMA(adapter) (((adapter)->dma_tx.channel != -1) && \
0148      ((adapter)->dma_rx.channel != -1))
0149 
0150 struct ks8842_adapter {
0151     void __iomem    *hw_addr;
0152     int     irq;
0153     unsigned long   conf_flags; /* copy of platform_device config */
0154     struct tasklet_struct   tasklet;
0155     spinlock_t  lock; /* spinlock to be interrupt safe */
0156     struct work_struct timeout_work;
0157     struct net_device *netdev;
0158     struct device *dev;
0159     struct ks8842_tx_dma_ctl    dma_tx;
0160     struct ks8842_rx_dma_ctl    dma_rx;
0161 };
0162 
0163 static void ks8842_dma_rx_cb(void *data);
0164 static void ks8842_dma_tx_cb(void *data);
0165 
0166 static inline void ks8842_resume_dma(struct ks8842_adapter *adapter)
0167 {
0168     iowrite32(1, adapter->hw_addr + REQ_TIMB_DMA_RESUME);
0169 }
0170 
0171 static inline void ks8842_select_bank(struct ks8842_adapter *adapter, u16 bank)
0172 {
0173     iowrite16(bank, adapter->hw_addr + REG_SELECT_BANK);
0174 }
0175 
0176 static inline void ks8842_write8(struct ks8842_adapter *adapter, u16 bank,
0177     u8 value, int offset)
0178 {
0179     ks8842_select_bank(adapter, bank);
0180     iowrite8(value, adapter->hw_addr + offset);
0181 }
0182 
0183 static inline void ks8842_write16(struct ks8842_adapter *adapter, u16 bank,
0184     u16 value, int offset)
0185 {
0186     ks8842_select_bank(adapter, bank);
0187     iowrite16(value, adapter->hw_addr + offset);
0188 }
0189 
0190 static inline void ks8842_enable_bits(struct ks8842_adapter *adapter, u16 bank,
0191     u16 bits, int offset)
0192 {
0193     u16 reg;
0194     ks8842_select_bank(adapter, bank);
0195     reg = ioread16(adapter->hw_addr + offset);
0196     reg |= bits;
0197     iowrite16(reg, adapter->hw_addr + offset);
0198 }
0199 
0200 static inline void ks8842_clear_bits(struct ks8842_adapter *adapter, u16 bank,
0201     u16 bits, int offset)
0202 {
0203     u16 reg;
0204     ks8842_select_bank(adapter, bank);
0205     reg = ioread16(adapter->hw_addr + offset);
0206     reg &= ~bits;
0207     iowrite16(reg, adapter->hw_addr + offset);
0208 }
0209 
0210 static inline void ks8842_write32(struct ks8842_adapter *adapter, u16 bank,
0211     u32 value, int offset)
0212 {
0213     ks8842_select_bank(adapter, bank);
0214     iowrite32(value, adapter->hw_addr + offset);
0215 }
0216 
0217 static inline u8 ks8842_read8(struct ks8842_adapter *adapter, u16 bank,
0218     int offset)
0219 {
0220     ks8842_select_bank(adapter, bank);
0221     return ioread8(adapter->hw_addr + offset);
0222 }
0223 
0224 static inline u16 ks8842_read16(struct ks8842_adapter *adapter, u16 bank,
0225     int offset)
0226 {
0227     ks8842_select_bank(adapter, bank);
0228     return ioread16(adapter->hw_addr + offset);
0229 }
0230 
0231 static inline u32 ks8842_read32(struct ks8842_adapter *adapter, u16 bank,
0232     int offset)
0233 {
0234     ks8842_select_bank(adapter, bank);
0235     return ioread32(adapter->hw_addr + offset);
0236 }
0237 
0238 static void ks8842_reset(struct ks8842_adapter *adapter)
0239 {
0240     if (adapter->conf_flags & MICREL_KS884X) {
0241         ks8842_write16(adapter, 3, 1, REG_GRR);
0242         msleep(10);
0243         iowrite16(0, adapter->hw_addr + REG_GRR);
0244     } else {
0245         /* The KS8842 goes haywire when doing softare reset
0246         * a work around in the timberdale IP is implemented to
0247         * do a hardware reset instead
0248         ks8842_write16(adapter, 3, 1, REG_GRR);
0249         msleep(10);
0250         iowrite16(0, adapter->hw_addr + REG_GRR);
0251         */
0252         iowrite32(0x1, adapter->hw_addr + REG_TIMB_RST);
0253         msleep(20);
0254     }
0255 }
0256 
0257 static void ks8842_update_link_status(struct net_device *netdev,
0258     struct ks8842_adapter *adapter)
0259 {
0260     /* check the status of the link */
0261     if (ks8842_read16(adapter, 45, REG_P1MBSR) & 0x4) {
0262         netif_carrier_on(netdev);
0263         netif_wake_queue(netdev);
0264     } else {
0265         netif_stop_queue(netdev);
0266         netif_carrier_off(netdev);
0267     }
0268 }
0269 
0270 static void ks8842_enable_tx(struct ks8842_adapter *adapter)
0271 {
0272     ks8842_enable_bits(adapter, 16, 0x01, REG_TXCR);
0273 }
0274 
0275 static void ks8842_disable_tx(struct ks8842_adapter *adapter)
0276 {
0277     ks8842_clear_bits(adapter, 16, 0x01, REG_TXCR);
0278 }
0279 
0280 static void ks8842_enable_rx(struct ks8842_adapter *adapter)
0281 {
0282     ks8842_enable_bits(adapter, 16, 0x01, REG_RXCR);
0283 }
0284 
0285 static void ks8842_disable_rx(struct ks8842_adapter *adapter)
0286 {
0287     ks8842_clear_bits(adapter, 16, 0x01, REG_RXCR);
0288 }
0289 
0290 static void ks8842_reset_hw(struct ks8842_adapter *adapter)
0291 {
0292     /* reset the HW */
0293     ks8842_reset(adapter);
0294 
0295     /* Enable QMU Transmit flow control / transmit padding / Transmit CRC */
0296     ks8842_write16(adapter, 16, 0x000E, REG_TXCR);
0297 
0298     /* enable the receiver, uni + multi + broadcast + flow ctrl
0299         + crc strip */
0300     ks8842_write16(adapter, 16, 0x8 | 0x20 | 0x40 | 0x80 | 0x400,
0301         REG_RXCR);
0302 
0303     /* TX frame pointer autoincrement */
0304     ks8842_write16(adapter, 17, 0x4000, REG_TXFDPR);
0305 
0306     /* RX frame pointer autoincrement */
0307     ks8842_write16(adapter, 17, 0x4000, REG_RXFDPR);
0308 
0309     /* RX 2 kb high watermark */
0310     ks8842_write16(adapter, 0, 0x1000, REG_QRFCR);
0311 
0312     /* aggressive back off in half duplex */
0313     ks8842_enable_bits(adapter, 32, 1 << 8, REG_SGCR1);
0314 
0315     /* enable no excessive collison drop */
0316     ks8842_enable_bits(adapter, 32, 1 << 3, REG_SGCR2);
0317 
0318     /* Enable port 1 force flow control / back pressure / transmit / recv */
0319     ks8842_write16(adapter, 48, 0x1E07, REG_P1CR2);
0320 
0321     /* restart port auto-negotiation */
0322     ks8842_enable_bits(adapter, 49, 1 << 13, REG_P1CR4);
0323 
0324     /* Enable the transmitter */
0325     ks8842_enable_tx(adapter);
0326 
0327     /* Enable the receiver */
0328     ks8842_enable_rx(adapter);
0329 
0330     /* clear all interrupts */
0331     ks8842_write16(adapter, 18, 0xffff, REG_ISR);
0332 
0333     /* enable interrupts */
0334     if (KS8842_USE_DMA(adapter)) {
0335         /* When running in DMA Mode the RX interrupt is not enabled in
0336            timberdale because RX data is received by DMA callbacks
0337            it must still be enabled in the KS8842 because it indicates
0338            to timberdale when there is RX data for it's DMA FIFOs */
0339         iowrite16(ENABLED_IRQS_DMA_IP, adapter->hw_addr + REG_TIMB_IER);
0340         ks8842_write16(adapter, 18, ENABLED_IRQS_DMA, REG_IER);
0341     } else {
0342         if (!(adapter->conf_flags & MICREL_KS884X))
0343             iowrite16(ENABLED_IRQS,
0344                 adapter->hw_addr + REG_TIMB_IER);
0345         ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
0346     }
0347     /* enable the switch */
0348     ks8842_write16(adapter, 32, 0x1, REG_SW_ID_AND_ENABLE);
0349 }
0350 
0351 static void ks8842_init_mac_addr(struct ks8842_adapter *adapter)
0352 {
0353     u8 addr[ETH_ALEN];
0354     int i;
0355     u16 mac;
0356 
0357     for (i = 0; i < ETH_ALEN; i++)
0358         addr[ETH_ALEN - i - 1] = ks8842_read8(adapter, 2, REG_MARL + i);
0359     eth_hw_addr_set(adapter->netdev, addr);
0360 
0361     if (adapter->conf_flags & MICREL_KS884X) {
0362         /*
0363         the sequence of saving mac addr between MAC and Switch is
0364         different.
0365         */
0366 
0367         mac = ks8842_read16(adapter, 2, REG_MARL);
0368         ks8842_write16(adapter, 39, mac, REG_MACAR3);
0369         mac = ks8842_read16(adapter, 2, REG_MARM);
0370         ks8842_write16(adapter, 39, mac, REG_MACAR2);
0371         mac = ks8842_read16(adapter, 2, REG_MARH);
0372         ks8842_write16(adapter, 39, mac, REG_MACAR1);
0373     } else {
0374 
0375         /* make sure the switch port uses the same MAC as the QMU */
0376         mac = ks8842_read16(adapter, 2, REG_MARL);
0377         ks8842_write16(adapter, 39, mac, REG_MACAR1);
0378         mac = ks8842_read16(adapter, 2, REG_MARM);
0379         ks8842_write16(adapter, 39, mac, REG_MACAR2);
0380         mac = ks8842_read16(adapter, 2, REG_MARH);
0381         ks8842_write16(adapter, 39, mac, REG_MACAR3);
0382     }
0383 }
0384 
0385 static void ks8842_write_mac_addr(struct ks8842_adapter *adapter, const u8 *mac)
0386 {
0387     unsigned long flags;
0388     unsigned i;
0389 
0390     spin_lock_irqsave(&adapter->lock, flags);
0391     for (i = 0; i < ETH_ALEN; i++) {
0392         ks8842_write8(adapter, 2, mac[ETH_ALEN - i - 1], REG_MARL + i);
0393         if (!(adapter->conf_flags & MICREL_KS884X))
0394             ks8842_write8(adapter, 39, mac[ETH_ALEN - i - 1],
0395                 REG_MACAR1 + i);
0396     }
0397 
0398     if (adapter->conf_flags & MICREL_KS884X) {
0399         /*
0400         the sequence of saving mac addr between MAC and Switch is
0401         different.
0402         */
0403 
0404         u16 mac;
0405 
0406         mac = ks8842_read16(adapter, 2, REG_MARL);
0407         ks8842_write16(adapter, 39, mac, REG_MACAR3);
0408         mac = ks8842_read16(adapter, 2, REG_MARM);
0409         ks8842_write16(adapter, 39, mac, REG_MACAR2);
0410         mac = ks8842_read16(adapter, 2, REG_MARH);
0411         ks8842_write16(adapter, 39, mac, REG_MACAR1);
0412     }
0413     spin_unlock_irqrestore(&adapter->lock, flags);
0414 }
0415 
0416 static inline u16 ks8842_tx_fifo_space(struct ks8842_adapter *adapter)
0417 {
0418     return ks8842_read16(adapter, 16, REG_TXMIR) & 0x1fff;
0419 }
0420 
0421 static int ks8842_tx_frame_dma(struct sk_buff *skb, struct net_device *netdev)
0422 {
0423     struct ks8842_adapter *adapter = netdev_priv(netdev);
0424     struct ks8842_tx_dma_ctl *ctl = &adapter->dma_tx;
0425     u8 *buf = ctl->buf;
0426 
0427     if (ctl->adesc) {
0428         netdev_dbg(netdev, "%s: TX ongoing\n", __func__);
0429         /* transfer ongoing */
0430         return NETDEV_TX_BUSY;
0431     }
0432 
0433     sg_dma_len(&ctl->sg) = skb->len + sizeof(u32);
0434 
0435     /* copy data to the TX buffer */
0436     /* the control word, enable IRQ, port 1 and the length */
0437     *buf++ = 0x00;
0438     *buf++ = 0x01; /* Port 1 */
0439     *buf++ = skb->len & 0xff;
0440     *buf++ = (skb->len >> 8) & 0xff;
0441     skb_copy_from_linear_data(skb, buf, skb->len);
0442 
0443     dma_sync_single_range_for_device(adapter->dev,
0444         sg_dma_address(&ctl->sg), 0, sg_dma_len(&ctl->sg),
0445         DMA_TO_DEVICE);
0446 
0447     /* make sure the length is a multiple of 4 */
0448     if (sg_dma_len(&ctl->sg) % 4)
0449         sg_dma_len(&ctl->sg) += 4 - sg_dma_len(&ctl->sg) % 4;
0450 
0451     ctl->adesc = dmaengine_prep_slave_sg(ctl->chan,
0452         &ctl->sg, 1, DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT);
0453     if (!ctl->adesc)
0454         return NETDEV_TX_BUSY;
0455 
0456     ctl->adesc->callback_param = netdev;
0457     ctl->adesc->callback = ks8842_dma_tx_cb;
0458     ctl->adesc->tx_submit(ctl->adesc);
0459 
0460     netdev->stats.tx_bytes += skb->len;
0461 
0462     dev_kfree_skb(skb);
0463 
0464     return NETDEV_TX_OK;
0465 }
0466 
0467 static int ks8842_tx_frame(struct sk_buff *skb, struct net_device *netdev)
0468 {
0469     struct ks8842_adapter *adapter = netdev_priv(netdev);
0470     int len = skb->len;
0471 
0472     netdev_dbg(netdev, "%s: len %u head %p data %p tail %p end %p\n",
0473         __func__, skb->len, skb->head, skb->data,
0474         skb_tail_pointer(skb), skb_end_pointer(skb));
0475 
0476     /* check FIFO buffer space, we need space for CRC and command bits */
0477     if (ks8842_tx_fifo_space(adapter) < len + 8)
0478         return NETDEV_TX_BUSY;
0479 
0480     if (adapter->conf_flags & KS884X_16BIT) {
0481         u16 *ptr16 = (u16 *)skb->data;
0482         ks8842_write16(adapter, 17, 0x8000 | 0x100, REG_QMU_DATA_LO);
0483         ks8842_write16(adapter, 17, (u16)len, REG_QMU_DATA_HI);
0484         netdev->stats.tx_bytes += len;
0485 
0486         /* copy buffer */
0487         while (len > 0) {
0488             iowrite16(*ptr16++, adapter->hw_addr + REG_QMU_DATA_LO);
0489             iowrite16(*ptr16++, adapter->hw_addr + REG_QMU_DATA_HI);
0490             len -= sizeof(u32);
0491         }
0492     } else {
0493 
0494         u32 *ptr = (u32 *)skb->data;
0495         u32 ctrl;
0496         /* the control word, enable IRQ, port 1 and the length */
0497         ctrl = 0x8000 | 0x100 | (len << 16);
0498         ks8842_write32(adapter, 17, ctrl, REG_QMU_DATA_LO);
0499 
0500         netdev->stats.tx_bytes += len;
0501 
0502         /* copy buffer */
0503         while (len > 0) {
0504             iowrite32(*ptr, adapter->hw_addr + REG_QMU_DATA_LO);
0505             len -= sizeof(u32);
0506             ptr++;
0507         }
0508     }
0509 
0510     /* enqueue packet */
0511     ks8842_write16(adapter, 17, 1, REG_TXQCR);
0512 
0513     dev_kfree_skb(skb);
0514 
0515     return NETDEV_TX_OK;
0516 }
0517 
0518 static void ks8842_update_rx_err_counters(struct net_device *netdev, u32 status)
0519 {
0520     netdev_dbg(netdev, "RX error, status: %x\n", status);
0521 
0522     netdev->stats.rx_errors++;
0523     if (status & RXSR_TOO_LONG)
0524         netdev->stats.rx_length_errors++;
0525     if (status & RXSR_CRC_ERROR)
0526         netdev->stats.rx_crc_errors++;
0527     if (status & RXSR_RUNT)
0528         netdev->stats.rx_frame_errors++;
0529 }
0530 
0531 static void ks8842_update_rx_counters(struct net_device *netdev, u32 status,
0532     int len)
0533 {
0534     netdev_dbg(netdev, "RX packet, len: %d\n", len);
0535 
0536     netdev->stats.rx_packets++;
0537     netdev->stats.rx_bytes += len;
0538     if (status & RXSR_MULTICAST)
0539         netdev->stats.multicast++;
0540 }
0541 
0542 static int __ks8842_start_new_rx_dma(struct net_device *netdev)
0543 {
0544     struct ks8842_adapter *adapter = netdev_priv(netdev);
0545     struct ks8842_rx_dma_ctl *ctl = &adapter->dma_rx;
0546     struct scatterlist *sg = &ctl->sg;
0547     int err;
0548 
0549     ctl->skb = netdev_alloc_skb(netdev, DMA_BUFFER_SIZE);
0550     if (ctl->skb) {
0551         sg_init_table(sg, 1);
0552         sg_dma_address(sg) = dma_map_single(adapter->dev,
0553             ctl->skb->data, DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
0554         if (dma_mapping_error(adapter->dev, sg_dma_address(sg))) {
0555             err = -ENOMEM;
0556             sg_dma_address(sg) = 0;
0557             goto out;
0558         }
0559 
0560         sg_dma_len(sg) = DMA_BUFFER_SIZE;
0561 
0562         ctl->adesc = dmaengine_prep_slave_sg(ctl->chan,
0563             sg, 1, DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT);
0564 
0565         if (!ctl->adesc) {
0566             err = -ENOMEM;
0567             goto out;
0568         }
0569 
0570         ctl->adesc->callback_param = netdev;
0571         ctl->adesc->callback = ks8842_dma_rx_cb;
0572         ctl->adesc->tx_submit(ctl->adesc);
0573     } else {
0574         err = -ENOMEM;
0575         sg_dma_address(sg) = 0;
0576         goto out;
0577     }
0578 
0579     return 0;
0580 out:
0581     if (sg_dma_address(sg))
0582         dma_unmap_single(adapter->dev, sg_dma_address(sg),
0583             DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
0584     sg_dma_address(sg) = 0;
0585     dev_kfree_skb(ctl->skb);
0586     ctl->skb = NULL;
0587 
0588     printk(KERN_ERR DRV_NAME": Failed to start RX DMA: %d\n", err);
0589     return err;
0590 }
0591 
0592 static void ks8842_rx_frame_dma_tasklet(struct tasklet_struct *t)
0593 {
0594     struct ks8842_adapter *adapter = from_tasklet(adapter, t, dma_rx.tasklet);
0595     struct net_device *netdev = adapter->netdev;
0596     struct ks8842_rx_dma_ctl *ctl = &adapter->dma_rx;
0597     struct sk_buff *skb = ctl->skb;
0598     dma_addr_t addr = sg_dma_address(&ctl->sg);
0599     u32 status;
0600 
0601     ctl->adesc = NULL;
0602 
0603     /* kick next transfer going */
0604     __ks8842_start_new_rx_dma(netdev);
0605 
0606     /* now handle the data we got */
0607     dma_unmap_single(adapter->dev, addr, DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
0608 
0609     status = *((u32 *)skb->data);
0610 
0611     netdev_dbg(netdev, "%s - rx_data: status: %x\n",
0612         __func__, status & 0xffff);
0613 
0614     /* check the status */
0615     if ((status & RXSR_VALID) && !(status & RXSR_ERROR)) {
0616         int len = (status >> 16) & 0x7ff;
0617 
0618         ks8842_update_rx_counters(netdev, status, len);
0619 
0620         /* reserve 4 bytes which is the status word */
0621         skb_reserve(skb, 4);
0622         skb_put(skb, len);
0623 
0624         skb->protocol = eth_type_trans(skb, netdev);
0625         netif_rx(skb);
0626     } else {
0627         ks8842_update_rx_err_counters(netdev, status);
0628         dev_kfree_skb(skb);
0629     }
0630 }
0631 
0632 static void ks8842_rx_frame(struct net_device *netdev,
0633     struct ks8842_adapter *adapter)
0634 {
0635     u32 status;
0636     int len;
0637 
0638     if (adapter->conf_flags & KS884X_16BIT) {
0639         status = ks8842_read16(adapter, 17, REG_QMU_DATA_LO);
0640         len = ks8842_read16(adapter, 17, REG_QMU_DATA_HI);
0641         netdev_dbg(netdev, "%s - rx_data: status: %x\n",
0642                __func__, status);
0643     } else {
0644         status = ks8842_read32(adapter, 17, REG_QMU_DATA_LO);
0645         len = (status >> 16) & 0x7ff;
0646         status &= 0xffff;
0647         netdev_dbg(netdev, "%s - rx_data: status: %x\n",
0648                __func__, status);
0649     }
0650 
0651     /* check the status */
0652     if ((status & RXSR_VALID) && !(status & RXSR_ERROR)) {
0653         struct sk_buff *skb = netdev_alloc_skb_ip_align(netdev, len + 3);
0654 
0655         if (skb) {
0656 
0657             ks8842_update_rx_counters(netdev, status, len);
0658 
0659             if (adapter->conf_flags & KS884X_16BIT) {
0660                 u16 *data16 = skb_put(skb, len);
0661                 ks8842_select_bank(adapter, 17);
0662                 while (len > 0) {
0663                     *data16++ = ioread16(adapter->hw_addr +
0664                         REG_QMU_DATA_LO);
0665                     *data16++ = ioread16(adapter->hw_addr +
0666                         REG_QMU_DATA_HI);
0667                     len -= sizeof(u32);
0668                 }
0669             } else {
0670                 u32 *data = skb_put(skb, len);
0671 
0672                 ks8842_select_bank(adapter, 17);
0673                 while (len > 0) {
0674                     *data++ = ioread32(adapter->hw_addr +
0675                         REG_QMU_DATA_LO);
0676                     len -= sizeof(u32);
0677                 }
0678             }
0679             skb->protocol = eth_type_trans(skb, netdev);
0680             netif_rx(skb);
0681         } else
0682             netdev->stats.rx_dropped++;
0683     } else
0684         ks8842_update_rx_err_counters(netdev, status);
0685 
0686     /* set high watermark to 3K */
0687     ks8842_clear_bits(adapter, 0, 1 << 12, REG_QRFCR);
0688 
0689     /* release the frame */
0690     ks8842_write16(adapter, 17, 0x01, REG_RXQCR);
0691 
0692     /* set high watermark to 2K */
0693     ks8842_enable_bits(adapter, 0, 1 << 12, REG_QRFCR);
0694 }
0695 
0696 static void ks8842_handle_rx(struct net_device *netdev,
0697     struct ks8842_adapter *adapter)
0698 {
0699     u16 rx_data = ks8842_read16(adapter, 16, REG_RXMIR) & 0x1fff;
0700     netdev_dbg(netdev, "%s Entry - rx_data: %d\n", __func__, rx_data);
0701     while (rx_data) {
0702         ks8842_rx_frame(netdev, adapter);
0703         rx_data = ks8842_read16(adapter, 16, REG_RXMIR) & 0x1fff;
0704     }
0705 }
0706 
0707 static void ks8842_handle_tx(struct net_device *netdev,
0708     struct ks8842_adapter *adapter)
0709 {
0710     u16 sr = ks8842_read16(adapter, 16, REG_TXSR);
0711     netdev_dbg(netdev, "%s - entry, sr: %x\n", __func__, sr);
0712     netdev->stats.tx_packets++;
0713     if (netif_queue_stopped(netdev))
0714         netif_wake_queue(netdev);
0715 }
0716 
0717 static void ks8842_handle_rx_overrun(struct net_device *netdev,
0718     struct ks8842_adapter *adapter)
0719 {
0720     netdev_dbg(netdev, "%s: entry\n", __func__);
0721     netdev->stats.rx_errors++;
0722     netdev->stats.rx_fifo_errors++;
0723 }
0724 
0725 static void ks8842_tasklet(struct tasklet_struct *t)
0726 {
0727     struct ks8842_adapter *adapter = from_tasklet(adapter, t, tasklet);
0728     struct net_device *netdev = adapter->netdev;
0729     u16 isr;
0730     unsigned long flags;
0731     u16 entry_bank;
0732 
0733     /* read current bank to be able to set it back */
0734     spin_lock_irqsave(&adapter->lock, flags);
0735     entry_bank = ioread16(adapter->hw_addr + REG_SELECT_BANK);
0736     spin_unlock_irqrestore(&adapter->lock, flags);
0737 
0738     isr = ks8842_read16(adapter, 18, REG_ISR);
0739     netdev_dbg(netdev, "%s - ISR: 0x%x\n", __func__, isr);
0740 
0741     /* when running in DMA mode, do not ack RX interrupts, it is handled
0742        internally by timberdale, otherwise it's DMA FIFO:s would stop
0743     */
0744     if (KS8842_USE_DMA(adapter))
0745         isr &= ~IRQ_RX;
0746 
0747     /* Ack */
0748     ks8842_write16(adapter, 18, isr, REG_ISR);
0749 
0750     if (!(adapter->conf_flags & MICREL_KS884X))
0751         /* Ack in the timberdale IP as well */
0752         iowrite32(0x1, adapter->hw_addr + REG_TIMB_IAR);
0753 
0754     if (!netif_running(netdev))
0755         return;
0756 
0757     if (isr & IRQ_LINK_CHANGE)
0758         ks8842_update_link_status(netdev, adapter);
0759 
0760     /* should not get IRQ_RX when running DMA mode */
0761     if (isr & (IRQ_RX | IRQ_RX_ERROR) && !KS8842_USE_DMA(adapter))
0762         ks8842_handle_rx(netdev, adapter);
0763 
0764     /* should only happen when in PIO mode */
0765     if (isr & IRQ_TX)
0766         ks8842_handle_tx(netdev, adapter);
0767 
0768     if (isr & IRQ_RX_OVERRUN)
0769         ks8842_handle_rx_overrun(netdev, adapter);
0770 
0771     if (isr & IRQ_TX_STOPPED) {
0772         ks8842_disable_tx(adapter);
0773         ks8842_enable_tx(adapter);
0774     }
0775 
0776     if (isr & IRQ_RX_STOPPED) {
0777         ks8842_disable_rx(adapter);
0778         ks8842_enable_rx(adapter);
0779     }
0780 
0781     /* re-enable interrupts, put back the bank selection register */
0782     spin_lock_irqsave(&adapter->lock, flags);
0783     if (KS8842_USE_DMA(adapter))
0784         ks8842_write16(adapter, 18, ENABLED_IRQS_DMA, REG_IER);
0785     else
0786         ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
0787     iowrite16(entry_bank, adapter->hw_addr + REG_SELECT_BANK);
0788 
0789     /* Make sure timberdale continues DMA operations, they are stopped while
0790        we are handling the ks8842 because we might change bank */
0791     if (KS8842_USE_DMA(adapter))
0792         ks8842_resume_dma(adapter);
0793 
0794     spin_unlock_irqrestore(&adapter->lock, flags);
0795 }
0796 
0797 static irqreturn_t ks8842_irq(int irq, void *devid)
0798 {
0799     struct net_device *netdev = devid;
0800     struct ks8842_adapter *adapter = netdev_priv(netdev);
0801     u16 isr;
0802     u16 entry_bank = ioread16(adapter->hw_addr + REG_SELECT_BANK);
0803     irqreturn_t ret = IRQ_NONE;
0804 
0805     isr = ks8842_read16(adapter, 18, REG_ISR);
0806     netdev_dbg(netdev, "%s - ISR: 0x%x\n", __func__, isr);
0807 
0808     if (isr) {
0809         if (KS8842_USE_DMA(adapter))
0810             /* disable all but RX IRQ, since the FPGA relies on it*/
0811             ks8842_write16(adapter, 18, IRQ_RX, REG_IER);
0812         else
0813             /* disable IRQ */
0814             ks8842_write16(adapter, 18, 0x00, REG_IER);
0815 
0816         /* schedule tasklet */
0817         tasklet_schedule(&adapter->tasklet);
0818 
0819         ret = IRQ_HANDLED;
0820     }
0821 
0822     iowrite16(entry_bank, adapter->hw_addr + REG_SELECT_BANK);
0823 
0824     /* After an interrupt, tell timberdale to continue DMA operations.
0825        DMA is disabled while we are handling the ks8842 because we might
0826        change bank */
0827     ks8842_resume_dma(adapter);
0828 
0829     return ret;
0830 }
0831 
0832 static void ks8842_dma_rx_cb(void *data)
0833 {
0834     struct net_device   *netdev = data;
0835     struct ks8842_adapter   *adapter = netdev_priv(netdev);
0836 
0837     netdev_dbg(netdev, "RX DMA finished\n");
0838     /* schedule tasklet */
0839     if (adapter->dma_rx.adesc)
0840         tasklet_schedule(&adapter->dma_rx.tasklet);
0841 }
0842 
0843 static void ks8842_dma_tx_cb(void *data)
0844 {
0845     struct net_device       *netdev = data;
0846     struct ks8842_adapter       *adapter = netdev_priv(netdev);
0847     struct ks8842_tx_dma_ctl    *ctl = &adapter->dma_tx;
0848 
0849     netdev_dbg(netdev, "TX DMA finished\n");
0850 
0851     if (!ctl->adesc)
0852         return;
0853 
0854     netdev->stats.tx_packets++;
0855     ctl->adesc = NULL;
0856 
0857     if (netif_queue_stopped(netdev))
0858         netif_wake_queue(netdev);
0859 }
0860 
0861 static void ks8842_stop_dma(struct ks8842_adapter *adapter)
0862 {
0863     struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
0864     struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
0865 
0866     tx_ctl->adesc = NULL;
0867     if (tx_ctl->chan)
0868         dmaengine_terminate_all(tx_ctl->chan);
0869 
0870     rx_ctl->adesc = NULL;
0871     if (rx_ctl->chan)
0872         dmaengine_terminate_all(rx_ctl->chan);
0873 
0874     if (sg_dma_address(&rx_ctl->sg))
0875         dma_unmap_single(adapter->dev, sg_dma_address(&rx_ctl->sg),
0876             DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
0877     sg_dma_address(&rx_ctl->sg) = 0;
0878 
0879     dev_kfree_skb(rx_ctl->skb);
0880     rx_ctl->skb = NULL;
0881 }
0882 
0883 static void ks8842_dealloc_dma_bufs(struct ks8842_adapter *adapter)
0884 {
0885     struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
0886     struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
0887 
0888     ks8842_stop_dma(adapter);
0889 
0890     if (tx_ctl->chan)
0891         dma_release_channel(tx_ctl->chan);
0892     tx_ctl->chan = NULL;
0893 
0894     if (rx_ctl->chan)
0895         dma_release_channel(rx_ctl->chan);
0896     rx_ctl->chan = NULL;
0897 
0898     tasklet_kill(&rx_ctl->tasklet);
0899 
0900     if (sg_dma_address(&tx_ctl->sg))
0901         dma_unmap_single(adapter->dev, sg_dma_address(&tx_ctl->sg),
0902             DMA_BUFFER_SIZE, DMA_TO_DEVICE);
0903     sg_dma_address(&tx_ctl->sg) = 0;
0904 
0905     kfree(tx_ctl->buf);
0906     tx_ctl->buf = NULL;
0907 }
0908 
0909 static bool ks8842_dma_filter_fn(struct dma_chan *chan, void *filter_param)
0910 {
0911     return chan->chan_id == (long)filter_param;
0912 }
0913 
0914 static int ks8842_alloc_dma_bufs(struct net_device *netdev)
0915 {
0916     struct ks8842_adapter *adapter = netdev_priv(netdev);
0917     struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
0918     struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
0919     int err;
0920 
0921     dma_cap_mask_t mask;
0922 
0923     dma_cap_zero(mask);
0924     dma_cap_set(DMA_SLAVE, mask);
0925     dma_cap_set(DMA_PRIVATE, mask);
0926 
0927     sg_init_table(&tx_ctl->sg, 1);
0928 
0929     tx_ctl->chan = dma_request_channel(mask, ks8842_dma_filter_fn,
0930                        (void *)(long)tx_ctl->channel);
0931     if (!tx_ctl->chan) {
0932         err = -ENODEV;
0933         goto err;
0934     }
0935 
0936     /* allocate DMA buffer */
0937     tx_ctl->buf = kmalloc(DMA_BUFFER_SIZE, GFP_KERNEL);
0938     if (!tx_ctl->buf) {
0939         err = -ENOMEM;
0940         goto err;
0941     }
0942 
0943     sg_dma_address(&tx_ctl->sg) = dma_map_single(adapter->dev,
0944         tx_ctl->buf, DMA_BUFFER_SIZE, DMA_TO_DEVICE);
0945     if (dma_mapping_error(adapter->dev, sg_dma_address(&tx_ctl->sg))) {
0946         err = -ENOMEM;
0947         sg_dma_address(&tx_ctl->sg) = 0;
0948         goto err;
0949     }
0950 
0951     rx_ctl->chan = dma_request_channel(mask, ks8842_dma_filter_fn,
0952                        (void *)(long)rx_ctl->channel);
0953     if (!rx_ctl->chan) {
0954         err = -ENODEV;
0955         goto err;
0956     }
0957 
0958     tasklet_setup(&rx_ctl->tasklet, ks8842_rx_frame_dma_tasklet);
0959 
0960     return 0;
0961 err:
0962     ks8842_dealloc_dma_bufs(adapter);
0963     return err;
0964 }
0965 
0966 /* Netdevice operations */
0967 
0968 static int ks8842_open(struct net_device *netdev)
0969 {
0970     struct ks8842_adapter *adapter = netdev_priv(netdev);
0971     int err;
0972 
0973     netdev_dbg(netdev, "%s - entry\n", __func__);
0974 
0975     if (KS8842_USE_DMA(adapter)) {
0976         err = ks8842_alloc_dma_bufs(netdev);
0977 
0978         if (!err) {
0979             /* start RX dma */
0980             err = __ks8842_start_new_rx_dma(netdev);
0981             if (err)
0982                 ks8842_dealloc_dma_bufs(adapter);
0983         }
0984 
0985         if (err) {
0986             printk(KERN_WARNING DRV_NAME
0987                 ": Failed to initiate DMA, running PIO\n");
0988             ks8842_dealloc_dma_bufs(adapter);
0989             adapter->dma_rx.channel = -1;
0990             adapter->dma_tx.channel = -1;
0991         }
0992     }
0993 
0994     /* reset the HW */
0995     ks8842_reset_hw(adapter);
0996 
0997     ks8842_write_mac_addr(adapter, netdev->dev_addr);
0998 
0999     ks8842_update_link_status(netdev, adapter);
1000 
1001     err = request_irq(adapter->irq, ks8842_irq, IRQF_SHARED, DRV_NAME,
1002         netdev);
1003     if (err) {
1004         pr_err("Failed to request IRQ: %d: %d\n", adapter->irq, err);
1005         return err;
1006     }
1007 
1008     return 0;
1009 }
1010 
1011 static int ks8842_close(struct net_device *netdev)
1012 {
1013     struct ks8842_adapter *adapter = netdev_priv(netdev);
1014 
1015     netdev_dbg(netdev, "%s - entry\n", __func__);
1016 
1017     cancel_work_sync(&adapter->timeout_work);
1018 
1019     if (KS8842_USE_DMA(adapter))
1020         ks8842_dealloc_dma_bufs(adapter);
1021 
1022     /* free the irq */
1023     free_irq(adapter->irq, netdev);
1024 
1025     /* disable the switch */
1026     ks8842_write16(adapter, 32, 0x0, REG_SW_ID_AND_ENABLE);
1027 
1028     return 0;
1029 }
1030 
1031 static netdev_tx_t ks8842_xmit_frame(struct sk_buff *skb,
1032                      struct net_device *netdev)
1033 {
1034     int ret;
1035     struct ks8842_adapter *adapter = netdev_priv(netdev);
1036 
1037     netdev_dbg(netdev, "%s: entry\n", __func__);
1038 
1039     if (KS8842_USE_DMA(adapter)) {
1040         unsigned long flags;
1041         ret = ks8842_tx_frame_dma(skb, netdev);
1042         /* for now only allow one transfer at the time */
1043         spin_lock_irqsave(&adapter->lock, flags);
1044         if (adapter->dma_tx.adesc)
1045             netif_stop_queue(netdev);
1046         spin_unlock_irqrestore(&adapter->lock, flags);
1047         return ret;
1048     }
1049 
1050     ret = ks8842_tx_frame(skb, netdev);
1051 
1052     if (ks8842_tx_fifo_space(adapter) <  netdev->mtu + 8)
1053         netif_stop_queue(netdev);
1054 
1055     return ret;
1056 }
1057 
1058 static int ks8842_set_mac(struct net_device *netdev, void *p)
1059 {
1060     struct ks8842_adapter *adapter = netdev_priv(netdev);
1061     struct sockaddr *addr = p;
1062     char *mac = (u8 *)addr->sa_data;
1063 
1064     netdev_dbg(netdev, "%s: entry\n", __func__);
1065 
1066     if (!is_valid_ether_addr(addr->sa_data))
1067         return -EADDRNOTAVAIL;
1068 
1069     eth_hw_addr_set(netdev, mac);
1070 
1071     ks8842_write_mac_addr(adapter, mac);
1072     return 0;
1073 }
1074 
1075 static void ks8842_tx_timeout_work(struct work_struct *work)
1076 {
1077     struct ks8842_adapter *adapter =
1078         container_of(work, struct ks8842_adapter, timeout_work);
1079     struct net_device *netdev = adapter->netdev;
1080     unsigned long flags;
1081 
1082     netdev_dbg(netdev, "%s: entry\n", __func__);
1083 
1084     spin_lock_irqsave(&adapter->lock, flags);
1085 
1086     if (KS8842_USE_DMA(adapter))
1087         ks8842_stop_dma(adapter);
1088 
1089     /* disable interrupts */
1090     ks8842_write16(adapter, 18, 0, REG_IER);
1091     ks8842_write16(adapter, 18, 0xFFFF, REG_ISR);
1092 
1093     netif_stop_queue(netdev);
1094 
1095     spin_unlock_irqrestore(&adapter->lock, flags);
1096 
1097     ks8842_reset_hw(adapter);
1098 
1099     ks8842_write_mac_addr(adapter, netdev->dev_addr);
1100 
1101     ks8842_update_link_status(netdev, adapter);
1102 
1103     if (KS8842_USE_DMA(adapter))
1104         __ks8842_start_new_rx_dma(netdev);
1105 }
1106 
1107 static void ks8842_tx_timeout(struct net_device *netdev, unsigned int txqueue)
1108 {
1109     struct ks8842_adapter *adapter = netdev_priv(netdev);
1110 
1111     netdev_dbg(netdev, "%s: entry\n", __func__);
1112 
1113     schedule_work(&adapter->timeout_work);
1114 }
1115 
1116 static const struct net_device_ops ks8842_netdev_ops = {
1117     .ndo_open       = ks8842_open,
1118     .ndo_stop       = ks8842_close,
1119     .ndo_start_xmit     = ks8842_xmit_frame,
1120     .ndo_set_mac_address    = ks8842_set_mac,
1121     .ndo_tx_timeout     = ks8842_tx_timeout,
1122     .ndo_validate_addr  = eth_validate_addr
1123 };
1124 
1125 static const struct ethtool_ops ks8842_ethtool_ops = {
1126     .get_link       = ethtool_op_get_link,
1127 };
1128 
1129 static int ks8842_probe(struct platform_device *pdev)
1130 {
1131     int err = -ENOMEM;
1132     struct resource *iomem;
1133     struct net_device *netdev;
1134     struct ks8842_adapter *adapter;
1135     struct ks8842_platform_data *pdata = dev_get_platdata(&pdev->dev);
1136     u16 id;
1137     unsigned i;
1138 
1139     iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1140     if (!iomem) {
1141         dev_err(&pdev->dev, "Invalid resource\n");
1142         return -EINVAL;
1143     }
1144     if (!request_mem_region(iomem->start, resource_size(iomem), DRV_NAME))
1145         goto err_mem_region;
1146 
1147     netdev = alloc_etherdev(sizeof(struct ks8842_adapter));
1148     if (!netdev)
1149         goto err_alloc_etherdev;
1150 
1151     SET_NETDEV_DEV(netdev, &pdev->dev);
1152 
1153     adapter = netdev_priv(netdev);
1154     adapter->netdev = netdev;
1155     INIT_WORK(&adapter->timeout_work, ks8842_tx_timeout_work);
1156     adapter->hw_addr = ioremap(iomem->start, resource_size(iomem));
1157     adapter->conf_flags = iomem->flags;
1158 
1159     if (!adapter->hw_addr)
1160         goto err_ioremap;
1161 
1162     adapter->irq = platform_get_irq(pdev, 0);
1163     if (adapter->irq < 0) {
1164         err = adapter->irq;
1165         goto err_get_irq;
1166     }
1167 
1168     adapter->dev = (pdev->dev.parent) ? pdev->dev.parent : &pdev->dev;
1169 
1170     /* DMA is only supported when accessed via timberdale */
1171     if (!(adapter->conf_flags & MICREL_KS884X) && pdata &&
1172         (pdata->tx_dma_channel != -1) &&
1173         (pdata->rx_dma_channel != -1)) {
1174         adapter->dma_rx.channel = pdata->rx_dma_channel;
1175         adapter->dma_tx.channel = pdata->tx_dma_channel;
1176     } else {
1177         adapter->dma_rx.channel = -1;
1178         adapter->dma_tx.channel = -1;
1179     }
1180 
1181     tasklet_setup(&adapter->tasklet, ks8842_tasklet);
1182     spin_lock_init(&adapter->lock);
1183 
1184     netdev->netdev_ops = &ks8842_netdev_ops;
1185     netdev->ethtool_ops = &ks8842_ethtool_ops;
1186 
1187     /* Check if a mac address was given */
1188     i = netdev->addr_len;
1189     if (pdata) {
1190         for (i = 0; i < netdev->addr_len; i++)
1191             if (pdata->macaddr[i] != 0)
1192                 break;
1193 
1194         if (i < netdev->addr_len)
1195             /* an address was passed, use it */
1196             eth_hw_addr_set(netdev, pdata->macaddr);
1197     }
1198 
1199     if (i == netdev->addr_len) {
1200         ks8842_init_mac_addr(adapter);
1201 
1202         if (!is_valid_ether_addr(netdev->dev_addr))
1203             eth_hw_addr_random(netdev);
1204     }
1205 
1206     id = ks8842_read16(adapter, 32, REG_SW_ID_AND_ENABLE);
1207 
1208     strcpy(netdev->name, "eth%d");
1209     err = register_netdev(netdev);
1210     if (err)
1211         goto err_register;
1212 
1213     platform_set_drvdata(pdev, netdev);
1214 
1215     pr_info("Found chip, family: 0x%x, id: 0x%x, rev: 0x%x\n",
1216         (id >> 8) & 0xff, (id >> 4) & 0xf, (id >> 1) & 0x7);
1217 
1218     return 0;
1219 
1220 err_register:
1221 err_get_irq:
1222     iounmap(adapter->hw_addr);
1223 err_ioremap:
1224     free_netdev(netdev);
1225 err_alloc_etherdev:
1226     release_mem_region(iomem->start, resource_size(iomem));
1227 err_mem_region:
1228     return err;
1229 }
1230 
1231 static int ks8842_remove(struct platform_device *pdev)
1232 {
1233     struct net_device *netdev = platform_get_drvdata(pdev);
1234     struct ks8842_adapter *adapter = netdev_priv(netdev);
1235     struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1236 
1237     unregister_netdev(netdev);
1238     tasklet_kill(&adapter->tasklet);
1239     iounmap(adapter->hw_addr);
1240     free_netdev(netdev);
1241     release_mem_region(iomem->start, resource_size(iomem));
1242     return 0;
1243 }
1244 
1245 
1246 static struct platform_driver ks8842_platform_driver = {
1247     .driver = {
1248         .name   = DRV_NAME,
1249     },
1250     .probe      = ks8842_probe,
1251     .remove     = ks8842_remove,
1252 };
1253 
1254 module_platform_driver(ks8842_platform_driver);
1255 
1256 MODULE_DESCRIPTION("Timberdale KS8842 ethernet driver");
1257 MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
1258 MODULE_LICENSE("GPL v2");
1259 MODULE_ALIAS("platform:ks8842");
1260
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!