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