drivers/net/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/kernel.h>
  27 #include <linux/module.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/netdevice.h>
  30 #include <linux/etherdevice.h>
  31 #include <linux/ethtool.h>
  32 #include <linux/ks8842.h>
  33
  34 #define DRV_NAME "ks8842"
  35
  36 /* Timberdale specific Registers */
  37 #define REG_TIMB_RST            0x1c
  38 #define REG_TIMB_FIFO           0x20
  39 #define REG_TIMB_ISR            0x24
  40 #define REG_TIMB_IER            0x28
  41 #define REG_TIMB_IAR            0x2C
  42 #define REQ_TIMB_DMA_RESUME     0x30
  43
  44 /* KS8842 registers */
  45
  46 #define REG_SELECT_BANK 0x0e
  47
  48 /* bank 0 registers */
  49 #define REG_QRFCR       0x04
  50
  51 /* bank 2 registers */
  52 #define REG_MARL        0x00
  53 #define REG_MARM        0x02
  54 #define REG_MARH        0x04
  55
  56 /* bank 3 registers */
  57 #define REG_GRR         0x06
  58
  59 /* bank 16 registers */
  60 #define REG_TXCR        0x00
  61 #define REG_TXSR        0x02
  62 #define REG_RXCR        0x04
  63 #define REG_TXMIR       0x08
  64 #define REG_RXMIR       0x0A
  65
  66 /* bank 17 registers */
  67 #define REG_TXQCR       0x00
  68 #define REG_RXQCR       0x02
  69 #define REG_TXFDPR      0x04
  70 #define REG_RXFDPR      0x06
  71 #define REG_QMU_DATA_LO 0x08
  72 #define REG_QMU_DATA_HI 0x0A
  73
  74 /* bank 18 registers */
  75 #define REG_IER         0x00
  76 #define IRQ_LINK_CHANGE 0x8000
  77 #define IRQ_TX          0x4000
  78 #define IRQ_RX          0x2000
  79 #define IRQ_RX_OVERRUN  0x0800
  80 #define IRQ_TX_STOPPED  0x0200
  81 #define IRQ_RX_STOPPED  0x0100
  82 #define IRQ_RX_ERROR    0x0080
  83 #define ENABLED_IRQS    (IRQ_LINK_CHANGE | IRQ_TX | IRQ_RX | IRQ_RX_STOPPED | \
  84                 IRQ_TX_STOPPED | IRQ_RX_OVERRUN | IRQ_RX_ERROR)
  85 #define REG_ISR         0x02
  86 #define REG_RXSR        0x04
  87 #define RXSR_VALID      0x8000
  88 #define RXSR_BROADCAST  0x80
  89 #define RXSR_MULTICAST  0x40
  90 #define RXSR_UNICAST    0x20
  91 #define RXSR_FRAMETYPE  0x08
  92 #define RXSR_TOO_LONG   0x04
  93 #define RXSR_RUNT       0x02
  94 #define RXSR_CRC_ERROR  0x01
  95 #define RXSR_ERROR      (RXSR_TOO_LONG | RXSR_RUNT | RXSR_CRC_ERROR)
  96
  97 /* bank 32 registers */
  98 #define REG_SW_ID_AND_ENABLE    0x00
  99 #define REG_SGCR1               0x02
 100 #define REG_SGCR2               0x04
 101 #define REG_SGCR3               0x06
 102
 103 /* bank 39 registers */
 104 #define REG_MACAR1              0x00
 105 #define REG_MACAR2              0x02
 106 #define REG_MACAR3              0x04
 107
 108 /* bank 45 registers */
 109 #define REG_P1MBCR              0x00
 110 #define REG_P1MBSR              0x02
 111
 112 /* bank 46 registers */
 113 #define REG_P2MBCR              0x00
 114 #define REG_P2MBSR              0x02
 115
 116 /* bank 48 registers */
 117 #define REG_P1CR2               0x02
 118
 119 /* bank 49 registers */
 120 #define REG_P1CR4               0x02
 121 #define REG_P1SR                0x04
 122
 123 /* flags passed by platform_device for configuration */
 124 #define MICREL_KS884X           0x01    /* 0=Timeberdale(FPGA), 1=Micrel */
 125 #define KS884X_16BIT            0x02    /*  1=16bit, 0=32bit */
 126
 127 struct ks8842_adapter {
 128         void __iomem    *hw_addr;
 129         int             irq;
 130         unsigned long   conf_flags;     /* copy of platform_device config */
 131         struct tasklet_struct   tasklet;
 132         spinlock_t      lock; /* spinlock to be interrupt safe */
 133         struct work_struct timeout_work;
 134         struct net_device *netdev;
 135 };
 136
 137 static inline void ks8842_select_bank(struct ks8842_adapter *adapter, u16 bank)
 138 {
 139         iowrite16(bank, adapter->hw_addr + REG_SELECT_BANK);
 140 }
 141
 142 static inline void ks8842_write8(struct ks8842_adapter *adapter, u16 bank,
 143         u8 value, int offset)
 144 {
 145         ks8842_select_bank(adapter, bank);
 146         iowrite8(value, adapter->hw_addr + offset);
 147 }
 148
 149 static inline void ks8842_write16(struct ks8842_adapter *adapter, u16 bank,
 150         u16 value, int offset)
 151 {
 152         ks8842_select_bank(adapter, bank);
 153         iowrite16(value, adapter->hw_addr + offset);
 154 }
 155
 156 static inline void ks8842_enable_bits(struct ks8842_adapter *adapter, u16 bank,
 157         u16 bits, int offset)
 158 {
 159         u16 reg;
 160         ks8842_select_bank(adapter, bank);
 161         reg = ioread16(adapter->hw_addr + offset);
 162         reg |= bits;
 163         iowrite16(reg, adapter->hw_addr + offset);
 164 }
 165
 166 static inline void ks8842_clear_bits(struct ks8842_adapter *adapter, u16 bank,
 167         u16 bits, int offset)
 168 {
 169         u16 reg;
 170         ks8842_select_bank(adapter, bank);
 171         reg = ioread16(adapter->hw_addr + offset);
 172         reg &= ~bits;
 173         iowrite16(reg, adapter->hw_addr + offset);
 174 }
 175
 176 static inline void ks8842_write32(struct ks8842_adapter *adapter, u16 bank,
 177         u32 value, int offset)
 178 {
 179         ks8842_select_bank(adapter, bank);
 180         iowrite32(value, adapter->hw_addr + offset);
 181 }
 182
 183 static inline u8 ks8842_read8(struct ks8842_adapter *adapter, u16 bank,
 184         int offset)
 185 {
 186         ks8842_select_bank(adapter, bank);
 187         return ioread8(adapter->hw_addr + offset);
 188 }
 189
 190 static inline u16 ks8842_read16(struct ks8842_adapter *adapter, u16 bank,
 191         int offset)
 192 {
 193         ks8842_select_bank(adapter, bank);
 194         return ioread16(adapter->hw_addr + offset);
 195 }
 196
 197 static inline u32 ks8842_read32(struct ks8842_adapter *adapter, u16 bank,
 198         int offset)
 199 {
 200         ks8842_select_bank(adapter, bank);
 201         return ioread32(adapter->hw_addr + offset);
 202 }
 203
 204 static void ks8842_reset(struct ks8842_adapter *adapter)
 205 {
 206         if (adapter->conf_flags & MICREL_KS884X) {
 207                 ks8842_write16(adapter, 3, 1, REG_GRR);
 208                 msleep(10);
 209                 iowrite16(0, adapter->hw_addr + REG_GRR);
 210         } else {
 211                 /* The KS8842 goes haywire when doing softare reset
 212                 * a work around in the timberdale IP is implemented to
 213                 * do a hardware reset instead
 214                 ks8842_write16(adapter, 3, 1, REG_GRR);
 215                 msleep(10);
 216                 iowrite16(0, adapter->hw_addr + REG_GRR);
 217                 */
 218                 iowrite32(0x1, adapter->hw_addr + REG_TIMB_RST);
 219                 msleep(20);
 220         }
 221 }
 222
 223 static void ks8842_update_link_status(struct net_device *netdev,
 224         struct ks8842_adapter *adapter)
 225 {
 226         /* check the status of the link */
 227         if (ks8842_read16(adapter, 45, REG_P1MBSR) & 0x4) {
 228                 netif_carrier_on(netdev);
 229                 netif_wake_queue(netdev);
 230         } else {
 231                 netif_stop_queue(netdev);
 232                 netif_carrier_off(netdev);
 233         }
 234 }
 235
 236 static void ks8842_enable_tx(struct ks8842_adapter *adapter)
 237 {
 238         ks8842_enable_bits(adapter, 16, 0x01, REG_TXCR);
 239 }
 240
 241 static void ks8842_disable_tx(struct ks8842_adapter *adapter)
 242 {
 243         ks8842_clear_bits(adapter, 16, 0x01, REG_TXCR);
 244 }
 245
 246 static void ks8842_enable_rx(struct ks8842_adapter *adapter)
 247 {
 248         ks8842_enable_bits(adapter, 16, 0x01, REG_RXCR);
 249 }
 250
 251 static void ks8842_disable_rx(struct ks8842_adapter *adapter)
 252 {
 253         ks8842_clear_bits(adapter, 16, 0x01, REG_RXCR);
 254 }
 255
 256 static void ks8842_reset_hw(struct ks8842_adapter *adapter)
 257 {
 258         /* reset the HW */
 259         ks8842_reset(adapter);
 260
 261         /* Enable QMU Transmit flow control / transmit padding / Transmit CRC */
 262         ks8842_write16(adapter, 16, 0x000E, REG_TXCR);
 263
 264         /* enable the receiver, uni + multi + broadcast + flow ctrl
 265                 + crc strip */
 266         ks8842_write16(adapter, 16, 0x8 | 0x20 | 0x40 | 0x80 | 0x400,
 267                 REG_RXCR);
 268
 269         /* TX frame pointer autoincrement */
 270         ks8842_write16(adapter, 17, 0x4000, REG_TXFDPR);
 271
 272         /* RX frame pointer autoincrement */
 273         ks8842_write16(adapter, 17, 0x4000, REG_RXFDPR);
 274
 275         /* RX 2 kb high watermark */
 276         ks8842_write16(adapter, 0, 0x1000, REG_QRFCR);
 277
 278         /* aggresive back off in half duplex */
 279         ks8842_enable_bits(adapter, 32, 1 << 8, REG_SGCR1);
 280
 281         /* enable no excessive collison drop */
 282         ks8842_enable_bits(adapter, 32, 1 << 3, REG_SGCR2);
 283
 284         /* Enable port 1 force flow control / back pressure / transmit / recv */
 285         ks8842_write16(adapter, 48, 0x1E07, REG_P1CR2);
 286
 287         /* restart port auto-negotiation */
 288         ks8842_enable_bits(adapter, 49, 1 << 13, REG_P1CR4);
 289
 290         /* Enable the transmitter */
 291         ks8842_enable_tx(adapter);
 292
 293         /* Enable the receiver */
 294         ks8842_enable_rx(adapter);
 295
 296         /* clear all interrupts */
 297         ks8842_write16(adapter, 18, 0xffff, REG_ISR);
 298
 299         /* enable interrupts */
 300         ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
 301
 302         /* enable the switch */
 303         ks8842_write16(adapter, 32, 0x1, REG_SW_ID_AND_ENABLE);
 304 }
 305
 306 static void ks8842_read_mac_addr(struct ks8842_adapter *adapter, u8 *dest)
 307 {
 308         int i;
 309         u16 mac;
 310
 311         for (i = 0; i < ETH_ALEN; i++)
 312                 dest[ETH_ALEN - i - 1] = ks8842_read8(adapter, 2, REG_MARL + i);
 313
 314         if (adapter->conf_flags & MICREL_KS884X) {
 315                 /*
 316                 the sequence of saving mac addr between MAC and Switch is
 317                 different.
 318                 */
 319
 320                 mac = ks8842_read16(adapter, 2, REG_MARL);
 321                 ks8842_write16(adapter, 39, mac, REG_MACAR3);
 322                 mac = ks8842_read16(adapter, 2, REG_MARM);
 323                 ks8842_write16(adapter, 39, mac, REG_MACAR2);
 324                 mac = ks8842_read16(adapter, 2, REG_MARH);
 325                 ks8842_write16(adapter, 39, mac, REG_MACAR1);
 326         } else {
 327
 328                 /* make sure the switch port uses the same MAC as the QMU */
 329                 mac = ks8842_read16(adapter, 2, REG_MARL);
 330                 ks8842_write16(adapter, 39, mac, REG_MACAR1);
 331                 mac = ks8842_read16(adapter, 2, REG_MARM);
 332                 ks8842_write16(adapter, 39, mac, REG_MACAR2);
 333                 mac = ks8842_read16(adapter, 2, REG_MARH);
 334                 ks8842_write16(adapter, 39, mac, REG_MACAR3);
 335         }
 336 }
 337
 338 static void ks8842_write_mac_addr(struct ks8842_adapter *adapter, u8 *mac)
 339 {
 340         unsigned long flags;
 341         unsigned i;
 342
 343         spin_lock_irqsave(&adapter->lock, flags);
 344         for (i = 0; i < ETH_ALEN; i++) {
 345                 ks8842_write8(adapter, 2, mac[ETH_ALEN - i - 1], REG_MARL + i);
 346                 if (!(adapter->conf_flags & MICREL_KS884X))
 347                         ks8842_write8(adapter, 39, mac[ETH_ALEN - i - 1],
 348                                 REG_MACAR1 + i);
 349         }
 350
 351         if (adapter->conf_flags & MICREL_KS884X) {
 352                 /*
 353                 the sequence of saving mac addr between MAC and Switch is
 354                 different.
 355                 */
 356
 357                 u16 mac;
 358
 359                 mac = ks8842_read16(adapter, 2, REG_MARL);
 360                 ks8842_write16(adapter, 39, mac, REG_MACAR3);
 361                 mac = ks8842_read16(adapter, 2, REG_MARM);
 362                 ks8842_write16(adapter, 39, mac, REG_MACAR2);
 363                 mac = ks8842_read16(adapter, 2, REG_MARH);
 364                 ks8842_write16(adapter, 39, mac, REG_MACAR1);
 365         }
 366         spin_unlock_irqrestore(&adapter->lock, flags);
 367 }
 368
 369 static inline u16 ks8842_tx_fifo_space(struct ks8842_adapter *adapter)
 370 {
 371         return ks8842_read16(adapter, 16, REG_TXMIR) & 0x1fff;
 372 }
 373
 374 static int ks8842_tx_frame(struct sk_buff *skb, struct net_device *netdev)
 375 {
 376         struct ks8842_adapter *adapter = netdev_priv(netdev);
 377         int len = skb->len;
 378
 379         netdev_dbg(netdev, "%s: len %u head %p data %p tail %p end %p\n",
 380                 __func__, skb->len, skb->head, skb->data,
 381                 skb_tail_pointer(skb), skb_end_pointer(skb));
 382
 383         /* check FIFO buffer space, we need space for CRC and command bits */
 384         if (ks8842_tx_fifo_space(adapter) < len + 8)
 385                 return NETDEV_TX_BUSY;
 386
 387         if (adapter->conf_flags & KS884X_16BIT) {
 388                 u16 *ptr16 = (u16 *)skb->data;
 389                 ks8842_write16(adapter, 17, 0x8000 | 0x100, REG_QMU_DATA_LO);
 390                 ks8842_write16(adapter, 17, (u16)len, REG_QMU_DATA_HI);
 391                 netdev->stats.tx_bytes += len;
 392
 393                 /* copy buffer */
 394                 while (len > 0) {
 395                         iowrite16(*ptr16++, adapter->hw_addr + REG_QMU_DATA_LO);
 396                         iowrite16(*ptr16++, adapter->hw_addr + REG_QMU_DATA_HI);
 397                         len -= sizeof(u32);
 398                 }
 399         } else {
 400
 401                 u32 *ptr = (u32 *)skb->data;
 402                 u32 ctrl;
 403                 /* the control word, enable IRQ, port 1 and the length */
 404                 ctrl = 0x8000 | 0x100 | (len << 16);
 405                 ks8842_write32(adapter, 17, ctrl, REG_QMU_DATA_LO);
 406
 407                 netdev->stats.tx_bytes += len;
 408
 409                 /* copy buffer */
 410                 while (len > 0) {
 411                         iowrite32(*ptr, adapter->hw_addr + REG_QMU_DATA_LO);
 412                         len -= sizeof(u32);
 413                         ptr++;
 414                 }
 415         }
 416
 417         /* enqueue packet */
 418         ks8842_write16(adapter, 17, 1, REG_TXQCR);
 419
 420         dev_kfree_skb(skb);
 421
 422         return NETDEV_TX_OK;
 423 }
 424
 425 static void ks8842_rx_frame(struct net_device *netdev,
 426         struct ks8842_adapter *adapter)
 427 {
 428         u32 status;
 429         int len;
 430
 431         if (adapter->conf_flags & KS884X_16BIT) {
 432                 status = ks8842_read16(adapter, 17, REG_QMU_DATA_LO);
 433                 len = ks8842_read16(adapter, 17, REG_QMU_DATA_HI);
 434                 netdev_dbg(netdev, "%s - rx_data: status: %x\n",
 435                            __func__, status);
 436         } else {
 437                 status = ks8842_read32(adapter, 17, REG_QMU_DATA_LO);
 438                 len = (status >> 16) & 0x7ff;
 439                 status &= 0xffff;
 440                 netdev_dbg(netdev, "%s - rx_data: status: %x\n",
 441                            __func__, status);
 442         }
 443
 444         /* check the status */
 445         if ((status & RXSR_VALID) && !(status & RXSR_ERROR)) {
 446                 struct sk_buff *skb = netdev_alloc_skb_ip_align(netdev, len);
 447
 448                 netdev_dbg(netdev, "%s, got package, len: %d\n", __func__, len);
 449                 if (skb) {
 450
 451                         netdev->stats.rx_packets++;
 452                         netdev->stats.rx_bytes += len;
 453                         if (status & RXSR_MULTICAST)
 454                                 netdev->stats.multicast++;
 455
 456                         if (adapter->conf_flags & KS884X_16BIT) {
 457                                 u16 *data16 = (u16 *)skb_put(skb, len);
 458                                 ks8842_select_bank(adapter, 17);
 459                                 while (len > 0) {
 460                                         *data16++ = ioread16(adapter->hw_addr +
 461                                                 REG_QMU_DATA_LO);
 462                                         *data16++ = ioread16(adapter->hw_addr +
 463                                                 REG_QMU_DATA_HI);
 464                                         len -= sizeof(u32);
 465                                 }
 466                         } else {
 467                                 u32 *data = (u32 *)skb_put(skb, len);
 468
 469                                 ks8842_select_bank(adapter, 17);
 470                                 while (len > 0) {
 471                                         *data++ = ioread32(adapter->hw_addr +
 472                                                 REG_QMU_DATA_LO);
 473                                         len -= sizeof(u32);
 474                                 }
 475                         }
 476                         skb->protocol = eth_type_trans(skb, netdev);
 477                         netif_rx(skb);
 478                 } else
 479                         netdev->stats.rx_dropped++;
 480         } else {
 481                 netdev_dbg(netdev, "RX error, status: %x\n", status);
 482                 netdev->stats.rx_errors++;
 483                 if (status & RXSR_TOO_LONG)
 484                         netdev->stats.rx_length_errors++;
 485                 if (status & RXSR_CRC_ERROR)
 486                         netdev->stats.rx_crc_errors++;
 487                 if (status & RXSR_RUNT)
 488                         netdev->stats.rx_frame_errors++;
 489         }
 490
 491         /* set high watermark to 3K */
 492         ks8842_clear_bits(adapter, 0, 1 << 12, REG_QRFCR);
 493
 494         /* release the frame */
 495         ks8842_write16(adapter, 17, 0x01, REG_RXQCR);
 496
 497         /* set high watermark to 2K */
 498         ks8842_enable_bits(adapter, 0, 1 << 12, REG_QRFCR);
 499 }
 500
 501 void ks8842_handle_rx(struct net_device *netdev, struct ks8842_adapter *adapter)
 502 {
 503         u16 rx_data = ks8842_read16(adapter, 16, REG_RXMIR) & 0x1fff;
 504         netdev_dbg(netdev, "%s Entry - rx_data: %d\n", __func__, rx_data);
 505         while (rx_data) {
 506                 ks8842_rx_frame(netdev, adapter);
 507                 rx_data = ks8842_read16(adapter, 16, REG_RXMIR) & 0x1fff;
 508         }
 509 }
 510
 511 void ks8842_handle_tx(struct net_device *netdev, struct ks8842_adapter *adapter)
 512 {
 513         u16 sr = ks8842_read16(adapter, 16, REG_TXSR);
 514         netdev_dbg(netdev, "%s - entry, sr: %x\n", __func__, sr);
 515         netdev->stats.tx_packets++;
 516         if (netif_queue_stopped(netdev))
 517                 netif_wake_queue(netdev);
 518 }
 519
 520 void ks8842_handle_rx_overrun(struct net_device *netdev,
 521         struct ks8842_adapter *adapter)
 522 {
 523         netdev_dbg(netdev, "%s: entry\n", __func__);
 524         netdev->stats.rx_errors++;
 525         netdev->stats.rx_fifo_errors++;
 526 }
 527
 528 void ks8842_tasklet(unsigned long arg)
 529 {
 530         struct net_device *netdev = (struct net_device *)arg;
 531         struct ks8842_adapter *adapter = netdev_priv(netdev);
 532         u16 isr;
 533         unsigned long flags;
 534         u16 entry_bank;
 535
 536         /* read current bank to be able to set it back */
 537         spin_lock_irqsave(&adapter->lock, flags);
 538         entry_bank = ioread16(adapter->hw_addr + REG_SELECT_BANK);
 539         spin_unlock_irqrestore(&adapter->lock, flags);
 540
 541         isr = ks8842_read16(adapter, 18, REG_ISR);
 542         netdev_dbg(netdev, "%s - ISR: 0x%x\n", __func__, isr);
 543
 544         /* Ack */
 545         ks8842_write16(adapter, 18, isr, REG_ISR);
 546
 547         if (!(adapter->conf_flags & MICREL_KS884X))
 548                 /* Ack in the timberdale IP as well */
 549                 iowrite32(0x1, adapter->hw_addr + REG_TIMB_IAR);
 550
 551         if (!netif_running(netdev))
 552                 return;
 553
 554         if (isr & IRQ_LINK_CHANGE)
 555                 ks8842_update_link_status(netdev, adapter);
 556
 557         if (isr & (IRQ_RX | IRQ_RX_ERROR))
 558                 ks8842_handle_rx(netdev, adapter);
 559
 560         if (isr & IRQ_TX)
 561                 ks8842_handle_tx(netdev, adapter);
 562
 563         if (isr & IRQ_RX_OVERRUN)
 564                 ks8842_handle_rx_overrun(netdev, adapter);
 565
 566         if (isr & IRQ_TX_STOPPED) {
 567                 ks8842_disable_tx(adapter);
 568                 ks8842_enable_tx(adapter);
 569         }
 570
 571         if (isr & IRQ_RX_STOPPED) {
 572                 ks8842_disable_rx(adapter);
 573                 ks8842_enable_rx(adapter);
 574         }
 575
 576         /* re-enable interrupts, put back the bank selection register */
 577         spin_lock_irqsave(&adapter->lock, flags);
 578         ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
 579         iowrite16(entry_bank, adapter->hw_addr + REG_SELECT_BANK);
 580         spin_unlock_irqrestore(&adapter->lock, flags);
 581 }
 582
 583 static irqreturn_t ks8842_irq(int irq, void *devid)
 584 {
 585         struct net_device *netdev = devid;
 586         struct ks8842_adapter *adapter = netdev_priv(netdev);
 587         u16 isr;
 588         u16 entry_bank = ioread16(adapter->hw_addr + REG_SELECT_BANK);
 589         irqreturn_t ret = IRQ_NONE;
 590
 591         isr = ks8842_read16(adapter, 18, REG_ISR);
 592         netdev_dbg(netdev, "%s - ISR: 0x%x\n", __func__, isr);
 593
 594         if (isr) {
 595                 /* disable IRQ */
 596                 ks8842_write16(adapter, 18, 0x00, REG_IER);
 597
 598                 /* schedule tasklet */
 599                 tasklet_schedule(&adapter->tasklet);
 600
 601                 ret = IRQ_HANDLED;
 602         }
 603
 604         iowrite16(entry_bank, adapter->hw_addr + REG_SELECT_BANK);
 605
 606         return ret;
 607 }
 608
 609
 610 /* Netdevice operations */
 611
 612 static int ks8842_open(struct net_device *netdev)
 613 {
 614         struct ks8842_adapter *adapter = netdev_priv(netdev);
 615         int err;
 616
 617         netdev_dbg(netdev, "%s - entry\n", __func__);
 618
 619         /* reset the HW */
 620         ks8842_reset_hw(adapter);
 621
 622         ks8842_write_mac_addr(adapter, netdev->dev_addr);
 623
 624         ks8842_update_link_status(netdev, adapter);
 625
 626         err = request_irq(adapter->irq, ks8842_irq, IRQF_SHARED, DRV_NAME,
 627                 netdev);
 628         if (err) {
 629                 pr_err("Failed to request IRQ: %d: %d\n", adapter->irq, err);
 630                 return err;
 631         }
 632
 633         return 0;
 634 }
 635
 636 static int ks8842_close(struct net_device *netdev)
 637 {
 638         struct ks8842_adapter *adapter = netdev_priv(netdev);
 639
 640         netdev_dbg(netdev, "%s - entry\n", __func__);
 641
 642         cancel_work_sync(&adapter->timeout_work);
 643
 644         /* free the irq */
 645         free_irq(adapter->irq, netdev);
 646
 647         /* disable the switch */
 648         ks8842_write16(adapter, 32, 0x0, REG_SW_ID_AND_ENABLE);
 649
 650         return 0;
 651 }
 652
 653 static netdev_tx_t ks8842_xmit_frame(struct sk_buff *skb,
 654                                      struct net_device *netdev)
 655 {
 656         int ret;
 657         struct ks8842_adapter *adapter = netdev_priv(netdev);
 658
 659         netdev_dbg(netdev, "%s: entry\n", __func__);
 660
 661         ret = ks8842_tx_frame(skb, netdev);
 662
 663         if (ks8842_tx_fifo_space(adapter) <  netdev->mtu + 8)
 664                 netif_stop_queue(netdev);
 665
 666         return ret;
 667 }
 668
 669 static int ks8842_set_mac(struct net_device *netdev, void *p)
 670 {
 671         struct ks8842_adapter *adapter = netdev_priv(netdev);
 672         struct sockaddr *addr = p;
 673         char *mac = (u8 *)addr->sa_data;
 674
 675         netdev_dbg(netdev, "%s: entry\n", __func__);
 676
 677         if (!is_valid_ether_addr(addr->sa_data))
 678                 return -EADDRNOTAVAIL;
 679
 680         memcpy(netdev->dev_addr, mac, netdev->addr_len);
 681
 682         ks8842_write_mac_addr(adapter, mac);
 683         return 0;
 684 }
 685
 686 static void ks8842_tx_timeout_work(struct work_struct *work)
 687 {
 688         struct ks8842_adapter *adapter =
 689                 container_of(work, struct ks8842_adapter, timeout_work);
 690         struct net_device *netdev = adapter->netdev;
 691         unsigned long flags;
 692
 693         netdev_dbg(netdev, "%s: entry\n", __func__);
 694
 695         spin_lock_irqsave(&adapter->lock, flags);
 696         /* disable interrupts */
 697         ks8842_write16(adapter, 18, 0, REG_IER);
 698         ks8842_write16(adapter, 18, 0xFFFF, REG_ISR);
 699
 700         netif_stop_queue(netdev);
 701
 702         spin_unlock_irqrestore(&adapter->lock, flags);
 703
 704         ks8842_reset_hw(adapter);
 705
 706         ks8842_write_mac_addr(adapter, netdev->dev_addr);
 707
 708         ks8842_update_link_status(netdev, adapter);
 709 }
 710
 711 static void ks8842_tx_timeout(struct net_device *netdev)
 712 {
 713         struct ks8842_adapter *adapter = netdev_priv(netdev);
 714
 715         netdev_dbg(netdev, "%s: entry\n", __func__);
 716
 717         schedule_work(&adapter->timeout_work);
 718 }
 719
 720 static const struct net_device_ops ks8842_netdev_ops = {
 721         .ndo_open               = ks8842_open,
 722         .ndo_stop               = ks8842_close,
 723         .ndo_start_xmit         = ks8842_xmit_frame,
 724         .ndo_set_mac_address    = ks8842_set_mac,
 725         .ndo_tx_timeout         = ks8842_tx_timeout,
 726         .ndo_validate_addr      = eth_validate_addr
 727 };
 728
 729 static const struct ethtool_ops ks8842_ethtool_ops = {
 730         .get_link               = ethtool_op_get_link,
 731 };
 732
 733 static int __devinit ks8842_probe(struct platform_device *pdev)
 734 {
 735         int err = -ENOMEM;
 736         struct resource *iomem;
 737         struct net_device *netdev;
 738         struct ks8842_adapter *adapter;
 739         struct ks8842_platform_data *pdata = pdev->dev.platform_data;
 740         u16 id;
 741         unsigned i;
 742
 743         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 744         if (!request_mem_region(iomem->start, resource_size(iomem), DRV_NAME))
 745                 goto err_mem_region;
 746
 747         netdev = alloc_etherdev(sizeof(struct ks8842_adapter));
 748         if (!netdev)
 749                 goto err_alloc_etherdev;
 750
 751         SET_NETDEV_DEV(netdev, &pdev->dev);
 752
 753         adapter = netdev_priv(netdev);
 754         adapter->netdev = netdev;
 755         INIT_WORK(&adapter->timeout_work, ks8842_tx_timeout_work);
 756         adapter->hw_addr = ioremap(iomem->start, resource_size(iomem));
 757         adapter->conf_flags = iomem->flags;
 758
 759         if (!adapter->hw_addr)
 760                 goto err_ioremap;
 761
 762         adapter->irq = platform_get_irq(pdev, 0);
 763         if (adapter->irq < 0) {
 764                 err = adapter->irq;
 765                 goto err_get_irq;
 766         }
 767
 768         tasklet_init(&adapter->tasklet, ks8842_tasklet, (unsigned long)netdev);
 769         spin_lock_init(&adapter->lock);
 770
 771         netdev->netdev_ops = &ks8842_netdev_ops;
 772         netdev->ethtool_ops = &ks8842_ethtool_ops;
 773
 774         /* Check if a mac address was given */
 775         i = netdev->addr_len;
 776         if (pdata) {
 777                 for (i = 0; i < netdev->addr_len; i++)
 778                         if (pdata->macaddr[i] != 0)
 779                                 break;
 780
 781                 if (i < netdev->addr_len)
 782                         /* an address was passed, use it */
 783                         memcpy(netdev->dev_addr, pdata->macaddr,
 784                                 netdev->addr_len);
 785         }
 786
 787         if (i == netdev->addr_len) {
 788                 ks8842_read_mac_addr(adapter, netdev->dev_addr);
 789
 790                 if (!is_valid_ether_addr(netdev->dev_addr))
 791                         random_ether_addr(netdev->dev_addr);
 792         }
 793
 794         id = ks8842_read16(adapter, 32, REG_SW_ID_AND_ENABLE);
 795
 796         strcpy(netdev->name, "eth%d");
 797         err = register_netdev(netdev);
 798         if (err)
 799                 goto err_register;
 800
 801         platform_set_drvdata(pdev, netdev);
 802
 803         pr_info("Found chip, family: 0x%x, id: 0x%x, rev: 0x%x\n",
 804                 (id >> 8) & 0xff, (id >> 4) & 0xf, (id >> 1) & 0x7);
 805
 806         return 0;
 807
 808 err_register:
 809 err_get_irq:
 810         iounmap(adapter->hw_addr);
 811 err_ioremap:
 812         free_netdev(netdev);
 813 err_alloc_etherdev:
 814         release_mem_region(iomem->start, resource_size(iomem));
 815 err_mem_region:
 816         return err;
 817 }
 818
 819 static int __devexit ks8842_remove(struct platform_device *pdev)
 820 {
 821         struct net_device *netdev = platform_get_drvdata(pdev);
 822         struct ks8842_adapter *adapter = netdev_priv(netdev);
 823         struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 824
 825         unregister_netdev(netdev);
 826         tasklet_kill(&adapter->tasklet);
 827         iounmap(adapter->hw_addr);
 828         free_netdev(netdev);
 829         release_mem_region(iomem->start, resource_size(iomem));
 830         platform_set_drvdata(pdev, NULL);
 831         return 0;
 832 }
 833
 834
 835 static struct platform_driver ks8842_platform_driver = {
 836         .driver = {
 837                 .name   = DRV_NAME,
 838                 .owner  = THIS_MODULE,
 839         },
 840         .probe          = ks8842_probe,
 841         .remove         = ks8842_remove,
 842 };
 843
 844 static int __init ks8842_init(void)
 845 {
 846         return platform_driver_register(&ks8842_platform_driver);
 847 }
 848
 849 static void __exit ks8842_exit(void)
 850 {
 851         platform_driver_unregister(&ks8842_platform_driver);
 852 }
 853
 854 module_init(ks8842_init);
 855 module_exit(ks8842_exit);
 856
 857 MODULE_DESCRIPTION("Timberdale KS8842 ethernet driver");
 858 MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
 859 MODULE_LICENSE("GPL v2");
 860 MODULE_ALIAS("platform:ks8842");
 861