1/* 2 * Micrel KS8695 (Centaur) Ethernet. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License as 6 * published by the Free Software Foundation; either version 2 of the 7 * License, or (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, but 10 * WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * General Public License for more details. 13 * 14 * Copyright 2008 Simtec Electronics 15 * Daniel Silverstone <dsilvers@simtec.co.uk> 16 * Vincent Sanders <vince@simtec.co.uk> 17 */ 18 19#include <linux/dma-mapping.h> 20#include <linux/module.h> 21#include <linux/ioport.h> 22#include <linux/netdevice.h> 23#include <linux/etherdevice.h> 24#include <linux/interrupt.h> 25#include <linux/skbuff.h> 26#include <linux/spinlock.h> 27#include <linux/crc32.h> 28#include <linux/mii.h> 29#include <linux/ethtool.h> 30#include <linux/delay.h> 31#include <linux/platform_device.h> 32#include <linux/irq.h> 33#include <linux/io.h> 34#include <linux/slab.h> 35 36#include <asm/irq.h> 37 38#include <mach/regs-switch.h> 39#include <mach/regs-misc.h> 40#include <asm/mach/irq.h> 41#include <mach/regs-irq.h> 42 43#include "ks8695net.h" 44 45#define MODULENAME "ks8695_ether" 46#define MODULEVERSION "1.02" 47 48/* 49 * Transmit and device reset timeout, default 5 seconds. 50 */ 51static int watchdog = 5000; 52 53/* Hardware structures */ 54 55/** 56 * struct rx_ring_desc - Receive descriptor ring element 57 * @status: The status of the descriptor element (E.g. who owns it) 58 * @length: The number of bytes in the block pointed to by data_ptr 59 * @data_ptr: The physical address of the data block to receive into 60 * @next_desc: The physical address of the next descriptor element. 61 */ 62struct rx_ring_desc { 63 __le32 status; 64 __le32 length; 65 __le32 data_ptr; 66 __le32 next_desc; 67}; 68 69/** 70 * struct tx_ring_desc - Transmit descriptor ring element 71 * @owner: Who owns the descriptor 72 * @status: The number of bytes in the block pointed to by data_ptr 73 * @data_ptr: The physical address of the data block to receive into 74 * @next_desc: The physical address of the next descriptor element. 75 */ 76struct tx_ring_desc { 77 __le32 owner; 78 __le32 status; 79 __le32 data_ptr; 80 __le32 next_desc; 81}; 82 83/** 84 * struct ks8695_skbuff - sk_buff wrapper for rx/tx rings. 85 * @skb: The buffer in the ring 86 * @dma_ptr: The mapped DMA pointer of the buffer 87 * @length: The number of bytes mapped to dma_ptr 88 */ 89struct ks8695_skbuff { 90 struct sk_buff *skb; 91 dma_addr_t dma_ptr; 92 u32 length; 93}; 94 95/* Private device structure */ 96 97#define MAX_TX_DESC 8 98#define MAX_TX_DESC_MASK 0x7 99#define MAX_RX_DESC 16 100#define MAX_RX_DESC_MASK 0xf 101 102/*napi_weight have better more than rx DMA buffers*/ 103#define NAPI_WEIGHT 64 104 105#define MAX_RXBUF_SIZE 0x700 106 107#define TX_RING_DMA_SIZE (sizeof(struct tx_ring_desc) * MAX_TX_DESC) 108#define RX_RING_DMA_SIZE (sizeof(struct rx_ring_desc) * MAX_RX_DESC) 109#define RING_DMA_SIZE (TX_RING_DMA_SIZE + RX_RING_DMA_SIZE) 110 111/** 112 * enum ks8695_dtype - Device type 113 * @KS8695_DTYPE_WAN: This device is a WAN interface 114 * @KS8695_DTYPE_LAN: This device is a LAN interface 115 * @KS8695_DTYPE_HPNA: This device is an HPNA interface 116 */ 117enum ks8695_dtype { 118 KS8695_DTYPE_WAN, 119 KS8695_DTYPE_LAN, 120 KS8695_DTYPE_HPNA, 121}; 122 123/** 124 * struct ks8695_priv - Private data for the KS8695 Ethernet 125 * @in_suspend: Flag to indicate if we're suspending/resuming 126 * @ndev: The net_device for this interface 127 * @dev: The platform device object for this interface 128 * @dtype: The type of this device 129 * @io_regs: The ioremapped registers for this interface 130 * @napi : Add support NAPI for Rx 131 * @rx_irq_name: The textual name of the RX IRQ from the platform data 132 * @tx_irq_name: The textual name of the TX IRQ from the platform data 133 * @link_irq_name: The textual name of the link IRQ from the 134 * platform data if available 135 * @rx_irq: The IRQ number for the RX IRQ 136 * @tx_irq: The IRQ number for the TX IRQ 137 * @link_irq: The IRQ number for the link IRQ if available 138 * @regs_req: The resource request for the registers region 139 * @phyiface_req: The resource request for the phy/switch region 140 * if available 141 * @phyiface_regs: The ioremapped registers for the phy/switch if available 142 * @ring_base: The base pointer of the dma coherent memory for the rings 143 * @ring_base_dma: The DMA mapped equivalent of ring_base 144 * @tx_ring: The pointer in ring_base of the TX ring 145 * @tx_ring_used: The number of slots in the TX ring which are occupied 146 * @tx_ring_next_slot: The next slot to fill in the TX ring 147 * @tx_ring_dma: The DMA mapped equivalent of tx_ring 148 * @tx_buffers: The sk_buff mappings for the TX ring 149 * @txq_lock: A lock to protect the tx_buffers tx_ring_used etc variables 150 * @rx_ring: The pointer in ring_base of the RX ring 151 * @rx_ring_dma: The DMA mapped equivalent of rx_ring 152 * @rx_buffers: The sk_buff mappings for the RX ring 153 * @next_rx_desc_read: The next RX descriptor to read from on IRQ 154 * @rx_lock: A lock to protect Rx irq function 155 * @msg_enable: The flags for which messages to emit 156 */ 157struct ks8695_priv { 158 int in_suspend; 159 struct net_device *ndev; 160 struct device *dev; 161 enum ks8695_dtype dtype; 162 void __iomem *io_regs; 163 164 struct napi_struct napi; 165 166 const char *rx_irq_name, *tx_irq_name, *link_irq_name; 167 int rx_irq, tx_irq, link_irq; 168 169 struct resource *regs_req, *phyiface_req; 170 void __iomem *phyiface_regs; 171 172 void *ring_base; 173 dma_addr_t ring_base_dma; 174 175 struct tx_ring_desc *tx_ring; 176 int tx_ring_used; 177 int tx_ring_next_slot; 178 dma_addr_t tx_ring_dma; 179 struct ks8695_skbuff tx_buffers[MAX_TX_DESC]; 180 spinlock_t txq_lock; 181 182 struct rx_ring_desc *rx_ring; 183 dma_addr_t rx_ring_dma; 184 struct ks8695_skbuff rx_buffers[MAX_RX_DESC]; 185 int next_rx_desc_read; 186 spinlock_t rx_lock; 187 188 int msg_enable; 189}; 190 191/* Register access */ 192 193/** 194 * ks8695_readreg - Read from a KS8695 ethernet register 195 * @ksp: The device to read from 196 * @reg: The register to read 197 */ 198static inline u32 199ks8695_readreg(struct ks8695_priv *ksp, int reg) 200{ 201 return readl(ksp->io_regs + reg); 202} 203 204/** 205 * ks8695_writereg - Write to a KS8695 ethernet register 206 * @ksp: The device to write to 207 * @reg: The register to write 208 * @value: The value to write to the register 209 */ 210static inline void 211ks8695_writereg(struct ks8695_priv *ksp, int reg, u32 value) 212{ 213 writel(value, ksp->io_regs + reg); 214} 215 216/* Utility functions */ 217 218/** 219 * ks8695_port_type - Retrieve port-type as user-friendly string 220 * @ksp: The device to return the type for 221 * 222 * Returns a string indicating which of the WAN, LAN or HPNA 223 * ports this device is likely to represent. 224 */ 225static const char * 226ks8695_port_type(struct ks8695_priv *ksp) 227{ 228 switch (ksp->dtype) { 229 case KS8695_DTYPE_LAN: 230 return "LAN"; 231 case KS8695_DTYPE_WAN: 232 return "WAN"; 233 case KS8695_DTYPE_HPNA: 234 return "HPNA"; 235 } 236 237 return "UNKNOWN"; 238} 239 240/** 241 * ks8695_update_mac - Update the MAC registers in the device 242 * @ksp: The device to update 243 * 244 * Updates the MAC registers in the KS8695 device from the address in the 245 * net_device structure associated with this interface. 246 */ 247static void 248ks8695_update_mac(struct ks8695_priv *ksp) 249{ 250 /* Update the HW with the MAC from the net_device */ 251 struct net_device *ndev = ksp->ndev; 252 u32 machigh, maclow; 253 254 maclow = ((ndev->dev_addr[2] << 24) | (ndev->dev_addr[3] << 16) | 255 (ndev->dev_addr[4] << 8) | (ndev->dev_addr[5] << 0)); 256 machigh = ((ndev->dev_addr[0] << 8) | (ndev->dev_addr[1] << 0)); 257 258 ks8695_writereg(ksp, KS8695_MAL, maclow); 259 ks8695_writereg(ksp, KS8695_MAH, machigh); 260 261} 262 263/** 264 * ks8695_refill_rxbuffers - Re-fill the RX buffer ring 265 * @ksp: The device to refill 266 * 267 * Iterates the RX ring of the device looking for empty slots. 268 * For each empty slot, we allocate and map a new SKB and give it 269 * to the hardware. 270 * This can be called from interrupt context safely. 271 */ 272static void 273ks8695_refill_rxbuffers(struct ks8695_priv *ksp) 274{ 275 /* Run around the RX ring, filling in any missing sk_buff's */ 276 int buff_n; 277 278 for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) { 279 if (!ksp->rx_buffers[buff_n].skb) { 280 struct sk_buff *skb = 281 netdev_alloc_skb(ksp->ndev, MAX_RXBUF_SIZE); 282 dma_addr_t mapping; 283 284 ksp->rx_buffers[buff_n].skb = skb; 285 if (skb == NULL) { 286 /* Failed to allocate one, perhaps 287 * we'll try again later. 288 */ 289 break; 290 } 291 292 mapping = dma_map_single(ksp->dev, skb->data, 293 MAX_RXBUF_SIZE, 294 DMA_FROM_DEVICE); 295 if (unlikely(dma_mapping_error(ksp->dev, mapping))) { 296 /* Failed to DMA map this SKB, try later */ 297 dev_kfree_skb_irq(skb); 298 ksp->rx_buffers[buff_n].skb = NULL; 299 break; 300 } 301 ksp->rx_buffers[buff_n].dma_ptr = mapping; 302 ksp->rx_buffers[buff_n].length = MAX_RXBUF_SIZE; 303 304 /* Record this into the DMA ring */ 305 ksp->rx_ring[buff_n].data_ptr = cpu_to_le32(mapping); 306 ksp->rx_ring[buff_n].length = 307 cpu_to_le32(MAX_RXBUF_SIZE); 308 309 wmb(); 310 311 /* And give ownership over to the hardware */ 312 ksp->rx_ring[buff_n].status = cpu_to_le32(RDES_OWN); 313 } 314 } 315} 316 317/* Maximum number of multicast addresses which the KS8695 HW supports */ 318#define KS8695_NR_ADDRESSES 16 319 320/** 321 * ks8695_init_partial_multicast - Init the mcast addr registers 322 * @ksp: The device to initialise 323 * @addr: The multicast address list to use 324 * @nr_addr: The number of addresses in the list 325 * 326 * This routine is a helper for ks8695_set_multicast - it writes 327 * the additional-address registers in the KS8695 ethernet device 328 * and cleans up any others left behind. 329 */ 330static void 331ks8695_init_partial_multicast(struct ks8695_priv *ksp, 332 struct net_device *ndev) 333{ 334 u32 low, high; 335 int i; 336 struct netdev_hw_addr *ha; 337 338 i = 0; 339 netdev_for_each_mc_addr(ha, ndev) { 340 /* Ran out of space in chip? */ 341 BUG_ON(i == KS8695_NR_ADDRESSES); 342 343 low = (ha->addr[2] << 24) | (ha->addr[3] << 16) | 344 (ha->addr[4] << 8) | (ha->addr[5]); 345 high = (ha->addr[0] << 8) | (ha->addr[1]); 346 347 ks8695_writereg(ksp, KS8695_AAL_(i), low); 348 ks8695_writereg(ksp, KS8695_AAH_(i), AAH_E | high); 349 i++; 350 } 351 352 /* Clear the remaining Additional Station Addresses */ 353 for (; i < KS8695_NR_ADDRESSES; i++) { 354 ks8695_writereg(ksp, KS8695_AAL_(i), 0); 355 ks8695_writereg(ksp, KS8695_AAH_(i), 0); 356 } 357} 358 359/* Interrupt handling */ 360 361/** 362 * ks8695_tx_irq - Transmit IRQ handler 363 * @irq: The IRQ which went off (ignored) 364 * @dev_id: The net_device for the interrupt 365 * 366 * Process the TX ring, clearing out any transmitted slots. 367 * Allows the net_device to pass us new packets once slots are 368 * freed. 369 */ 370static irqreturn_t 371ks8695_tx_irq(int irq, void *dev_id) 372{ 373 struct net_device *ndev = (struct net_device *)dev_id; 374 struct ks8695_priv *ksp = netdev_priv(ndev); 375 int buff_n; 376 377 for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) { 378 if (ksp->tx_buffers[buff_n].skb && 379 !(ksp->tx_ring[buff_n].owner & cpu_to_le32(TDES_OWN))) { 380 rmb(); 381 /* An SKB which is not owned by HW is present */ 382 /* Update the stats for the net_device */ 383 ndev->stats.tx_packets++; 384 ndev->stats.tx_bytes += ksp->tx_buffers[buff_n].length; 385 386 /* Free the packet from the ring */ 387 ksp->tx_ring[buff_n].data_ptr = 0; 388 389 /* Free the sk_buff */ 390 dma_unmap_single(ksp->dev, 391 ksp->tx_buffers[buff_n].dma_ptr, 392 ksp->tx_buffers[buff_n].length, 393 DMA_TO_DEVICE); 394 dev_kfree_skb_irq(ksp->tx_buffers[buff_n].skb); 395 ksp->tx_buffers[buff_n].skb = NULL; 396 ksp->tx_ring_used--; 397 } 398 } 399 400 netif_wake_queue(ndev); 401 402 return IRQ_HANDLED; 403} 404 405/** 406 * ks8695_get_rx_enable_bit - Get rx interrupt enable/status bit 407 * @ksp: Private data for the KS8695 Ethernet 408 * 409 * For KS8695 document: 410 * Interrupt Enable Register (offset 0xE204) 411 * Bit29 : WAN MAC Receive Interrupt Enable 412 * Bit16 : LAN MAC Receive Interrupt Enable 413 * Interrupt Status Register (Offset 0xF208) 414 * Bit29: WAN MAC Receive Status 415 * Bit16: LAN MAC Receive Status 416 * So, this Rx interrupt enable/status bit number is equal 417 * as Rx IRQ number. 418 */ 419static inline u32 ks8695_get_rx_enable_bit(struct ks8695_priv *ksp) 420{ 421 return ksp->rx_irq; 422} 423 424/** 425 * ks8695_rx_irq - Receive IRQ handler 426 * @irq: The IRQ which went off (ignored) 427 * @dev_id: The net_device for the interrupt 428 * 429 * Inform NAPI that packet reception needs to be scheduled 430 */ 431 432static irqreturn_t 433ks8695_rx_irq(int irq, void *dev_id) 434{ 435 struct net_device *ndev = (struct net_device *)dev_id; 436 struct ks8695_priv *ksp = netdev_priv(ndev); 437 438 spin_lock(&ksp->rx_lock); 439 440 if (napi_schedule_prep(&ksp->napi)) { 441 unsigned long status = readl(KS8695_IRQ_VA + KS8695_INTEN); 442 unsigned long mask_bit = 1 << ks8695_get_rx_enable_bit(ksp); 443 /*disable rx interrupt*/ 444 status &= ~mask_bit; 445 writel(status , KS8695_IRQ_VA + KS8695_INTEN); 446 __napi_schedule(&ksp->napi); 447 } 448 449 spin_unlock(&ksp->rx_lock); 450 return IRQ_HANDLED; 451} 452 453/** 454 * ks8695_rx - Receive packets called by NAPI poll method 455 * @ksp: Private data for the KS8695 Ethernet 456 * @budget: Number of packets allowed to process 457 */ 458static int ks8695_rx(struct ks8695_priv *ksp, int budget) 459{ 460 struct net_device *ndev = ksp->ndev; 461 struct sk_buff *skb; 462 int buff_n; 463 u32 flags; 464 int pktlen; 465 int received = 0; 466 467 buff_n = ksp->next_rx_desc_read; 468 while (received < budget 469 && ksp->rx_buffers[buff_n].skb 470 && (!(ksp->rx_ring[buff_n].status & 471 cpu_to_le32(RDES_OWN)))) { 472 rmb(); 473 flags = le32_to_cpu(ksp->rx_ring[buff_n].status); 474 475 /* Found an SKB which we own, this means we 476 * received a packet 477 */ 478 if ((flags & (RDES_FS | RDES_LS)) != 479 (RDES_FS | RDES_LS)) { 480 /* This packet is not the first and 481 * the last segment. Therefore it is 482 * a "spanning" packet and we can't 483 * handle it 484 */ 485 goto rx_failure; 486 } 487 488 if (flags & (RDES_ES | RDES_RE)) { 489 /* It's an error packet */ 490 ndev->stats.rx_errors++; 491 if (flags & RDES_TL) 492 ndev->stats.rx_length_errors++; 493 if (flags & RDES_RF) 494 ndev->stats.rx_length_errors++; 495 if (flags & RDES_CE) 496 ndev->stats.rx_crc_errors++; 497 if (flags & RDES_RE) 498 ndev->stats.rx_missed_errors++; 499 500 goto rx_failure; 501 } 502 503 pktlen = flags & RDES_FLEN; 504 pktlen -= 4; /* Drop the CRC */ 505 506 /* Retrieve the sk_buff */ 507 skb = ksp->rx_buffers[buff_n].skb; 508 509 /* Clear it from the ring */ 510 ksp->rx_buffers[buff_n].skb = NULL; 511 ksp->rx_ring[buff_n].data_ptr = 0; 512 513 /* Unmap the SKB */ 514 dma_unmap_single(ksp->dev, 515 ksp->rx_buffers[buff_n].dma_ptr, 516 ksp->rx_buffers[buff_n].length, 517 DMA_FROM_DEVICE); 518 519 /* Relinquish the SKB to the network layer */ 520 skb_put(skb, pktlen); 521 skb->protocol = eth_type_trans(skb, ndev); 522 netif_receive_skb(skb); 523 524 /* Record stats */ 525 ndev->stats.rx_packets++; 526 ndev->stats.rx_bytes += pktlen; 527 goto rx_finished; 528 529rx_failure: 530 /* This ring entry is an error, but we can 531 * re-use the skb 532 */ 533 /* Give the ring entry back to the hardware */ 534 ksp->rx_ring[buff_n].status = cpu_to_le32(RDES_OWN); 535rx_finished: 536 received++; 537 buff_n = (buff_n + 1) & MAX_RX_DESC_MASK; 538 } 539 540 /* And note which RX descriptor we last did */ 541 ksp->next_rx_desc_read = buff_n; 542 543 /* And refill the buffers */ 544 ks8695_refill_rxbuffers(ksp); 545 546 /* Kick the RX DMA engine, in case it became suspended */ 547 ks8695_writereg(ksp, KS8695_DRSC, 0); 548 549 return received; 550} 551 552 553/** 554 * ks8695_poll - Receive packet by NAPI poll method 555 * @ksp: Private data for the KS8695 Ethernet 556 * @budget: The remaining number packets for network subsystem 557 * 558 * Invoked by the network core when it requests for new 559 * packets from the driver 560 */ 561static int ks8695_poll(struct napi_struct *napi, int budget) 562{ 563 struct ks8695_priv *ksp = container_of(napi, struct ks8695_priv, napi); 564 unsigned long work_done; 565 566 unsigned long isr = readl(KS8695_IRQ_VA + KS8695_INTEN); 567 unsigned long mask_bit = 1 << ks8695_get_rx_enable_bit(ksp); 568 569 work_done = ks8695_rx(ksp, budget); 570 571 if (work_done < budget) { 572 unsigned long flags; 573 spin_lock_irqsave(&ksp->rx_lock, flags); 574 __napi_complete(napi); 575 /*enable rx interrupt*/ 576 writel(isr | mask_bit, KS8695_IRQ_VA + KS8695_INTEN); 577 spin_unlock_irqrestore(&ksp->rx_lock, flags); 578 } 579 return work_done; 580} 581 582/** 583 * ks8695_link_irq - Link change IRQ handler 584 * @irq: The IRQ which went off (ignored) 585 * @dev_id: The net_device for the interrupt 586 * 587 * The WAN interface can generate an IRQ when the link changes, 588 * report this to the net layer and the user. 589 */ 590static irqreturn_t 591ks8695_link_irq(int irq, void *dev_id) 592{ 593 struct net_device *ndev = (struct net_device *)dev_id; 594 struct ks8695_priv *ksp = netdev_priv(ndev); 595 u32 ctrl; 596 597 ctrl = readl(ksp->phyiface_regs + KS8695_WMC); 598 if (ctrl & WMC_WLS) { 599 netif_carrier_on(ndev); 600 if (netif_msg_link(ksp)) 601 dev_info(ksp->dev, 602 "%s: Link is now up (10%sMbps/%s-duplex)\n", 603 ndev->name, 604 (ctrl & WMC_WSS) ? "0" : "", 605 (ctrl & WMC_WDS) ? "Full" : "Half"); 606 } else { 607 netif_carrier_off(ndev); 608 if (netif_msg_link(ksp)) 609 dev_info(ksp->dev, "%s: Link is now down.\n", 610 ndev->name); 611 } 612 613 return IRQ_HANDLED; 614} 615 616 617/* KS8695 Device functions */ 618 619/** 620 * ks8695_reset - Reset a KS8695 ethernet interface 621 * @ksp: The interface to reset 622 * 623 * Perform an engine reset of the interface and re-program it 624 * with sensible defaults. 625 */ 626static void 627ks8695_reset(struct ks8695_priv *ksp) 628{ 629 int reset_timeout = watchdog; 630 /* Issue the reset via the TX DMA control register */ 631 ks8695_writereg(ksp, KS8695_DTXC, DTXC_TRST); 632 while (reset_timeout--) { 633 if (!(ks8695_readreg(ksp, KS8695_DTXC) & DTXC_TRST)) 634 break; 635 msleep(1); 636 } 637 638 if (reset_timeout < 0) { 639 dev_crit(ksp->dev, 640 "Timeout waiting for DMA engines to reset\n"); 641 /* And blithely carry on */ 642 } 643 644 /* Definitely wait long enough before attempting to program 645 * the engines 646 */ 647 msleep(10); 648 649 /* RX: unicast and broadcast */ 650 ks8695_writereg(ksp, KS8695_DRXC, DRXC_RU | DRXC_RB); 651 /* TX: pad and add CRC */ 652 ks8695_writereg(ksp, KS8695_DTXC, DTXC_TEP | DTXC_TAC); 653} 654 655/** 656 * ks8695_shutdown - Shut down a KS8695 ethernet interface 657 * @ksp: The interface to shut down 658 * 659 * This disables packet RX/TX, cleans up IRQs, drains the rings, 660 * and basically places the interface into a clean shutdown 661 * state. 662 */ 663static void 664ks8695_shutdown(struct ks8695_priv *ksp) 665{ 666 u32 ctrl; 667 int buff_n; 668 669 /* Disable packet transmission */ 670 ctrl = ks8695_readreg(ksp, KS8695_DTXC); 671 ks8695_writereg(ksp, KS8695_DTXC, ctrl & ~DTXC_TE); 672 673 /* Disable packet reception */ 674 ctrl = ks8695_readreg(ksp, KS8695_DRXC); 675 ks8695_writereg(ksp, KS8695_DRXC, ctrl & ~DRXC_RE); 676 677 /* Release the IRQs */ 678 free_irq(ksp->rx_irq, ksp->ndev); 679 free_irq(ksp->tx_irq, ksp->ndev); 680 if (ksp->link_irq != -1) 681 free_irq(ksp->link_irq, ksp->ndev); 682 683 /* Throw away any pending TX packets */ 684 for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) { 685 if (ksp->tx_buffers[buff_n].skb) { 686 /* Remove this SKB from the TX ring */ 687 ksp->tx_ring[buff_n].owner = 0; 688 ksp->tx_ring[buff_n].status = 0; 689 ksp->tx_ring[buff_n].data_ptr = 0; 690 691 /* Unmap and bin this SKB */ 692 dma_unmap_single(ksp->dev, 693 ksp->tx_buffers[buff_n].dma_ptr, 694 ksp->tx_buffers[buff_n].length, 695 DMA_TO_DEVICE); 696 dev_kfree_skb_irq(ksp->tx_buffers[buff_n].skb); 697 ksp->tx_buffers[buff_n].skb = NULL; 698 } 699 } 700 701 /* Purge the RX buffers */ 702 for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) { 703 if (ksp->rx_buffers[buff_n].skb) { 704 /* Remove the SKB from the RX ring */ 705 ksp->rx_ring[buff_n].status = 0; 706 ksp->rx_ring[buff_n].data_ptr = 0; 707 708 /* Unmap and bin the SKB */ 709 dma_unmap_single(ksp->dev, 710 ksp->rx_buffers[buff_n].dma_ptr, 711 ksp->rx_buffers[buff_n].length, 712 DMA_FROM_DEVICE); 713 dev_kfree_skb_irq(ksp->rx_buffers[buff_n].skb); 714 ksp->rx_buffers[buff_n].skb = NULL; 715 } 716 } 717} 718 719 720/** 721 * ks8695_setup_irq - IRQ setup helper function 722 * @irq: The IRQ number to claim 723 * @irq_name: The name to give the IRQ claimant 724 * @handler: The function to call to handle the IRQ 725 * @ndev: The net_device to pass in as the dev_id argument to the handler 726 * 727 * Return 0 on success. 728 */ 729static int 730ks8695_setup_irq(int irq, const char *irq_name, 731 irq_handler_t handler, struct net_device *ndev) 732{ 733 int ret; 734 735 ret = request_irq(irq, handler, IRQF_SHARED, irq_name, ndev); 736 737 if (ret) { 738 dev_err(&ndev->dev, "failure to request IRQ %d\n", irq); 739 return ret; 740 } 741 742 return 0; 743} 744 745/** 746 * ks8695_init_net - Initialise a KS8695 ethernet interface 747 * @ksp: The interface to initialise 748 * 749 * This routine fills the RX ring, initialises the DMA engines, 750 * allocates the IRQs and then starts the packet TX and RX 751 * engines. 752 */ 753static int 754ks8695_init_net(struct ks8695_priv *ksp) 755{ 756 int ret; 757 u32 ctrl; 758 759 ks8695_refill_rxbuffers(ksp); 760 761 /* Initialise the DMA engines */ 762 ks8695_writereg(ksp, KS8695_RDLB, (u32) ksp->rx_ring_dma); 763 ks8695_writereg(ksp, KS8695_TDLB, (u32) ksp->tx_ring_dma); 764 765 /* Request the IRQs */ 766 ret = ks8695_setup_irq(ksp->rx_irq, ksp->rx_irq_name, 767 ks8695_rx_irq, ksp->ndev); 768 if (ret) 769 return ret; 770 ret = ks8695_setup_irq(ksp->tx_irq, ksp->tx_irq_name, 771 ks8695_tx_irq, ksp->ndev); 772 if (ret) 773 return ret; 774 if (ksp->link_irq != -1) { 775 ret = ks8695_setup_irq(ksp->link_irq, ksp->link_irq_name, 776 ks8695_link_irq, ksp->ndev); 777 if (ret) 778 return ret; 779 } 780 781 /* Set up the ring indices */ 782 ksp->next_rx_desc_read = 0; 783 ksp->tx_ring_next_slot = 0; 784 ksp->tx_ring_used = 0; 785 786 /* Bring up transmission */ 787 ctrl = ks8695_readreg(ksp, KS8695_DTXC); 788 /* Enable packet transmission */ 789 ks8695_writereg(ksp, KS8695_DTXC, ctrl | DTXC_TE); 790 791 /* Bring up the reception */ 792 ctrl = ks8695_readreg(ksp, KS8695_DRXC); 793 /* Enable packet reception */ 794 ks8695_writereg(ksp, KS8695_DRXC, ctrl | DRXC_RE); 795 /* And start the DMA engine */ 796 ks8695_writereg(ksp, KS8695_DRSC, 0); 797 798 /* All done */ 799 return 0; 800} 801 802/** 803 * ks8695_release_device - HW resource release for KS8695 e-net 804 * @ksp: The device to be freed 805 * 806 * This unallocates io memory regions, dma-coherent regions etc 807 * which were allocated in ks8695_probe. 808 */ 809static void 810ks8695_release_device(struct ks8695_priv *ksp) 811{ 812 /* Unmap the registers */ 813 iounmap(ksp->io_regs); 814 if (ksp->phyiface_regs) 815 iounmap(ksp->phyiface_regs); 816 817 /* And release the request */ 818 release_resource(ksp->regs_req); 819 kfree(ksp->regs_req); 820 if (ksp->phyiface_req) { 821 release_resource(ksp->phyiface_req); 822 kfree(ksp->phyiface_req); 823 } 824 825 /* Free the ring buffers */ 826 dma_free_coherent(ksp->dev, RING_DMA_SIZE, 827 ksp->ring_base, ksp->ring_base_dma); 828} 829 830/* Ethtool support */ 831 832/** 833 * ks8695_get_msglevel - Get the messages enabled for emission 834 * @ndev: The network device to read from 835 */ 836static u32 837ks8695_get_msglevel(struct net_device *ndev) 838{ 839 struct ks8695_priv *ksp = netdev_priv(ndev); 840 841 return ksp->msg_enable; 842} 843 844/** 845 * ks8695_set_msglevel - Set the messages enabled for emission 846 * @ndev: The network device to configure 847 * @value: The messages to set for emission 848 */ 849static void 850ks8695_set_msglevel(struct net_device *ndev, u32 value) 851{ 852 struct ks8695_priv *ksp = netdev_priv(ndev); 853 854 ksp->msg_enable = value; 855} 856 857/** 858 * ks8695_wan_get_settings - Get device-specific settings. 859 * @ndev: The network device to read settings from 860 * @cmd: The ethtool structure to read into 861 */ 862static int 863ks8695_wan_get_settings(struct net_device *ndev, struct ethtool_cmd *cmd) 864{ 865 struct ks8695_priv *ksp = netdev_priv(ndev); 866 u32 ctrl; 867 868 /* All ports on the KS8695 support these... */ 869 cmd->supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | 870 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | 871 SUPPORTED_TP | SUPPORTED_MII); 872 cmd->transceiver = XCVR_INTERNAL; 873 874 cmd->advertising = ADVERTISED_TP | ADVERTISED_MII; 875 cmd->port = PORT_MII; 876 cmd->supported |= (SUPPORTED_Autoneg | SUPPORTED_Pause); 877 cmd->phy_address = 0; 878 879 ctrl = readl(ksp->phyiface_regs + KS8695_WMC); 880 if ((ctrl & WMC_WAND) == 0) { 881 /* auto-negotiation is enabled */ 882 cmd->advertising |= ADVERTISED_Autoneg; 883 if (ctrl & WMC_WANA100F) 884 cmd->advertising |= ADVERTISED_100baseT_Full; 885 if (ctrl & WMC_WANA100H) 886 cmd->advertising |= ADVERTISED_100baseT_Half; 887 if (ctrl & WMC_WANA10F) 888 cmd->advertising |= ADVERTISED_10baseT_Full; 889 if (ctrl & WMC_WANA10H) 890 cmd->advertising |= ADVERTISED_10baseT_Half; 891 if (ctrl & WMC_WANAP) 892 cmd->advertising |= ADVERTISED_Pause; 893 cmd->autoneg = AUTONEG_ENABLE; 894 895 ethtool_cmd_speed_set(cmd, 896 (ctrl & WMC_WSS) ? SPEED_100 : SPEED_10); 897 cmd->duplex = (ctrl & WMC_WDS) ? 898 DUPLEX_FULL : DUPLEX_HALF; 899 } else { 900 /* auto-negotiation is disabled */ 901 cmd->autoneg = AUTONEG_DISABLE; 902 903 ethtool_cmd_speed_set(cmd, ((ctrl & WMC_WANF100) ? 904 SPEED_100 : SPEED_10)); 905 cmd->duplex = (ctrl & WMC_WANFF) ? 906 DUPLEX_FULL : DUPLEX_HALF; 907 } 908 909 return 0; 910} 911 912/** 913 * ks8695_wan_set_settings - Set device-specific settings. 914 * @ndev: The network device to configure 915 * @cmd: The settings to configure 916 */ 917static int 918ks8695_wan_set_settings(struct net_device *ndev, struct ethtool_cmd *cmd) 919{ 920 struct ks8695_priv *ksp = netdev_priv(ndev); 921 u32 ctrl; 922 923 if ((cmd->speed != SPEED_10) && (cmd->speed != SPEED_100)) 924 return -EINVAL; 925 if ((cmd->duplex != DUPLEX_HALF) && (cmd->duplex != DUPLEX_FULL)) 926 return -EINVAL; 927 if (cmd->port != PORT_MII) 928 return -EINVAL; 929 if (cmd->transceiver != XCVR_INTERNAL) 930 return -EINVAL; 931 if ((cmd->autoneg != AUTONEG_DISABLE) && 932 (cmd->autoneg != AUTONEG_ENABLE)) 933 return -EINVAL; 934 935 if (cmd->autoneg == AUTONEG_ENABLE) { 936 if ((cmd->advertising & (ADVERTISED_10baseT_Half | 937 ADVERTISED_10baseT_Full | 938 ADVERTISED_100baseT_Half | 939 ADVERTISED_100baseT_Full)) == 0) 940 return -EINVAL; 941 942 ctrl = readl(ksp->phyiface_regs + KS8695_WMC); 943 944 ctrl &= ~(WMC_WAND | WMC_WANA100F | WMC_WANA100H | 945 WMC_WANA10F | WMC_WANA10H); 946 if (cmd->advertising & ADVERTISED_100baseT_Full) 947 ctrl |= WMC_WANA100F; 948 if (cmd->advertising & ADVERTISED_100baseT_Half) 949 ctrl |= WMC_WANA100H; 950 if (cmd->advertising & ADVERTISED_10baseT_Full) 951 ctrl |= WMC_WANA10F; 952 if (cmd->advertising & ADVERTISED_10baseT_Half) 953 ctrl |= WMC_WANA10H; 954 955 /* force a re-negotiation */ 956 ctrl |= WMC_WANR; 957 writel(ctrl, ksp->phyiface_regs + KS8695_WMC); 958 } else { 959 ctrl = readl(ksp->phyiface_regs + KS8695_WMC); 960 961 /* disable auto-negotiation */ 962 ctrl |= WMC_WAND; 963 ctrl &= ~(WMC_WANF100 | WMC_WANFF); 964 965 if (cmd->speed == SPEED_100) 966 ctrl |= WMC_WANF100; 967 if (cmd->duplex == DUPLEX_FULL) 968 ctrl |= WMC_WANFF; 969 970 writel(ctrl, ksp->phyiface_regs + KS8695_WMC); 971 } 972 973 return 0; 974} 975 976/** 977 * ks8695_wan_nwayreset - Restart the autonegotiation on the port. 978 * @ndev: The network device to restart autoneotiation on 979 */ 980static int 981ks8695_wan_nwayreset(struct net_device *ndev) 982{ 983 struct ks8695_priv *ksp = netdev_priv(ndev); 984 u32 ctrl; 985 986 ctrl = readl(ksp->phyiface_regs + KS8695_WMC); 987 988 if ((ctrl & WMC_WAND) == 0) 989 writel(ctrl | WMC_WANR, 990 ksp->phyiface_regs + KS8695_WMC); 991 else 992 /* auto-negotiation not enabled */ 993 return -EINVAL; 994 995 return 0; 996} 997 998/** 999 * ks8695_wan_get_pause - Retrieve network pause/flow-control advertising 1000 * @ndev: The device to retrieve settings from 1001 * @param: The structure to fill out with the information 1002 */ 1003static void 1004ks8695_wan_get_pause(struct net_device *ndev, struct ethtool_pauseparam *param) 1005{ 1006 struct ks8695_priv *ksp = netdev_priv(ndev); 1007 u32 ctrl; 1008 1009 ctrl = readl(ksp->phyiface_regs + KS8695_WMC); 1010 1011 /* advertise Pause */ 1012 param->autoneg = (ctrl & WMC_WANAP); 1013 1014 /* current Rx Flow-control */ 1015 ctrl = ks8695_readreg(ksp, KS8695_DRXC); 1016 param->rx_pause = (ctrl & DRXC_RFCE); 1017 1018 /* current Tx Flow-control */ 1019 ctrl = ks8695_readreg(ksp, KS8695_DTXC); 1020 param->tx_pause = (ctrl & DTXC_TFCE); 1021} 1022 1023/** 1024 * ks8695_get_drvinfo - Retrieve driver information 1025 * @ndev: The network device to retrieve info about 1026 * @info: The info structure to fill out. 1027 */ 1028static void 1029ks8695_get_drvinfo(struct net_device *ndev, struct ethtool_drvinfo *info) 1030{ 1031 strlcpy(info->driver, MODULENAME, sizeof(info->driver)); 1032 strlcpy(info->version, MODULEVERSION, sizeof(info->version)); 1033 strlcpy(info->bus_info, dev_name(ndev->dev.parent), 1034 sizeof(info->bus_info)); 1035} 1036 1037static const struct ethtool_ops ks8695_ethtool_ops = { 1038 .get_msglevel = ks8695_get_msglevel, 1039 .set_msglevel = ks8695_set_msglevel, 1040 .get_drvinfo = ks8695_get_drvinfo, 1041}; 1042 1043static const struct ethtool_ops ks8695_wan_ethtool_ops = { 1044 .get_msglevel = ks8695_get_msglevel, 1045 .set_msglevel = ks8695_set_msglevel, 1046 .get_settings = ks8695_wan_get_settings, 1047 .set_settings = ks8695_wan_set_settings, 1048 .nway_reset = ks8695_wan_nwayreset, 1049 .get_link = ethtool_op_get_link, 1050 .get_pauseparam = ks8695_wan_get_pause, 1051 .get_drvinfo = ks8695_get_drvinfo, 1052}; 1053 1054/* Network device interface functions */ 1055 1056/** 1057 * ks8695_set_mac - Update MAC in net dev and HW 1058 * @ndev: The network device to update 1059 * @addr: The new MAC address to set 1060 */ 1061static int 1062ks8695_set_mac(struct net_device *ndev, void *addr) 1063{ 1064 struct ks8695_priv *ksp = netdev_priv(ndev); 1065 struct sockaddr *address = addr; 1066 1067 if (!is_valid_ether_addr(address->sa_data)) 1068 return -EADDRNOTAVAIL; 1069 1070 memcpy(ndev->dev_addr, address->sa_data, ndev->addr_len); 1071 1072 ks8695_update_mac(ksp); 1073 1074 dev_dbg(ksp->dev, "%s: Updated MAC address to %pM\n", 1075 ndev->name, ndev->dev_addr); 1076 1077 return 0; 1078} 1079 1080/** 1081 * ks8695_set_multicast - Set up the multicast behaviour of the interface 1082 * @ndev: The net_device to configure 1083 * 1084 * This routine, called by the net layer, configures promiscuity 1085 * and multicast reception behaviour for the interface. 1086 */ 1087static void 1088ks8695_set_multicast(struct net_device *ndev) 1089{ 1090 struct ks8695_priv *ksp = netdev_priv(ndev); 1091 u32 ctrl; 1092 1093 ctrl = ks8695_readreg(ksp, KS8695_DRXC); 1094 1095 if (ndev->flags & IFF_PROMISC) { 1096 /* enable promiscuous mode */ 1097 ctrl |= DRXC_RA; 1098 } else if (ndev->flags & ~IFF_PROMISC) { 1099 /* disable promiscuous mode */ 1100 ctrl &= ~DRXC_RA; 1101 } 1102 1103 if (ndev->flags & IFF_ALLMULTI) { 1104 /* enable all multicast mode */ 1105 ctrl |= DRXC_RM; 1106 } else if (netdev_mc_count(ndev) > KS8695_NR_ADDRESSES) { 1107 /* more specific multicast addresses than can be 1108 * handled in hardware 1109 */ 1110 ctrl |= DRXC_RM; 1111 } else { 1112 /* enable specific multicasts */ 1113 ctrl &= ~DRXC_RM; 1114 ks8695_init_partial_multicast(ksp, ndev); 1115 } 1116 1117 ks8695_writereg(ksp, KS8695_DRXC, ctrl); 1118} 1119 1120/** 1121 * ks8695_timeout - Handle a network tx/rx timeout. 1122 * @ndev: The net_device which timed out. 1123 * 1124 * A network transaction timed out, reset the device. 1125 */ 1126static void 1127ks8695_timeout(struct net_device *ndev) 1128{ 1129 struct ks8695_priv *ksp = netdev_priv(ndev); 1130 1131 netif_stop_queue(ndev); 1132 ks8695_shutdown(ksp); 1133 1134 ks8695_reset(ksp); 1135 1136 ks8695_update_mac(ksp); 1137 1138 /* We ignore the return from this since it managed to init 1139 * before it probably will be okay to init again. 1140 */ 1141 ks8695_init_net(ksp); 1142 1143 /* Reconfigure promiscuity etc */ 1144 ks8695_set_multicast(ndev); 1145 1146 /* And start the TX queue once more */ 1147 netif_start_queue(ndev); 1148} 1149 1150/** 1151 * ks8695_start_xmit - Start a packet transmission 1152 * @skb: The packet to transmit 1153 * @ndev: The network device to send the packet on 1154 * 1155 * This routine, called by the net layer, takes ownership of the 1156 * sk_buff and adds it to the TX ring. It then kicks the TX DMA 1157 * engine to ensure transmission begins. 1158 */ 1159static int 1160ks8695_start_xmit(struct sk_buff *skb, struct net_device *ndev) 1161{ 1162 struct ks8695_priv *ksp = netdev_priv(ndev); 1163 int buff_n; 1164 dma_addr_t dmap; 1165 1166 spin_lock_irq(&ksp->txq_lock); 1167 1168 if (ksp->tx_ring_used == MAX_TX_DESC) { 1169 /* Somehow we got entered when we have no room */ 1170 spin_unlock_irq(&ksp->txq_lock); 1171 return NETDEV_TX_BUSY; 1172 } 1173 1174 buff_n = ksp->tx_ring_next_slot; 1175 1176 BUG_ON(ksp->tx_buffers[buff_n].skb); 1177 1178 dmap = dma_map_single(ksp->dev, skb->data, skb->len, DMA_TO_DEVICE); 1179 if (unlikely(dma_mapping_error(ksp->dev, dmap))) { 1180 /* Failed to DMA map this SKB, give it back for now */ 1181 spin_unlock_irq(&ksp->txq_lock); 1182 dev_dbg(ksp->dev, "%s: Could not map DMA memory for "\ 1183 "transmission, trying later\n", ndev->name); 1184 return NETDEV_TX_BUSY; 1185 } 1186 1187 ksp->tx_buffers[buff_n].dma_ptr = dmap; 1188 /* Mapped okay, store the buffer pointer and length for later */ 1189 ksp->tx_buffers[buff_n].skb = skb; 1190 ksp->tx_buffers[buff_n].length = skb->len; 1191 1192 /* Fill out the TX descriptor */ 1193 ksp->tx_ring[buff_n].data_ptr = 1194 cpu_to_le32(ksp->tx_buffers[buff_n].dma_ptr); 1195 ksp->tx_ring[buff_n].status = 1196 cpu_to_le32(TDES_IC | TDES_FS | TDES_LS | 1197 (skb->len & TDES_TBS)); 1198 1199 wmb(); 1200 1201 /* Hand it over to the hardware */ 1202 ksp->tx_ring[buff_n].owner = cpu_to_le32(TDES_OWN); 1203 1204 if (++ksp->tx_ring_used == MAX_TX_DESC) 1205 netif_stop_queue(ndev); 1206 1207 /* Kick the TX DMA in case it decided to go IDLE */ 1208 ks8695_writereg(ksp, KS8695_DTSC, 0); 1209 1210 /* And update the next ring slot */ 1211 ksp->tx_ring_next_slot = (buff_n + 1) & MAX_TX_DESC_MASK; 1212 1213 spin_unlock_irq(&ksp->txq_lock); 1214 return NETDEV_TX_OK; 1215} 1216 1217/** 1218 * ks8695_stop - Stop (shutdown) a KS8695 ethernet interface 1219 * @ndev: The net_device to stop 1220 * 1221 * This disables the TX queue and cleans up a KS8695 ethernet 1222 * device. 1223 */ 1224static int 1225ks8695_stop(struct net_device *ndev) 1226{ 1227 struct ks8695_priv *ksp = netdev_priv(ndev); 1228 1229 netif_stop_queue(ndev); 1230 napi_disable(&ksp->napi); 1231 1232 ks8695_shutdown(ksp); 1233 1234 return 0; 1235} 1236 1237/** 1238 * ks8695_open - Open (bring up) a KS8695 ethernet interface 1239 * @ndev: The net_device to open 1240 * 1241 * This resets, configures the MAC, initialises the RX ring and 1242 * DMA engines and starts the TX queue for a KS8695 ethernet 1243 * device. 1244 */ 1245static int 1246ks8695_open(struct net_device *ndev) 1247{ 1248 struct ks8695_priv *ksp = netdev_priv(ndev); 1249 int ret; 1250 1251 ks8695_reset(ksp); 1252 1253 ks8695_update_mac(ksp); 1254 1255 ret = ks8695_init_net(ksp); 1256 if (ret) { 1257 ks8695_shutdown(ksp); 1258 return ret; 1259 } 1260 1261 napi_enable(&ksp->napi); 1262 netif_start_queue(ndev); 1263 1264 return 0; 1265} 1266 1267/* Platform device driver */ 1268 1269/** 1270 * ks8695_init_switch - Init LAN switch to known good defaults. 1271 * @ksp: The device to initialise 1272 * 1273 * This initialises the LAN switch in the KS8695 to a known-good 1274 * set of defaults. 1275 */ 1276static void 1277ks8695_init_switch(struct ks8695_priv *ksp) 1278{ 1279 u32 ctrl; 1280 1281 /* Default value for SEC0 according to datasheet */ 1282 ctrl = 0x40819e00; 1283 1284 /* LED0 = Speed LED1 = Link/Activity */ 1285 ctrl &= ~(SEC0_LLED1S | SEC0_LLED0S); 1286 ctrl |= (LLED0S_LINK | LLED1S_LINK_ACTIVITY); 1287 1288 /* Enable Switch */ 1289 ctrl |= SEC0_ENABLE; 1290 1291 writel(ctrl, ksp->phyiface_regs + KS8695_SEC0); 1292 1293 /* Defaults for SEC1 */ 1294 writel(0x9400100, ksp->phyiface_regs + KS8695_SEC1); 1295} 1296 1297/** 1298 * ks8695_init_wan_phy - Initialise the WAN PHY to sensible defaults 1299 * @ksp: The device to initialise 1300 * 1301 * This initialises a KS8695's WAN phy to sensible values for 1302 * autonegotiation etc. 1303 */ 1304static void 1305ks8695_init_wan_phy(struct ks8695_priv *ksp) 1306{ 1307 u32 ctrl; 1308 1309 /* Support auto-negotiation */ 1310 ctrl = (WMC_WANAP | WMC_WANA100F | WMC_WANA100H | 1311 WMC_WANA10F | WMC_WANA10H); 1312 1313 /* LED0 = Activity , LED1 = Link */ 1314 ctrl |= (WLED0S_ACTIVITY | WLED1S_LINK); 1315 1316 /* Restart Auto-negotiation */ 1317 ctrl |= WMC_WANR; 1318 1319 writel(ctrl, ksp->phyiface_regs + KS8695_WMC); 1320 1321 writel(0, ksp->phyiface_regs + KS8695_WPPM); 1322 writel(0, ksp->phyiface_regs + KS8695_PPS); 1323} 1324 1325static const struct net_device_ops ks8695_netdev_ops = { 1326 .ndo_open = ks8695_open, 1327 .ndo_stop = ks8695_stop, 1328 .ndo_start_xmit = ks8695_start_xmit, 1329 .ndo_tx_timeout = ks8695_timeout, 1330 .ndo_set_mac_address = ks8695_set_mac, 1331 .ndo_validate_addr = eth_validate_addr, 1332 .ndo_set_rx_mode = ks8695_set_multicast, 1333}; 1334 1335/** 1336 * ks8695_probe - Probe and initialise a KS8695 ethernet interface 1337 * @pdev: The platform device to probe 1338 * 1339 * Initialise a KS8695 ethernet device from platform data. 1340 * 1341 * This driver requires at least one IORESOURCE_MEM for the 1342 * registers and two IORESOURCE_IRQ for the RX and TX IRQs 1343 * respectively. It can optionally take an additional 1344 * IORESOURCE_MEM for the switch or phy in the case of the lan or 1345 * wan ports, and an IORESOURCE_IRQ for the link IRQ for the wan 1346 * port. 1347 */ 1348static int 1349ks8695_probe(struct platform_device *pdev) 1350{ 1351 struct ks8695_priv *ksp; 1352 struct net_device *ndev; 1353 struct resource *regs_res, *phyiface_res; 1354 struct resource *rxirq_res, *txirq_res, *linkirq_res; 1355 int ret = 0; 1356 int buff_n; 1357 u32 machigh, maclow; 1358 1359 /* Initialise a net_device */ 1360 ndev = alloc_etherdev(sizeof(struct ks8695_priv)); 1361 if (!ndev) 1362 return -ENOMEM; 1363 1364 SET_NETDEV_DEV(ndev, &pdev->dev); 1365 1366 dev_dbg(&pdev->dev, "ks8695_probe() called\n"); 1367 1368 /* Configure our private structure a little */ 1369 ksp = netdev_priv(ndev); 1370 1371 ksp->dev = &pdev->dev; 1372 ksp->ndev = ndev; 1373 ksp->msg_enable = NETIF_MSG_LINK; 1374 1375 /* Retrieve resources */ 1376 regs_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1377 phyiface_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 1378 1379 rxirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 1380 txirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 1); 1381 linkirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 2); 1382 1383 if (!(regs_res && rxirq_res && txirq_res)) { 1384 dev_err(ksp->dev, "insufficient resources\n"); 1385 ret = -ENOENT; 1386 goto failure; 1387 } 1388 1389 ksp->regs_req = request_mem_region(regs_res->start, 1390 resource_size(regs_res), 1391 pdev->name); 1392 1393 if (!ksp->regs_req) { 1394 dev_err(ksp->dev, "cannot claim register space\n"); 1395 ret = -EIO; 1396 goto failure; 1397 } 1398 1399 ksp->io_regs = ioremap(regs_res->start, resource_size(regs_res)); 1400 1401 if (!ksp->io_regs) { 1402 dev_err(ksp->dev, "failed to ioremap registers\n"); 1403 ret = -EINVAL; 1404 goto failure; 1405 } 1406 1407 if (phyiface_res) { 1408 ksp->phyiface_req = 1409 request_mem_region(phyiface_res->start, 1410 resource_size(phyiface_res), 1411 phyiface_res->name); 1412 1413 if (!ksp->phyiface_req) { 1414 dev_err(ksp->dev, 1415 "cannot claim switch register space\n"); 1416 ret = -EIO; 1417 goto failure; 1418 } 1419 1420 ksp->phyiface_regs = ioremap(phyiface_res->start, 1421 resource_size(phyiface_res)); 1422 1423 if (!ksp->phyiface_regs) { 1424 dev_err(ksp->dev, 1425 "failed to ioremap switch registers\n"); 1426 ret = -EINVAL; 1427 goto failure; 1428 } 1429 } 1430 1431 ksp->rx_irq = rxirq_res->start; 1432 ksp->rx_irq_name = rxirq_res->name ? rxirq_res->name : "Ethernet RX"; 1433 ksp->tx_irq = txirq_res->start; 1434 ksp->tx_irq_name = txirq_res->name ? txirq_res->name : "Ethernet TX"; 1435 ksp->link_irq = (linkirq_res ? linkirq_res->start : -1); 1436 ksp->link_irq_name = (linkirq_res && linkirq_res->name) ? 1437 linkirq_res->name : "Ethernet Link"; 1438 1439 /* driver system setup */ 1440 ndev->netdev_ops = &ks8695_netdev_ops; 1441 ndev->watchdog_timeo = msecs_to_jiffies(watchdog); 1442 1443 netif_napi_add(ndev, &ksp->napi, ks8695_poll, NAPI_WEIGHT); 1444 1445 /* Retrieve the default MAC addr from the chip. */ 1446 /* The bootloader should have left it in there for us. */ 1447 1448 machigh = ks8695_readreg(ksp, KS8695_MAH); 1449 maclow = ks8695_readreg(ksp, KS8695_MAL); 1450 1451 ndev->dev_addr[0] = (machigh >> 8) & 0xFF; 1452 ndev->dev_addr[1] = machigh & 0xFF; 1453 ndev->dev_addr[2] = (maclow >> 24) & 0xFF; 1454 ndev->dev_addr[3] = (maclow >> 16) & 0xFF; 1455 ndev->dev_addr[4] = (maclow >> 8) & 0xFF; 1456 ndev->dev_addr[5] = maclow & 0xFF; 1457 1458 if (!is_valid_ether_addr(ndev->dev_addr)) 1459 dev_warn(ksp->dev, "%s: Invalid ethernet MAC address. Please " 1460 "set using ifconfig\n", ndev->name); 1461 1462 /* In order to be efficient memory-wise, we allocate both 1463 * rings in one go. 1464 */ 1465 ksp->ring_base = dma_alloc_coherent(&pdev->dev, RING_DMA_SIZE, 1466 &ksp->ring_base_dma, GFP_KERNEL); 1467 if (!ksp->ring_base) { 1468 ret = -ENOMEM; 1469 goto failure; 1470 } 1471 1472 /* Specify the TX DMA ring buffer */ 1473 ksp->tx_ring = ksp->ring_base; 1474 ksp->tx_ring_dma = ksp->ring_base_dma; 1475 1476 /* And initialise the queue's lock */ 1477 spin_lock_init(&ksp->txq_lock); 1478 spin_lock_init(&ksp->rx_lock); 1479 1480 /* Specify the RX DMA ring buffer */ 1481 ksp->rx_ring = ksp->ring_base + TX_RING_DMA_SIZE; 1482 ksp->rx_ring_dma = ksp->ring_base_dma + TX_RING_DMA_SIZE; 1483 1484 /* Zero the descriptor rings */ 1485 memset(ksp->tx_ring, 0, TX_RING_DMA_SIZE); 1486 memset(ksp->rx_ring, 0, RX_RING_DMA_SIZE); 1487 1488 /* Build the rings */ 1489 for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) { 1490 ksp->tx_ring[buff_n].next_desc = 1491 cpu_to_le32(ksp->tx_ring_dma + 1492 (sizeof(struct tx_ring_desc) * 1493 ((buff_n + 1) & MAX_TX_DESC_MASK))); 1494 } 1495 1496 for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) { 1497 ksp->rx_ring[buff_n].next_desc = 1498 cpu_to_le32(ksp->rx_ring_dma + 1499 (sizeof(struct rx_ring_desc) * 1500 ((buff_n + 1) & MAX_RX_DESC_MASK))); 1501 } 1502 1503 /* Initialise the port (physically) */ 1504 if (ksp->phyiface_regs && ksp->link_irq == -1) { 1505 ks8695_init_switch(ksp); 1506 ksp->dtype = KS8695_DTYPE_LAN; 1507 ndev->ethtool_ops = &ks8695_ethtool_ops; 1508 } else if (ksp->phyiface_regs && ksp->link_irq != -1) { 1509 ks8695_init_wan_phy(ksp); 1510 ksp->dtype = KS8695_DTYPE_WAN; 1511 ndev->ethtool_ops = &ks8695_wan_ethtool_ops; 1512 } else { 1513 /* No initialisation since HPNA does not have a PHY */ 1514 ksp->dtype = KS8695_DTYPE_HPNA; 1515 ndev->ethtool_ops = &ks8695_ethtool_ops; 1516 } 1517 1518 /* And bring up the net_device with the net core */ 1519 platform_set_drvdata(pdev, ndev); 1520 ret = register_netdev(ndev); 1521 1522 if (ret == 0) { 1523 dev_info(ksp->dev, "ks8695 ethernet (%s) MAC: %pM\n", 1524 ks8695_port_type(ksp), ndev->dev_addr); 1525 } else { 1526 /* Report the failure to register the net_device */ 1527 dev_err(ksp->dev, "ks8695net: failed to register netdev.\n"); 1528 goto failure; 1529 } 1530 1531 /* All is well */ 1532 return 0; 1533 1534 /* Error exit path */ 1535failure: 1536 ks8695_release_device(ksp); 1537 free_netdev(ndev); 1538 1539 return ret; 1540} 1541 1542/** 1543 * ks8695_drv_suspend - Suspend a KS8695 ethernet platform device. 1544 * @pdev: The device to suspend 1545 * @state: The suspend state 1546 * 1547 * This routine detaches and shuts down a KS8695 ethernet device. 1548 */ 1549static int 1550ks8695_drv_suspend(struct platform_device *pdev, pm_message_t state) 1551{ 1552 struct net_device *ndev = platform_get_drvdata(pdev); 1553 struct ks8695_priv *ksp = netdev_priv(ndev); 1554 1555 ksp->in_suspend = 1; 1556 1557 if (netif_running(ndev)) { 1558 netif_device_detach(ndev); 1559 ks8695_shutdown(ksp); 1560 } 1561 1562 return 0; 1563} 1564 1565/** 1566 * ks8695_drv_resume - Resume a KS8695 ethernet platform device. 1567 * @pdev: The device to resume 1568 * 1569 * This routine re-initialises and re-attaches a KS8695 ethernet 1570 * device. 1571 */ 1572static int 1573ks8695_drv_resume(struct platform_device *pdev) 1574{ 1575 struct net_device *ndev = platform_get_drvdata(pdev); 1576 struct ks8695_priv *ksp = netdev_priv(ndev); 1577 1578 if (netif_running(ndev)) { 1579 ks8695_reset(ksp); 1580 ks8695_init_net(ksp); 1581 ks8695_set_multicast(ndev); 1582 netif_device_attach(ndev); 1583 } 1584 1585 ksp->in_suspend = 0; 1586 1587 return 0; 1588} 1589 1590/** 1591 * ks8695_drv_remove - Remove a KS8695 net device on driver unload. 1592 * @pdev: The platform device to remove 1593 * 1594 * This unregisters and releases a KS8695 ethernet device. 1595 */ 1596static int 1597ks8695_drv_remove(struct platform_device *pdev) 1598{ 1599 struct net_device *ndev = platform_get_drvdata(pdev); 1600 struct ks8695_priv *ksp = netdev_priv(ndev); 1601 1602 netif_napi_del(&ksp->napi); 1603 1604 unregister_netdev(ndev); 1605 ks8695_release_device(ksp); 1606 free_netdev(ndev); 1607 1608 dev_dbg(&pdev->dev, "released and freed device\n"); 1609 return 0; 1610} 1611 1612static struct platform_driver ks8695_driver = { 1613 .driver = { 1614 .name = MODULENAME, 1615 .owner = THIS_MODULE, 1616 }, 1617 .probe = ks8695_probe, 1618 .remove = ks8695_drv_remove, 1619 .suspend = ks8695_drv_suspend, 1620 .resume = ks8695_drv_resume, 1621}; 1622 1623module_platform_driver(ks8695_driver); 1624 1625MODULE_AUTHOR("Simtec Electronics"); 1626MODULE_DESCRIPTION("Micrel KS8695 (Centaur) Ethernet driver"); 1627MODULE_LICENSE("GPL"); 1628MODULE_ALIAS("platform:" MODULENAME); 1629 1630module_param(watchdog, int, 0400); 1631MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds"); 1632