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