Merge branches 'topic/fixes', 'topic/cleanups' and 'topic/documentation' into for...
[linux-2.6] / drivers / net / arm / ks8695net.c
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  */
48 static 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  */
59 struct 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  */
73 struct 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  */
86 struct 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  */
111 enum 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  */
149 struct 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  */
187 static inline u32
188 ks8695_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  */
199 static inline void
200 ks8695_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  */
214 static const char *
215 ks8695_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  */
236 static void
237 ks8695_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  */
261 static void
262 ks8695_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  */
319 static void
320 ks8695_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  */
360 static irqreturn_t
361 ks8695_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  */
404 static irqreturn_t
405 ks8695_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
476 rx_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);
482 rx_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  */
516 static irqreturn_t
517 ks8695_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  */
552 static void
553 ks8695_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  */
589 static void
590 ks8695_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  */
655 static int
656 ks8695_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  */
679 static int
680 ks8695_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  */
735 static void
736 ks8695_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  */
762 static u32
763 ks8695_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  */
775 static void
776 ks8695_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  */
788 static int
789 ks8695_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  */
861 static int
862 ks8695_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  */
954 static int
955 ks8695_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  */
985 static u32
986 ks8695_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  */
1010 static void
1011 ks8695_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  */
1047 static int
1048 ks8695_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  */
1058 static void
1059 ks8695_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
1067 static 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  */
1086 static int
1087 ks8695_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  */
1112 static void
1113 ks8695_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  */
1152 static void
1153 ks8695_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  */
1185 static int
1186 ks8695_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  */
1252 static int
1253 ks8695_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  */
1273 static int
1274 ks8695_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  */
1306 static void __devinit
1307 ks8695_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  */
1334 static void __devinit
1335 ks8695_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
1355 static 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  */
1377 static int __devinit
1378 ks8695_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 */
1562 failure:
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  */
1576 static int
1577 ks8695_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  */
1599 static int
1600 ks8695_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  */
1623 static int __devexit
1624 ks8695_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
1639 static 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
1652 static int __init
1653 ks8695_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
1661 static void __exit
1662 ks8695_cleanup(void)
1663 {
1664         platform_driver_unregister(&ks8695_driver);
1665 }
1666
1667 module_init(ks8695_init);
1668 module_exit(ks8695_cleanup);
1669
1670 MODULE_AUTHOR("Simtec Electronics")
1671 MODULE_DESCRIPTION("Micrel KS8695 (Centaur) Ethernet driver");
1672 MODULE_LICENSE("GPL");
1673 MODULE_ALIAS("platform:" MODULENAME);
1674
1675 module_param(watchdog, int, 0400);
1676 MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds");