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