Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / drivers / net / ps3_gelic_net.c
1 /*
2  *  PS3 gelic network driver.
3  *
4  * Copyright (C) 2007 Sony Computer Entertainment Inc.
5  * Copyright 2006, 2007 Sony Corporation
6  *
7  * This file is based on: spider_net.c
8  *
9  * (C) Copyright IBM Corp. 2005
10  *
11  * Authors : Utz Bacher <utz.bacher@de.ibm.com>
12  *           Jens Osterkamp <Jens.Osterkamp@de.ibm.com>
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2, or (at your option)
17  * any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27  */
28
29 #undef DEBUG
30
31 #include <linux/kernel.h>
32 #include <linux/module.h>
33
34 #include <linux/etherdevice.h>
35 #include <linux/ethtool.h>
36 #include <linux/if_vlan.h>
37
38 #include <linux/in.h>
39 #include <linux/ip.h>
40 #include <linux/tcp.h>
41
42 #include <linux/dma-mapping.h>
43 #include <net/checksum.h>
44 #include <asm/firmware.h>
45 #include <asm/ps3.h>
46 #include <asm/lv1call.h>
47
48 #include "ps3_gelic_net.h"
49 #include "ps3_gelic_wireless.h"
50
51 #define DRV_NAME "Gelic Network Driver"
52 #define DRV_VERSION "2.0"
53
54 MODULE_AUTHOR("SCE Inc.");
55 MODULE_DESCRIPTION("Gelic Network driver");
56 MODULE_LICENSE("GPL");
57
58
59 static inline void gelic_card_enable_rxdmac(struct gelic_card *card);
60 static inline void gelic_card_disable_rxdmac(struct gelic_card *card);
61 static inline void gelic_card_disable_txdmac(struct gelic_card *card);
62 static inline void gelic_card_reset_chain(struct gelic_card *card,
63                                           struct gelic_descr_chain *chain,
64                                           struct gelic_descr *start_descr);
65
66 /* set irq_mask */
67 int gelic_card_set_irq_mask(struct gelic_card *card, u64 mask)
68 {
69         int status;
70
71         status = lv1_net_set_interrupt_mask(bus_id(card), dev_id(card),
72                                             mask, 0);
73         if (status)
74                 dev_info(ctodev(card),
75                          "%s failed %d\n", __func__, status);
76         return status;
77 }
78
79 static inline void gelic_card_rx_irq_on(struct gelic_card *card)
80 {
81         card->irq_mask |= GELIC_CARD_RXINT;
82         gelic_card_set_irq_mask(card, card->irq_mask);
83 }
84 static inline void gelic_card_rx_irq_off(struct gelic_card *card)
85 {
86         card->irq_mask &= ~GELIC_CARD_RXINT;
87         gelic_card_set_irq_mask(card, card->irq_mask);
88 }
89
90 static void gelic_card_get_ether_port_status(struct gelic_card *card,
91                                              int inform)
92 {
93         u64 v2;
94         struct net_device *ether_netdev;
95
96         lv1_net_control(bus_id(card), dev_id(card),
97                         GELIC_LV1_GET_ETH_PORT_STATUS,
98                         GELIC_LV1_VLAN_TX_ETHERNET_0, 0, 0,
99                         &card->ether_port_status, &v2);
100
101         if (inform) {
102                 ether_netdev = card->netdev[GELIC_PORT_ETHERNET_0];
103                 if (card->ether_port_status & GELIC_LV1_ETHER_LINK_UP)
104                         netif_carrier_on(ether_netdev);
105                 else
106                         netif_carrier_off(ether_netdev);
107         }
108 }
109
110 static int gelic_card_set_link_mode(struct gelic_card *card, int mode)
111 {
112         int status;
113         u64 v1, v2;
114
115         status = lv1_net_control(bus_id(card), dev_id(card),
116                                  GELIC_LV1_SET_NEGOTIATION_MODE,
117                                  GELIC_LV1_PHY_ETHERNET_0, mode, 0, &v1, &v2);
118         if (status) {
119                 pr_info("%s: failed setting negotiation mode %d\n", __func__,
120                         status);
121                 return -EBUSY;
122         }
123
124         card->link_mode = mode;
125         return 0;
126 }
127
128 void gelic_card_up(struct gelic_card *card)
129 {
130         pr_debug("%s: called\n", __func__);
131         mutex_lock(&card->updown_lock);
132         if (atomic_inc_return(&card->users) == 1) {
133                 pr_debug("%s: real do\n", __func__);
134                 /* enable irq */
135                 gelic_card_set_irq_mask(card, card->irq_mask);
136                 /* start rx */
137                 gelic_card_enable_rxdmac(card);
138
139                 napi_enable(&card->napi);
140         }
141         mutex_unlock(&card->updown_lock);
142         pr_debug("%s: done\n", __func__);
143 }
144
145 void gelic_card_down(struct gelic_card *card)
146 {
147         u64 mask;
148         pr_debug("%s: called\n", __func__);
149         mutex_lock(&card->updown_lock);
150         if (atomic_dec_if_positive(&card->users) == 0) {
151                 pr_debug("%s: real do\n", __func__);
152                 napi_disable(&card->napi);
153                 /*
154                  * Disable irq. Wireless interrupts will
155                  * be disabled later if any
156                  */
157                 mask = card->irq_mask & (GELIC_CARD_WLAN_EVENT_RECEIVED |
158                                          GELIC_CARD_WLAN_COMMAND_COMPLETED);
159                 gelic_card_set_irq_mask(card, mask);
160                 /* stop rx */
161                 gelic_card_disable_rxdmac(card);
162                 gelic_card_reset_chain(card, &card->rx_chain,
163                                        card->descr + GELIC_NET_TX_DESCRIPTORS);
164                 /* stop tx */
165                 gelic_card_disable_txdmac(card);
166         }
167         mutex_unlock(&card->updown_lock);
168         pr_debug("%s: done\n", __func__);
169 }
170
171 /**
172  * gelic_descr_get_status -- returns the status of a descriptor
173  * @descr: descriptor to look at
174  *
175  * returns the status as in the dmac_cmd_status field of the descriptor
176  */
177 static enum gelic_descr_dma_status
178 gelic_descr_get_status(struct gelic_descr *descr)
179 {
180         return be32_to_cpu(descr->dmac_cmd_status) & GELIC_DESCR_DMA_STAT_MASK;
181 }
182
183 /**
184  * gelic_descr_set_status -- sets the status of a descriptor
185  * @descr: descriptor to change
186  * @status: status to set in the descriptor
187  *
188  * changes the status to the specified value. Doesn't change other bits
189  * in the status
190  */
191 static void gelic_descr_set_status(struct gelic_descr *descr,
192                                    enum gelic_descr_dma_status status)
193 {
194         descr->dmac_cmd_status = cpu_to_be32(status |
195                         (be32_to_cpu(descr->dmac_cmd_status) &
196                          ~GELIC_DESCR_DMA_STAT_MASK));
197         /*
198          * dma_cmd_status field is used to indicate whether the descriptor
199          * is valid or not.
200          * Usually caller of this function wants to inform that to the
201          * hardware, so we assure here the hardware sees the change.
202          */
203         wmb();
204 }
205
206 /**
207  * gelic_card_free_chain - free descriptor chain
208  * @card: card structure
209  * @descr_in: address of desc
210  */
211 static void gelic_card_free_chain(struct gelic_card *card,
212                                   struct gelic_descr *descr_in)
213 {
214         struct gelic_descr *descr;
215
216         for (descr = descr_in; descr && descr->bus_addr; descr = descr->next) {
217                 dma_unmap_single(ctodev(card), descr->bus_addr,
218                                  GELIC_DESCR_SIZE, DMA_BIDIRECTIONAL);
219                 descr->bus_addr = 0;
220         }
221 }
222
223 /**
224  * gelic_card_init_chain - links descriptor chain
225  * @card: card structure
226  * @chain: address of chain
227  * @start_descr: address of descriptor array
228  * @no: number of descriptors
229  *
230  * we manage a circular list that mirrors the hardware structure,
231  * except that the hardware uses bus addresses.
232  *
233  * returns 0 on success, <0 on failure
234  */
235 static int __devinit gelic_card_init_chain(struct gelic_card *card,
236                                            struct gelic_descr_chain *chain,
237                                            struct gelic_descr *start_descr,
238                                            int no)
239 {
240         int i;
241         struct gelic_descr *descr;
242
243         descr = start_descr;
244         memset(descr, 0, sizeof(*descr) * no);
245
246         /* set up the hardware pointers in each descriptor */
247         for (i = 0; i < no; i++, descr++) {
248                 gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
249                 descr->bus_addr =
250                         dma_map_single(ctodev(card), descr,
251                                        GELIC_DESCR_SIZE,
252                                        DMA_BIDIRECTIONAL);
253
254                 if (!descr->bus_addr)
255                         goto iommu_error;
256
257                 descr->next = descr + 1;
258                 descr->prev = descr - 1;
259         }
260         /* make them as ring */
261         (descr - 1)->next = start_descr;
262         start_descr->prev = (descr - 1);
263
264         /* chain bus addr of hw descriptor */
265         descr = start_descr;
266         for (i = 0; i < no; i++, descr++) {
267                 descr->next_descr_addr = cpu_to_be32(descr->next->bus_addr);
268         }
269
270         chain->head = start_descr;
271         chain->tail = start_descr;
272
273         /* do not chain last hw descriptor */
274         (descr - 1)->next_descr_addr = 0;
275
276         return 0;
277
278 iommu_error:
279         for (i--, descr--; 0 <= i; i--, descr--)
280                 if (descr->bus_addr)
281                         dma_unmap_single(ctodev(card), descr->bus_addr,
282                                          GELIC_DESCR_SIZE,
283                                          DMA_BIDIRECTIONAL);
284         return -ENOMEM;
285 }
286
287 /**
288  * gelic_card_reset_chain - reset status of a descriptor chain
289  * @card: card structure
290  * @chain: address of chain
291  * @start_descr: address of descriptor array
292  *
293  * Reset the status of dma descriptors to ready state
294  * and re-initialize the hardware chain for later use
295  */
296 static void gelic_card_reset_chain(struct gelic_card *card,
297                                    struct gelic_descr_chain *chain,
298                                    struct gelic_descr *start_descr)
299 {
300         struct gelic_descr *descr;
301
302         for (descr = start_descr; start_descr != descr->next; descr++) {
303                 gelic_descr_set_status(descr, GELIC_DESCR_DMA_CARDOWNED);
304                 descr->next_descr_addr = cpu_to_be32(descr->next->bus_addr);
305         }
306
307         chain->head = start_descr;
308         chain->tail = (descr - 1);
309
310         (descr - 1)->next_descr_addr = 0;
311 }
312 /**
313  * gelic_descr_prepare_rx - reinitializes a rx descriptor
314  * @card: card structure
315  * @descr: descriptor to re-init
316  *
317  * return 0 on succes, <0 on failure
318  *
319  * allocates a new rx skb, iommu-maps it and attaches it to the descriptor.
320  * Activate the descriptor state-wise
321  */
322 static int gelic_descr_prepare_rx(struct gelic_card *card,
323                                   struct gelic_descr *descr)
324 {
325         int offset;
326         unsigned int bufsize;
327
328         if (gelic_descr_get_status(descr) !=  GELIC_DESCR_DMA_NOT_IN_USE)
329                 dev_info(ctodev(card), "%s: ERROR status \n", __func__);
330         /* we need to round up the buffer size to a multiple of 128 */
331         bufsize = ALIGN(GELIC_NET_MAX_MTU, GELIC_NET_RXBUF_ALIGN);
332
333         /* and we need to have it 128 byte aligned, therefore we allocate a
334          * bit more */
335         descr->skb = dev_alloc_skb(bufsize + GELIC_NET_RXBUF_ALIGN - 1);
336         if (!descr->skb) {
337                 descr->buf_addr = 0; /* tell DMAC don't touch memory */
338                 dev_info(ctodev(card),
339                          "%s:allocate skb failed !!\n", __func__);
340                 return -ENOMEM;
341         }
342         descr->buf_size = cpu_to_be32(bufsize);
343         descr->dmac_cmd_status = 0;
344         descr->result_size = 0;
345         descr->valid_size = 0;
346         descr->data_error = 0;
347
348         offset = ((unsigned long)descr->skb->data) &
349                 (GELIC_NET_RXBUF_ALIGN - 1);
350         if (offset)
351                 skb_reserve(descr->skb, GELIC_NET_RXBUF_ALIGN - offset);
352         /* io-mmu-map the skb */
353         descr->buf_addr = cpu_to_be32(dma_map_single(ctodev(card),
354                                                      descr->skb->data,
355                                                      GELIC_NET_MAX_MTU,
356                                                      DMA_FROM_DEVICE));
357         if (!descr->buf_addr) {
358                 dev_kfree_skb_any(descr->skb);
359                 descr->skb = NULL;
360                 dev_info(ctodev(card),
361                          "%s:Could not iommu-map rx buffer\n", __func__);
362                 gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
363                 return -ENOMEM;
364         } else {
365                 gelic_descr_set_status(descr, GELIC_DESCR_DMA_CARDOWNED);
366                 return 0;
367         }
368 }
369
370 /**
371  * gelic_card_release_rx_chain - free all skb of rx descr
372  * @card: card structure
373  *
374  */
375 static void gelic_card_release_rx_chain(struct gelic_card *card)
376 {
377         struct gelic_descr *descr = card->rx_chain.head;
378
379         do {
380                 if (descr->skb) {
381                         dma_unmap_single(ctodev(card),
382                                          be32_to_cpu(descr->buf_addr),
383                                          descr->skb->len,
384                                          DMA_FROM_DEVICE);
385                         descr->buf_addr = 0;
386                         dev_kfree_skb_any(descr->skb);
387                         descr->skb = NULL;
388                         gelic_descr_set_status(descr,
389                                                GELIC_DESCR_DMA_NOT_IN_USE);
390                 }
391                 descr = descr->next;
392         } while (descr != card->rx_chain.head);
393 }
394
395 /**
396  * gelic_card_fill_rx_chain - fills descriptors/skbs in the rx chains
397  * @card: card structure
398  *
399  * fills all descriptors in the rx chain: allocates skbs
400  * and iommu-maps them.
401  * returns 0 on success, < 0 on failure
402  */
403 static int gelic_card_fill_rx_chain(struct gelic_card *card)
404 {
405         struct gelic_descr *descr = card->rx_chain.head;
406         int ret;
407
408         do {
409                 if (!descr->skb) {
410                         ret = gelic_descr_prepare_rx(card, descr);
411                         if (ret)
412                                 goto rewind;
413                 }
414                 descr = descr->next;
415         } while (descr != card->rx_chain.head);
416
417         return 0;
418 rewind:
419         gelic_card_release_rx_chain(card);
420         return ret;
421 }
422
423 /**
424  * gelic_card_alloc_rx_skbs - allocates rx skbs in rx descriptor chains
425  * @card: card structure
426  *
427  * returns 0 on success, < 0 on failure
428  */
429 static int __devinit gelic_card_alloc_rx_skbs(struct gelic_card *card)
430 {
431         struct gelic_descr_chain *chain;
432         int ret;
433         chain = &card->rx_chain;
434         ret = gelic_card_fill_rx_chain(card);
435         chain->tail = card->rx_top->prev; /* point to the last */
436         return ret;
437 }
438
439 /**
440  * gelic_descr_release_tx - processes a used tx descriptor
441  * @card: card structure
442  * @descr: descriptor to release
443  *
444  * releases a used tx descriptor (unmapping, freeing of skb)
445  */
446 static void gelic_descr_release_tx(struct gelic_card *card,
447                                        struct gelic_descr *descr)
448 {
449         struct sk_buff *skb = descr->skb;
450
451         BUG_ON(!(be32_to_cpu(descr->data_status) & GELIC_DESCR_TX_TAIL));
452
453         dma_unmap_single(ctodev(card), be32_to_cpu(descr->buf_addr), skb->len,
454                          DMA_TO_DEVICE);
455         dev_kfree_skb_any(skb);
456
457         descr->buf_addr = 0;
458         descr->buf_size = 0;
459         descr->next_descr_addr = 0;
460         descr->result_size = 0;
461         descr->valid_size = 0;
462         descr->data_status = 0;
463         descr->data_error = 0;
464         descr->skb = NULL;
465
466         /* set descr status */
467         gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
468 }
469
470 static void gelic_card_stop_queues(struct gelic_card *card)
471 {
472         netif_stop_queue(card->netdev[GELIC_PORT_ETHERNET_0]);
473
474         if (card->netdev[GELIC_PORT_WIRELESS])
475                 netif_stop_queue(card->netdev[GELIC_PORT_WIRELESS]);
476 }
477 static void gelic_card_wake_queues(struct gelic_card *card)
478 {
479         netif_wake_queue(card->netdev[GELIC_PORT_ETHERNET_0]);
480
481         if (card->netdev[GELIC_PORT_WIRELESS])
482                 netif_wake_queue(card->netdev[GELIC_PORT_WIRELESS]);
483 }
484 /**
485  * gelic_card_release_tx_chain - processes sent tx descriptors
486  * @card: adapter structure
487  * @stop: net_stop sequence
488  *
489  * releases the tx descriptors that gelic has finished with
490  */
491 static void gelic_card_release_tx_chain(struct gelic_card *card, int stop)
492 {
493         struct gelic_descr_chain *tx_chain;
494         enum gelic_descr_dma_status status;
495         struct net_device *netdev;
496         int release = 0;
497
498         for (tx_chain = &card->tx_chain;
499              tx_chain->head != tx_chain->tail && tx_chain->tail;
500              tx_chain->tail = tx_chain->tail->next) {
501                 status = gelic_descr_get_status(tx_chain->tail);
502                 netdev = tx_chain->tail->skb->dev;
503                 switch (status) {
504                 case GELIC_DESCR_DMA_RESPONSE_ERROR:
505                 case GELIC_DESCR_DMA_PROTECTION_ERROR:
506                 case GELIC_DESCR_DMA_FORCE_END:
507                         if (printk_ratelimit())
508                                 dev_info(ctodev(card),
509                                          "%s: forcing end of tx descriptor " \
510                                          "with status %x\n",
511                                          __func__, status);
512                         netdev->stats.tx_dropped++;
513                         break;
514
515                 case GELIC_DESCR_DMA_COMPLETE:
516                         if (tx_chain->tail->skb) {
517                                 netdev->stats.tx_packets++;
518                                 netdev->stats.tx_bytes +=
519                                         tx_chain->tail->skb->len;
520                         }
521                         break;
522
523                 case GELIC_DESCR_DMA_CARDOWNED:
524                         /* pending tx request */
525                 default:
526                         /* any other value (== GELIC_DESCR_DMA_NOT_IN_USE) */
527                         if (!stop)
528                                 goto out;
529                 }
530                 gelic_descr_release_tx(card, tx_chain->tail);
531                 release ++;
532         }
533 out:
534         if (!stop && release)
535                 gelic_card_wake_queues(card);
536 }
537
538 /**
539  * gelic_net_set_multi - sets multicast addresses and promisc flags
540  * @netdev: interface device structure
541  *
542  * gelic_net_set_multi configures multicast addresses as needed for the
543  * netdev interface. It also sets up multicast, allmulti and promisc
544  * flags appropriately
545  */
546 void gelic_net_set_multi(struct net_device *netdev)
547 {
548         struct gelic_card *card = netdev_card(netdev);
549         struct dev_mc_list *mc;
550         unsigned int i;
551         uint8_t *p;
552         u64 addr;
553         int status;
554
555         /* clear all multicast address */
556         status = lv1_net_remove_multicast_address(bus_id(card), dev_id(card),
557                                                   0, 1);
558         if (status)
559                 dev_err(ctodev(card),
560                         "lv1_net_remove_multicast_address failed %d\n",
561                         status);
562         /* set broadcast address */
563         status = lv1_net_add_multicast_address(bus_id(card), dev_id(card),
564                                                GELIC_NET_BROADCAST_ADDR, 0);
565         if (status)
566                 dev_err(ctodev(card),
567                         "lv1_net_add_multicast_address failed, %d\n",
568                         status);
569
570         if ((netdev->flags & IFF_ALLMULTI) ||
571             (netdev->mc_count > GELIC_NET_MC_COUNT_MAX)) {
572                 status = lv1_net_add_multicast_address(bus_id(card),
573                                                        dev_id(card),
574                                                        0, 1);
575                 if (status)
576                         dev_err(ctodev(card),
577                                 "lv1_net_add_multicast_address failed, %d\n",
578                                 status);
579                 return;
580         }
581
582         /* set multicast addresses */
583         for (mc = netdev->mc_list; mc; mc = mc->next) {
584                 addr = 0;
585                 p = mc->dmi_addr;
586                 for (i = 0; i < ETH_ALEN; i++) {
587                         addr <<= 8;
588                         addr |= *p++;
589                 }
590                 status = lv1_net_add_multicast_address(bus_id(card),
591                                                        dev_id(card),
592                                                        addr, 0);
593                 if (status)
594                         dev_err(ctodev(card),
595                                 "lv1_net_add_multicast_address failed, %d\n",
596                                 status);
597         }
598 }
599
600 /**
601  * gelic_card_enable_rxdmac - enables the receive DMA controller
602  * @card: card structure
603  *
604  * gelic_card_enable_rxdmac enables the DMA controller by setting RX_DMA_EN
605  * in the GDADMACCNTR register
606  */
607 static inline void gelic_card_enable_rxdmac(struct gelic_card *card)
608 {
609         int status;
610
611 #ifdef DEBUG
612         if (gelic_descr_get_status(card->rx_chain.head) !=
613             GELIC_DESCR_DMA_CARDOWNED) {
614                 printk(KERN_ERR "%s: status=%x\n", __func__,
615                        be32_to_cpu(card->rx_chain.head->dmac_cmd_status));
616                 printk(KERN_ERR "%s: nextphy=%x\n", __func__,
617                        be32_to_cpu(card->rx_chain.head->next_descr_addr));
618                 printk(KERN_ERR "%s: head=%p\n", __func__,
619                        card->rx_chain.head);
620         }
621 #endif
622         status = lv1_net_start_rx_dma(bus_id(card), dev_id(card),
623                                 card->rx_chain.head->bus_addr, 0);
624         if (status)
625                 dev_info(ctodev(card),
626                          "lv1_net_start_rx_dma failed, status=%d\n", status);
627 }
628
629 /**
630  * gelic_card_disable_rxdmac - disables the receive DMA controller
631  * @card: card structure
632  *
633  * gelic_card_disable_rxdmac terminates processing on the DMA controller by
634  * turing off DMA and issueing a force end
635  */
636 static inline void gelic_card_disable_rxdmac(struct gelic_card *card)
637 {
638         int status;
639
640         /* this hvc blocks until the DMA in progress really stopped */
641         status = lv1_net_stop_rx_dma(bus_id(card), dev_id(card), 0);
642         if (status)
643                 dev_err(ctodev(card),
644                         "lv1_net_stop_rx_dma faild, %d\n", status);
645 }
646
647 /**
648  * gelic_card_disable_txdmac - disables the transmit DMA controller
649  * @card: card structure
650  *
651  * gelic_card_disable_txdmac terminates processing on the DMA controller by
652  * turing off DMA and issueing a force end
653  */
654 static inline void gelic_card_disable_txdmac(struct gelic_card *card)
655 {
656         int status;
657
658         /* this hvc blocks until the DMA in progress really stopped */
659         status = lv1_net_stop_tx_dma(bus_id(card), dev_id(card), 0);
660         if (status)
661                 dev_err(ctodev(card),
662                         "lv1_net_stop_tx_dma faild, status=%d\n", status);
663 }
664
665 /**
666  * gelic_net_stop - called upon ifconfig down
667  * @netdev: interface device structure
668  *
669  * always returns 0
670  */
671 int gelic_net_stop(struct net_device *netdev)
672 {
673         struct gelic_card *card;
674
675         pr_debug("%s: start\n", __func__);
676
677         netif_stop_queue(netdev);
678         netif_carrier_off(netdev);
679
680         card = netdev_card(netdev);
681         gelic_card_down(card);
682
683         pr_debug("%s: done\n", __func__);
684         return 0;
685 }
686
687 /**
688  * gelic_card_get_next_tx_descr - returns the next available tx descriptor
689  * @card: device structure to get descriptor from
690  *
691  * returns the address of the next descriptor, or NULL if not available.
692  */
693 static struct gelic_descr *
694 gelic_card_get_next_tx_descr(struct gelic_card *card)
695 {
696         if (!card->tx_chain.head)
697                 return NULL;
698         /*  see if the next descriptor is free */
699         if (card->tx_chain.tail != card->tx_chain.head->next &&
700             gelic_descr_get_status(card->tx_chain.head) ==
701             GELIC_DESCR_DMA_NOT_IN_USE)
702                 return card->tx_chain.head;
703         else
704                 return NULL;
705
706 }
707
708 /**
709  * gelic_net_set_txdescr_cmdstat - sets the tx descriptor command field
710  * @descr: descriptor structure to fill out
711  * @skb: packet to consider
712  *
713  * fills out the command and status field of the descriptor structure,
714  * depending on hardware checksum settings. This function assumes a wmb()
715  * has executed before.
716  */
717 static void gelic_descr_set_tx_cmdstat(struct gelic_descr *descr,
718                                        struct sk_buff *skb)
719 {
720         if (skb->ip_summed != CHECKSUM_PARTIAL)
721                 descr->dmac_cmd_status =
722                         cpu_to_be32(GELIC_DESCR_DMA_CMD_NO_CHKSUM |
723                                     GELIC_DESCR_TX_DMA_FRAME_TAIL);
724         else {
725                 /* is packet ip?
726                  * if yes: tcp? udp? */
727                 if (skb->protocol == htons(ETH_P_IP)) {
728                         if (ip_hdr(skb)->protocol == IPPROTO_TCP)
729                                 descr->dmac_cmd_status =
730                                 cpu_to_be32(GELIC_DESCR_DMA_CMD_TCP_CHKSUM |
731                                             GELIC_DESCR_TX_DMA_FRAME_TAIL);
732
733                         else if (ip_hdr(skb)->protocol == IPPROTO_UDP)
734                                 descr->dmac_cmd_status =
735                                 cpu_to_be32(GELIC_DESCR_DMA_CMD_UDP_CHKSUM |
736                                             GELIC_DESCR_TX_DMA_FRAME_TAIL);
737                         else    /*
738                                  * the stack should checksum non-tcp and non-udp
739                                  * packets on his own: NETIF_F_IP_CSUM
740                                  */
741                                 descr->dmac_cmd_status =
742                                 cpu_to_be32(GELIC_DESCR_DMA_CMD_NO_CHKSUM |
743                                             GELIC_DESCR_TX_DMA_FRAME_TAIL);
744                 }
745         }
746 }
747
748 static inline struct sk_buff *gelic_put_vlan_tag(struct sk_buff *skb,
749                                                  unsigned short tag)
750 {
751         struct vlan_ethhdr *veth;
752         static unsigned int c;
753
754         if (skb_headroom(skb) < VLAN_HLEN) {
755                 struct sk_buff *sk_tmp = skb;
756                 pr_debug("%s: hd=%d c=%ud\n", __func__, skb_headroom(skb), c);
757                 skb = skb_realloc_headroom(sk_tmp, VLAN_HLEN);
758                 if (!skb)
759                         return NULL;
760                 dev_kfree_skb_any(sk_tmp);
761         }
762         veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
763
764         /* Move the mac addresses to the top of buffer */
765         memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN);
766
767         veth->h_vlan_proto = cpu_to_be16(ETH_P_8021Q);
768         veth->h_vlan_TCI = htons(tag);
769
770         return skb;
771 }
772
773 /**
774  * gelic_descr_prepare_tx - setup a descriptor for sending packets
775  * @card: card structure
776  * @descr: descriptor structure
777  * @skb: packet to use
778  *
779  * returns 0 on success, <0 on failure.
780  *
781  */
782 static int gelic_descr_prepare_tx(struct gelic_card *card,
783                                   struct gelic_descr *descr,
784                                   struct sk_buff *skb)
785 {
786         dma_addr_t buf;
787
788         if (card->vlan_required) {
789                 struct sk_buff *skb_tmp;
790                 enum gelic_port_type type;
791
792                 type = netdev_port(skb->dev)->type;
793                 skb_tmp = gelic_put_vlan_tag(skb,
794                                              card->vlan[type].tx);
795                 if (!skb_tmp)
796                         return -ENOMEM;
797                 skb = skb_tmp;
798         }
799
800         buf = dma_map_single(ctodev(card), skb->data, skb->len, DMA_TO_DEVICE);
801
802         if (!buf) {
803                 dev_err(ctodev(card),
804                         "dma map 2 failed (%p, %i). Dropping packet\n",
805                         skb->data, skb->len);
806                 return -ENOMEM;
807         }
808
809         descr->buf_addr = cpu_to_be32(buf);
810         descr->buf_size = cpu_to_be32(skb->len);
811         descr->skb = skb;
812         descr->data_status = 0;
813         descr->next_descr_addr = 0; /* terminate hw descr */
814         gelic_descr_set_tx_cmdstat(descr, skb);
815
816         /* bump free descriptor pointer */
817         card->tx_chain.head = descr->next;
818         return 0;
819 }
820
821 /**
822  * gelic_card_kick_txdma - enables TX DMA processing
823  * @card: card structure
824  * @descr: descriptor address to enable TX processing at
825  *
826  */
827 static int gelic_card_kick_txdma(struct gelic_card *card,
828                                  struct gelic_descr *descr)
829 {
830         int status = 0;
831
832         if (card->tx_dma_progress)
833                 return 0;
834
835         if (gelic_descr_get_status(descr) == GELIC_DESCR_DMA_CARDOWNED) {
836                 card->tx_dma_progress = 1;
837                 status = lv1_net_start_tx_dma(bus_id(card), dev_id(card),
838                                               descr->bus_addr, 0);
839                 if (status)
840                         dev_info(ctodev(card), "lv1_net_start_txdma failed," \
841                                  "status=%d\n", status);
842         }
843         return status;
844 }
845
846 /**
847  * gelic_net_xmit - transmits a frame over the device
848  * @skb: packet to send out
849  * @netdev: interface device structure
850  *
851  * returns 0 on success, <0 on failure
852  */
853 int gelic_net_xmit(struct sk_buff *skb, struct net_device *netdev)
854 {
855         struct gelic_card *card = netdev_card(netdev);
856         struct gelic_descr *descr;
857         int result;
858         unsigned long flags;
859
860         spin_lock_irqsave(&card->tx_lock, flags);
861
862         gelic_card_release_tx_chain(card, 0);
863
864         descr = gelic_card_get_next_tx_descr(card);
865         if (!descr) {
866                 /*
867                  * no more descriptors free
868                  */
869                 gelic_card_stop_queues(card);
870                 spin_unlock_irqrestore(&card->tx_lock, flags);
871                 return NETDEV_TX_BUSY;
872         }
873
874         result = gelic_descr_prepare_tx(card, descr, skb);
875         if (result) {
876                 /*
877                  * DMA map failed.  As chanses are that failure
878                  * would continue, just release skb and return
879                  */
880                 netdev->stats.tx_dropped++;
881                 dev_kfree_skb_any(skb);
882                 spin_unlock_irqrestore(&card->tx_lock, flags);
883                 return NETDEV_TX_OK;
884         }
885         /*
886          * link this prepared descriptor to previous one
887          * to achieve high performance
888          */
889         descr->prev->next_descr_addr = cpu_to_be32(descr->bus_addr);
890         /*
891          * as hardware descriptor is modified in the above lines,
892          * ensure that the hardware sees it
893          */
894         wmb();
895         if (gelic_card_kick_txdma(card, descr)) {
896                 /*
897                  * kick failed.
898                  * release descriptors which were just prepared
899                  */
900                 netdev->stats.tx_dropped++;
901                 gelic_descr_release_tx(card, descr);
902                 gelic_descr_release_tx(card, descr->next);
903                 card->tx_chain.tail = descr->next->next;
904                 dev_info(ctodev(card), "%s: kick failure\n", __func__);
905         } else {
906                 /* OK, DMA started/reserved */
907                 netdev->trans_start = jiffies;
908         }
909
910         spin_unlock_irqrestore(&card->tx_lock, flags);
911         return NETDEV_TX_OK;
912 }
913
914 /**
915  * gelic_net_pass_skb_up - takes an skb from a descriptor and passes it on
916  * @descr: descriptor to process
917  * @card: card structure
918  * @netdev: net_device structure to be passed packet
919  *
920  * iommu-unmaps the skb, fills out skb structure and passes the data to the
921  * stack. The descriptor state is not changed.
922  */
923 static void gelic_net_pass_skb_up(struct gelic_descr *descr,
924                                   struct gelic_card *card,
925                                   struct net_device *netdev)
926
927 {
928         struct sk_buff *skb = descr->skb;
929         u32 data_status, data_error;
930
931         data_status = be32_to_cpu(descr->data_status);
932         data_error = be32_to_cpu(descr->data_error);
933         /* unmap skb buffer */
934         dma_unmap_single(ctodev(card), be32_to_cpu(descr->buf_addr),
935                          GELIC_NET_MAX_MTU,
936                          DMA_FROM_DEVICE);
937
938         skb_put(skb, be32_to_cpu(descr->valid_size)?
939                 be32_to_cpu(descr->valid_size) :
940                 be32_to_cpu(descr->result_size));
941         if (!descr->valid_size)
942                 dev_info(ctodev(card), "buffer full %x %x %x\n",
943                          be32_to_cpu(descr->result_size),
944                          be32_to_cpu(descr->buf_size),
945                          be32_to_cpu(descr->dmac_cmd_status));
946
947         descr->skb = NULL;
948         /*
949          * the card put 2 bytes vlan tag in front
950          * of the ethernet frame
951          */
952         skb_pull(skb, 2);
953         skb->protocol = eth_type_trans(skb, netdev);
954
955         /* checksum offload */
956         if (card->rx_csum) {
957                 if ((data_status & GELIC_DESCR_DATA_STATUS_CHK_MASK) &&
958                     (!(data_error & GELIC_DESCR_DATA_ERROR_CHK_MASK)))
959                         skb->ip_summed = CHECKSUM_UNNECESSARY;
960                 else
961                         skb->ip_summed = CHECKSUM_NONE;
962         } else
963                 skb->ip_summed = CHECKSUM_NONE;
964
965         /* update netdevice statistics */
966         netdev->stats.rx_packets++;
967         netdev->stats.rx_bytes += skb->len;
968
969         /* pass skb up to stack */
970         netif_receive_skb(skb);
971 }
972
973 /**
974  * gelic_card_decode_one_descr - processes an rx descriptor
975  * @card: card structure
976  *
977  * returns 1 if a packet has been sent to the stack, otherwise 0
978  *
979  * processes an rx descriptor by iommu-unmapping the data buffer and passing
980  * the packet up to the stack
981  */
982 static int gelic_card_decode_one_descr(struct gelic_card *card)
983 {
984         enum gelic_descr_dma_status status;
985         struct gelic_descr_chain *chain = &card->rx_chain;
986         struct gelic_descr *descr = chain->head;
987         struct net_device *netdev = NULL;
988         int dmac_chain_ended;
989
990         status = gelic_descr_get_status(descr);
991         /* is this descriptor terminated with next_descr == NULL? */
992         dmac_chain_ended =
993                 be32_to_cpu(descr->dmac_cmd_status) &
994                 GELIC_DESCR_RX_DMA_CHAIN_END;
995
996         if (status == GELIC_DESCR_DMA_CARDOWNED)
997                 return 0;
998
999         if (status == GELIC_DESCR_DMA_NOT_IN_USE) {
1000                 dev_dbg(ctodev(card), "dormant descr? %p\n", descr);
1001                 return 0;
1002         }
1003
1004         /* netdevice select */
1005         if (card->vlan_required) {
1006                 unsigned int i;
1007                 u16 vid;
1008                 vid = *(u16 *)(descr->skb->data) & VLAN_VID_MASK;
1009                 for (i = 0; i < GELIC_PORT_MAX; i++) {
1010                         if (card->vlan[i].rx == vid) {
1011                                 netdev = card->netdev[i];
1012                                 break;
1013                         }
1014                 };
1015                 if (GELIC_PORT_MAX <= i) {
1016                         pr_info("%s: unknown packet vid=%x\n", __func__, vid);
1017                         goto refill;
1018                 }
1019         } else
1020                 netdev = card->netdev[GELIC_PORT_ETHERNET_0];
1021
1022         if ((status == GELIC_DESCR_DMA_RESPONSE_ERROR) ||
1023             (status == GELIC_DESCR_DMA_PROTECTION_ERROR) ||
1024             (status == GELIC_DESCR_DMA_FORCE_END)) {
1025                 dev_info(ctodev(card), "dropping RX descriptor with state %x\n",
1026                          status);
1027                 netdev->stats.rx_dropped++;
1028                 goto refill;
1029         }
1030
1031         if (status == GELIC_DESCR_DMA_BUFFER_FULL) {
1032                 /*
1033                  * Buffer full would occur if and only if
1034                  * the frame length was longer than the size of this
1035                  * descriptor's buffer.  If the frame length was equal
1036                  * to or shorter than buffer'size, FRAME_END condition
1037                  * would occur.
1038                  * Anyway this frame was longer than the MTU,
1039                  * just drop it.
1040                  */
1041                 dev_info(ctodev(card), "overlength frame\n");
1042                 goto refill;
1043         }
1044         /*
1045          * descriptoers any other than FRAME_END here should
1046          * be treated as error.
1047          */
1048         if (status != GELIC_DESCR_DMA_FRAME_END) {
1049                 dev_dbg(ctodev(card), "RX descriptor with state %x\n",
1050                         status);
1051                 goto refill;
1052         }
1053
1054         /* ok, we've got a packet in descr */
1055         gelic_net_pass_skb_up(descr, card, netdev);
1056 refill:
1057         /*
1058          * So that always DMAC can see the end
1059          * of the descriptor chain to avoid
1060          * from unwanted DMAC overrun.
1061          */
1062         descr->next_descr_addr = 0;
1063
1064         /* change the descriptor state: */
1065         gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
1066
1067         /*
1068          * this call can fail, but for now, just leave this
1069          * decriptor without skb
1070          */
1071         gelic_descr_prepare_rx(card, descr);
1072
1073         chain->tail = descr;
1074         chain->head = descr->next;
1075
1076         /*
1077          * Set this descriptor the end of the chain.
1078          */
1079         descr->prev->next_descr_addr = cpu_to_be32(descr->bus_addr);
1080
1081         /*
1082          * If dmac chain was met, DMAC stopped.
1083          * thus re-enable it
1084          */
1085         if (dmac_chain_ended) {
1086                 card->rx_dma_restart_required = 1;
1087                 dev_dbg(ctodev(card), "reenable rx dma scheduled\n");
1088         }
1089
1090         return 1;
1091 }
1092
1093 /**
1094  * gelic_net_poll - NAPI poll function called by the stack to return packets
1095  * @napi: napi structure
1096  * @budget: number of packets we can pass to the stack at most
1097  *
1098  * returns the number of the processed packets
1099  *
1100  */
1101 static int gelic_net_poll(struct napi_struct *napi, int budget)
1102 {
1103         struct gelic_card *card = container_of(napi, struct gelic_card, napi);
1104         int packets_done = 0;
1105
1106         while (packets_done < budget) {
1107                 if (!gelic_card_decode_one_descr(card))
1108                         break;
1109
1110                 packets_done++;
1111         }
1112
1113         if (packets_done < budget) {
1114                 napi_complete(napi);
1115                 gelic_card_rx_irq_on(card);
1116         }
1117         return packets_done;
1118 }
1119 /**
1120  * gelic_net_change_mtu - changes the MTU of an interface
1121  * @netdev: interface device structure
1122  * @new_mtu: new MTU value
1123  *
1124  * returns 0 on success, <0 on failure
1125  */
1126 int gelic_net_change_mtu(struct net_device *netdev, int new_mtu)
1127 {
1128         /* no need to re-alloc skbs or so -- the max mtu is about 2.3k
1129          * and mtu is outbound only anyway */
1130         if ((new_mtu < GELIC_NET_MIN_MTU) ||
1131             (new_mtu > GELIC_NET_MAX_MTU)) {
1132                 return -EINVAL;
1133         }
1134         netdev->mtu = new_mtu;
1135         return 0;
1136 }
1137
1138 /**
1139  * gelic_card_interrupt - event handler for gelic_net
1140  */
1141 static irqreturn_t gelic_card_interrupt(int irq, void *ptr)
1142 {
1143         unsigned long flags;
1144         struct gelic_card *card = ptr;
1145         u64 status;
1146
1147         status = card->irq_status;
1148
1149         if (!status)
1150                 return IRQ_NONE;
1151
1152         status &= card->irq_mask;
1153
1154         if (card->rx_dma_restart_required) {
1155                 card->rx_dma_restart_required = 0;
1156                 gelic_card_enable_rxdmac(card);
1157         }
1158
1159         if (status & GELIC_CARD_RXINT) {
1160                 gelic_card_rx_irq_off(card);
1161                 napi_schedule(&card->napi);
1162         }
1163
1164         if (status & GELIC_CARD_TXINT) {
1165                 spin_lock_irqsave(&card->tx_lock, flags);
1166                 card->tx_dma_progress = 0;
1167                 gelic_card_release_tx_chain(card, 0);
1168                 /* kick outstanding tx descriptor if any */
1169                 gelic_card_kick_txdma(card, card->tx_chain.tail);
1170                 spin_unlock_irqrestore(&card->tx_lock, flags);
1171         }
1172
1173         /* ether port status changed */
1174         if (status & GELIC_CARD_PORT_STATUS_CHANGED)
1175                 gelic_card_get_ether_port_status(card, 1);
1176
1177 #ifdef CONFIG_GELIC_WIRELESS
1178         if (status & (GELIC_CARD_WLAN_EVENT_RECEIVED |
1179                       GELIC_CARD_WLAN_COMMAND_COMPLETED))
1180                 gelic_wl_interrupt(card->netdev[GELIC_PORT_WIRELESS], status);
1181 #endif
1182
1183         return IRQ_HANDLED;
1184 }
1185
1186 #ifdef CONFIG_NET_POLL_CONTROLLER
1187 /**
1188  * gelic_net_poll_controller - artificial interrupt for netconsole etc.
1189  * @netdev: interface device structure
1190  *
1191  * see Documentation/networking/netconsole.txt
1192  */
1193 void gelic_net_poll_controller(struct net_device *netdev)
1194 {
1195         struct gelic_card *card = netdev_card(netdev);
1196
1197         gelic_card_set_irq_mask(card, 0);
1198         gelic_card_interrupt(netdev->irq, netdev);
1199         gelic_card_set_irq_mask(card, card->irq_mask);
1200 }
1201 #endif /* CONFIG_NET_POLL_CONTROLLER */
1202
1203 /**
1204  * gelic_net_open - called upon ifonfig up
1205  * @netdev: interface device structure
1206  *
1207  * returns 0 on success, <0 on failure
1208  *
1209  * gelic_net_open allocates all the descriptors and memory needed for
1210  * operation, sets up multicast list and enables interrupts
1211  */
1212 int gelic_net_open(struct net_device *netdev)
1213 {
1214         struct gelic_card *card = netdev_card(netdev);
1215
1216         dev_dbg(ctodev(card), " -> %s %p\n", __func__, netdev);
1217
1218         gelic_card_up(card);
1219
1220         netif_start_queue(netdev);
1221         gelic_card_get_ether_port_status(card, 1);
1222
1223         dev_dbg(ctodev(card), " <- %s\n", __func__);
1224         return 0;
1225 }
1226
1227 void gelic_net_get_drvinfo(struct net_device *netdev,
1228                            struct ethtool_drvinfo *info)
1229 {
1230         strncpy(info->driver, DRV_NAME, sizeof(info->driver) - 1);
1231         strncpy(info->version, DRV_VERSION, sizeof(info->version) - 1);
1232 }
1233
1234 static int gelic_ether_get_settings(struct net_device *netdev,
1235                                     struct ethtool_cmd *cmd)
1236 {
1237         struct gelic_card *card = netdev_card(netdev);
1238
1239         gelic_card_get_ether_port_status(card, 0);
1240
1241         if (card->ether_port_status & GELIC_LV1_ETHER_FULL_DUPLEX)
1242                 cmd->duplex = DUPLEX_FULL;
1243         else
1244                 cmd->duplex = DUPLEX_HALF;
1245
1246         switch (card->ether_port_status & GELIC_LV1_ETHER_SPEED_MASK) {
1247         case GELIC_LV1_ETHER_SPEED_10:
1248                 cmd->speed = SPEED_10;
1249                 break;
1250         case GELIC_LV1_ETHER_SPEED_100:
1251                 cmd->speed = SPEED_100;
1252                 break;
1253         case GELIC_LV1_ETHER_SPEED_1000:
1254                 cmd->speed = SPEED_1000;
1255                 break;
1256         default:
1257                 pr_info("%s: speed unknown\n", __func__);
1258                 cmd->speed = SPEED_10;
1259                 break;
1260         }
1261
1262         cmd->supported = SUPPORTED_TP | SUPPORTED_Autoneg |
1263                         SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
1264                         SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
1265                         SUPPORTED_1000baseT_Full;
1266         cmd->advertising = cmd->supported;
1267         if (card->link_mode & GELIC_LV1_ETHER_AUTO_NEG) {
1268                 cmd->autoneg = AUTONEG_ENABLE;
1269         } else {
1270                 cmd->autoneg = AUTONEG_DISABLE;
1271                 cmd->advertising &= ~ADVERTISED_Autoneg;
1272         }
1273         cmd->port = PORT_TP;
1274
1275         return 0;
1276 }
1277
1278 static int gelic_ether_set_settings(struct net_device *netdev,
1279                                     struct ethtool_cmd *cmd)
1280 {
1281         struct gelic_card *card = netdev_card(netdev);
1282         u64 mode;
1283         int ret;
1284
1285         if (cmd->autoneg == AUTONEG_ENABLE) {
1286                 mode = GELIC_LV1_ETHER_AUTO_NEG;
1287         } else {
1288                 switch (cmd->speed) {
1289                 case SPEED_10:
1290                         mode = GELIC_LV1_ETHER_SPEED_10;
1291                         break;
1292                 case SPEED_100:
1293                         mode = GELIC_LV1_ETHER_SPEED_100;
1294                         break;
1295                 case SPEED_1000:
1296                         mode = GELIC_LV1_ETHER_SPEED_1000;
1297                         break;
1298                 default:
1299                         return -EINVAL;
1300                 }
1301                 if (cmd->duplex == DUPLEX_FULL)
1302                         mode |= GELIC_LV1_ETHER_FULL_DUPLEX;
1303                 else if (cmd->speed == SPEED_1000) {
1304                         pr_info("1000 half duplex is not supported.\n");
1305                         return -EINVAL;
1306                 }
1307         }
1308
1309         ret = gelic_card_set_link_mode(card, mode);
1310
1311         if (ret)
1312                 return ret;
1313
1314         return 0;
1315 }
1316
1317 u32 gelic_net_get_rx_csum(struct net_device *netdev)
1318 {
1319         struct gelic_card *card = netdev_card(netdev);
1320
1321         return card->rx_csum;
1322 }
1323
1324 int gelic_net_set_rx_csum(struct net_device *netdev, u32 data)
1325 {
1326         struct gelic_card *card = netdev_card(netdev);
1327
1328         card->rx_csum = data;
1329         return 0;
1330 }
1331
1332 static void gelic_net_get_wol(struct net_device *netdev,
1333                               struct ethtool_wolinfo *wol)
1334 {
1335         if (0 <= ps3_compare_firmware_version(2, 2, 0))
1336                 wol->supported = WAKE_MAGIC;
1337         else
1338                 wol->supported = 0;
1339
1340         wol->wolopts = ps3_sys_manager_get_wol() ? wol->supported : 0;
1341         memset(&wol->sopass, 0, sizeof(wol->sopass));
1342 }
1343 static int gelic_net_set_wol(struct net_device *netdev,
1344                              struct ethtool_wolinfo *wol)
1345 {
1346         int status;
1347         struct gelic_card *card;
1348         u64 v1, v2;
1349
1350         if (ps3_compare_firmware_version(2, 2, 0) < 0 ||
1351             !capable(CAP_NET_ADMIN))
1352                 return -EPERM;
1353
1354         if (wol->wolopts & ~WAKE_MAGIC)
1355                 return -EINVAL;
1356
1357         card = netdev_card(netdev);
1358         if (wol->wolopts & WAKE_MAGIC) {
1359                 status = lv1_net_control(bus_id(card), dev_id(card),
1360                                          GELIC_LV1_SET_WOL,
1361                                          GELIC_LV1_WOL_MAGIC_PACKET,
1362                                          0, GELIC_LV1_WOL_MP_ENABLE,
1363                                          &v1, &v2);
1364                 if (status) {
1365                         pr_info("%s: enabling WOL failed %d\n", __func__,
1366                                 status);
1367                         status = -EIO;
1368                         goto done;
1369                 }
1370                 status = lv1_net_control(bus_id(card), dev_id(card),
1371                                          GELIC_LV1_SET_WOL,
1372                                          GELIC_LV1_WOL_ADD_MATCH_ADDR,
1373                                          0, GELIC_LV1_WOL_MATCH_ALL,
1374                                          &v1, &v2);
1375                 if (!status)
1376                         ps3_sys_manager_set_wol(1);
1377                 else {
1378                         pr_info("%s: enabling WOL filter failed %d\n",
1379                                 __func__, status);
1380                         status = -EIO;
1381                 }
1382         } else {
1383                 status = lv1_net_control(bus_id(card), dev_id(card),
1384                                          GELIC_LV1_SET_WOL,
1385                                          GELIC_LV1_WOL_MAGIC_PACKET,
1386                                          0, GELIC_LV1_WOL_MP_DISABLE,
1387                                          &v1, &v2);
1388                 if (status) {
1389                         pr_info("%s: disabling WOL failed %d\n", __func__,
1390                                 status);
1391                         status = -EIO;
1392                         goto done;
1393                 }
1394                 status = lv1_net_control(bus_id(card), dev_id(card),
1395                                          GELIC_LV1_SET_WOL,
1396                                          GELIC_LV1_WOL_DELETE_MATCH_ADDR,
1397                                          0, GELIC_LV1_WOL_MATCH_ALL,
1398                                          &v1, &v2);
1399                 if (!status)
1400                         ps3_sys_manager_set_wol(0);
1401                 else {
1402                         pr_info("%s: removing WOL filter failed %d\n",
1403                                 __func__, status);
1404                         status = -EIO;
1405                 }
1406         }
1407 done:
1408         return status;
1409 }
1410
1411 static const struct ethtool_ops gelic_ether_ethtool_ops = {
1412         .get_drvinfo    = gelic_net_get_drvinfo,
1413         .get_settings   = gelic_ether_get_settings,
1414         .set_settings   = gelic_ether_set_settings,
1415         .get_link       = ethtool_op_get_link,
1416         .get_tx_csum    = ethtool_op_get_tx_csum,
1417         .set_tx_csum    = ethtool_op_set_tx_csum,
1418         .get_rx_csum    = gelic_net_get_rx_csum,
1419         .set_rx_csum    = gelic_net_set_rx_csum,
1420         .get_wol        = gelic_net_get_wol,
1421         .set_wol        = gelic_net_set_wol,
1422 };
1423
1424 /**
1425  * gelic_net_tx_timeout_task - task scheduled by the watchdog timeout
1426  * function (to be called not under interrupt status)
1427  * @work: work is context of tx timout task
1428  *
1429  * called as task when tx hangs, resets interface (if interface is up)
1430  */
1431 static void gelic_net_tx_timeout_task(struct work_struct *work)
1432 {
1433         struct gelic_card *card =
1434                 container_of(work, struct gelic_card, tx_timeout_task);
1435         struct net_device *netdev = card->netdev[GELIC_PORT_ETHERNET_0];
1436
1437         dev_info(ctodev(card), "%s:Timed out. Restarting... \n", __func__);
1438
1439         if (!(netdev->flags & IFF_UP))
1440                 goto out;
1441
1442         netif_device_detach(netdev);
1443         gelic_net_stop(netdev);
1444
1445         gelic_net_open(netdev);
1446         netif_device_attach(netdev);
1447
1448 out:
1449         atomic_dec(&card->tx_timeout_task_counter);
1450 }
1451
1452 /**
1453  * gelic_net_tx_timeout - called when the tx timeout watchdog kicks in.
1454  * @netdev: interface device structure
1455  *
1456  * called, if tx hangs. Schedules a task that resets the interface
1457  */
1458 void gelic_net_tx_timeout(struct net_device *netdev)
1459 {
1460         struct gelic_card *card;
1461
1462         card = netdev_card(netdev);
1463         atomic_inc(&card->tx_timeout_task_counter);
1464         if (netdev->flags & IFF_UP)
1465                 schedule_work(&card->tx_timeout_task);
1466         else
1467                 atomic_dec(&card->tx_timeout_task_counter);
1468 }
1469
1470 static const struct net_device_ops gelic_netdevice_ops = {
1471         .ndo_open = gelic_net_open,
1472         .ndo_stop = gelic_net_stop,
1473         .ndo_start_xmit = gelic_net_xmit,
1474         .ndo_set_multicast_list = gelic_net_set_multi,
1475         .ndo_change_mtu = gelic_net_change_mtu,
1476         .ndo_tx_timeout = gelic_net_tx_timeout,
1477         .ndo_set_mac_address = eth_mac_addr,
1478         .ndo_validate_addr = eth_validate_addr,
1479 #ifdef CONFIG_NET_POLL_CONTROLLER
1480         .ndo_poll_controller = gelic_net_poll_controller,
1481 #endif
1482 };
1483
1484 /**
1485  * gelic_ether_setup_netdev_ops - initialization of net_device operations
1486  * @netdev: net_device structure
1487  *
1488  * fills out function pointers in the net_device structure
1489  */
1490 static void __devinit gelic_ether_setup_netdev_ops(struct net_device *netdev,
1491                                                    struct napi_struct *napi)
1492 {
1493         netdev->watchdog_timeo = GELIC_NET_WATCHDOG_TIMEOUT;
1494         /* NAPI */
1495         netif_napi_add(netdev, napi,
1496                        gelic_net_poll, GELIC_NET_NAPI_WEIGHT);
1497         netdev->ethtool_ops = &gelic_ether_ethtool_ops;
1498         netdev->netdev_ops = &gelic_netdevice_ops;
1499 }
1500
1501 /**
1502  * gelic_ether_setup_netdev - initialization of net_device
1503  * @netdev: net_device structure
1504  * @card: card structure
1505  *
1506  * Returns 0 on success or <0 on failure
1507  *
1508  * gelic_ether_setup_netdev initializes the net_device structure
1509  * and register it.
1510  **/
1511 int __devinit gelic_net_setup_netdev(struct net_device *netdev,
1512                                      struct gelic_card *card)
1513 {
1514         int status;
1515         u64 v1, v2;
1516
1517         netdev->features = NETIF_F_IP_CSUM;
1518
1519         status = lv1_net_control(bus_id(card), dev_id(card),
1520                                  GELIC_LV1_GET_MAC_ADDRESS,
1521                                  0, 0, 0, &v1, &v2);
1522         v1 <<= 16;
1523         if (status || !is_valid_ether_addr((u8 *)&v1)) {
1524                 dev_info(ctodev(card),
1525                          "%s:lv1_net_control GET_MAC_ADDR failed %d\n",
1526                          __func__, status);
1527                 return -EINVAL;
1528         }
1529         memcpy(netdev->dev_addr, &v1, ETH_ALEN);
1530
1531         if (card->vlan_required) {
1532                 netdev->hard_header_len += VLAN_HLEN;
1533                 /*
1534                  * As vlan is internally used,
1535                  * we can not receive vlan packets
1536                  */
1537                 netdev->features |= NETIF_F_VLAN_CHALLENGED;
1538         }
1539
1540         status = register_netdev(netdev);
1541         if (status) {
1542                 dev_err(ctodev(card), "%s:Couldn't register %s %d\n",
1543                         __func__, netdev->name, status);
1544                 return status;
1545         }
1546         dev_info(ctodev(card), "%s: MAC addr %pM\n",
1547                  netdev->name, netdev->dev_addr);
1548
1549         return 0;
1550 }
1551
1552 /**
1553  * gelic_alloc_card_net - allocates net_device and card structure
1554  *
1555  * returns the card structure or NULL in case of errors
1556  *
1557  * the card and net_device structures are linked to each other
1558  */
1559 #define GELIC_ALIGN (32)
1560 static struct gelic_card * __devinit gelic_alloc_card_net(struct net_device **netdev)
1561 {
1562         struct gelic_card *card;
1563         struct gelic_port *port;
1564         void *p;
1565         size_t alloc_size;
1566         /*
1567          * gelic requires dma descriptor is 32 bytes aligned and
1568          * the hypervisor requires irq_status is 8 bytes aligned.
1569          */
1570         BUILD_BUG_ON(offsetof(struct gelic_card, irq_status) % 8);
1571         BUILD_BUG_ON(offsetof(struct gelic_card, descr) % 32);
1572         alloc_size =
1573                 sizeof(struct gelic_card) +
1574                 sizeof(struct gelic_descr) * GELIC_NET_RX_DESCRIPTORS +
1575                 sizeof(struct gelic_descr) * GELIC_NET_TX_DESCRIPTORS +
1576                 GELIC_ALIGN - 1;
1577
1578         p  = kzalloc(alloc_size, GFP_KERNEL);
1579         if (!p)
1580                 return NULL;
1581         card = PTR_ALIGN(p, GELIC_ALIGN);
1582         card->unalign = p;
1583
1584         /*
1585          * alloc netdev
1586          */
1587         *netdev = alloc_etherdev(sizeof(struct gelic_port));
1588         if (!netdev) {
1589                 kfree(card->unalign);
1590                 return NULL;
1591         }
1592         port = netdev_priv(*netdev);
1593
1594         /* gelic_port */
1595         port->netdev = *netdev;
1596         port->card = card;
1597         port->type = GELIC_PORT_ETHERNET_0;
1598
1599         /* gelic_card */
1600         card->netdev[GELIC_PORT_ETHERNET_0] = *netdev;
1601
1602         INIT_WORK(&card->tx_timeout_task, gelic_net_tx_timeout_task);
1603         init_waitqueue_head(&card->waitq);
1604         atomic_set(&card->tx_timeout_task_counter, 0);
1605         mutex_init(&card->updown_lock);
1606         atomic_set(&card->users, 0);
1607
1608         return card;
1609 }
1610
1611 static void __devinit gelic_card_get_vlan_info(struct gelic_card *card)
1612 {
1613         u64 v1, v2;
1614         int status;
1615         unsigned int i;
1616         struct {
1617                 int tx;
1618                 int rx;
1619         } vlan_id_ix[2] = {
1620                 [GELIC_PORT_ETHERNET_0] = {
1621                         .tx = GELIC_LV1_VLAN_TX_ETHERNET_0,
1622                         .rx = GELIC_LV1_VLAN_RX_ETHERNET_0
1623                 },
1624                 [GELIC_PORT_WIRELESS] = {
1625                         .tx = GELIC_LV1_VLAN_TX_WIRELESS,
1626                         .rx = GELIC_LV1_VLAN_RX_WIRELESS
1627                 }
1628         };
1629
1630         for (i = 0; i < ARRAY_SIZE(vlan_id_ix); i++) {
1631                 /* tx tag */
1632                 status = lv1_net_control(bus_id(card), dev_id(card),
1633                                          GELIC_LV1_GET_VLAN_ID,
1634                                          vlan_id_ix[i].tx,
1635                                          0, 0, &v1, &v2);
1636                 if (status || !v1) {
1637                         if (status != LV1_NO_ENTRY)
1638                                 dev_dbg(ctodev(card),
1639                                         "get vlan id for tx(%d) failed(%d)\n",
1640                                         vlan_id_ix[i].tx, status);
1641                         card->vlan[i].tx = 0;
1642                         card->vlan[i].rx = 0;
1643                         continue;
1644                 }
1645                 card->vlan[i].tx = (u16)v1;
1646
1647                 /* rx tag */
1648                 status = lv1_net_control(bus_id(card), dev_id(card),
1649                                          GELIC_LV1_GET_VLAN_ID,
1650                                          vlan_id_ix[i].rx,
1651                                          0, 0, &v1, &v2);
1652                 if (status || !v1) {
1653                         if (status != LV1_NO_ENTRY)
1654                                 dev_info(ctodev(card),
1655                                          "get vlan id for rx(%d) failed(%d)\n",
1656                                          vlan_id_ix[i].rx, status);
1657                         card->vlan[i].tx = 0;
1658                         card->vlan[i].rx = 0;
1659                         continue;
1660                 }
1661                 card->vlan[i].rx = (u16)v1;
1662
1663                 dev_dbg(ctodev(card), "vlan_id[%d] tx=%02x rx=%02x\n",
1664                         i, card->vlan[i].tx, card->vlan[i].rx);
1665         }
1666
1667         if (card->vlan[GELIC_PORT_ETHERNET_0].tx) {
1668                 BUG_ON(!card->vlan[GELIC_PORT_WIRELESS].tx);
1669                 card->vlan_required = 1;
1670         } else
1671                 card->vlan_required = 0;
1672
1673         /* check wirelss capable firmware */
1674         if (ps3_compare_firmware_version(1, 6, 0) < 0) {
1675                 card->vlan[GELIC_PORT_WIRELESS].tx = 0;
1676                 card->vlan[GELIC_PORT_WIRELESS].rx = 0;
1677         }
1678
1679         dev_info(ctodev(card), "internal vlan %s\n",
1680                  card->vlan_required? "enabled" : "disabled");
1681 }
1682 /**
1683  * ps3_gelic_driver_probe - add a device to the control of this driver
1684  */
1685 static int __devinit ps3_gelic_driver_probe(struct ps3_system_bus_device *dev)
1686 {
1687         struct gelic_card *card;
1688         struct net_device *netdev;
1689         int result;
1690
1691         pr_debug("%s: called\n", __func__);
1692         result = ps3_open_hv_device(dev);
1693
1694         if (result) {
1695                 dev_dbg(&dev->core, "%s:ps3_open_hv_device failed\n",
1696                         __func__);
1697                 goto fail_open;
1698         }
1699
1700         result = ps3_dma_region_create(dev->d_region);
1701
1702         if (result) {
1703                 dev_dbg(&dev->core, "%s:ps3_dma_region_create failed(%d)\n",
1704                         __func__, result);
1705                 BUG_ON("check region type");
1706                 goto fail_dma_region;
1707         }
1708
1709         /* alloc card/netdevice */
1710         card = gelic_alloc_card_net(&netdev);
1711         if (!card) {
1712                 dev_info(&dev->core, "%s:gelic_net_alloc_card failed\n",
1713                          __func__);
1714                 result = -ENOMEM;
1715                 goto fail_alloc_card;
1716         }
1717         ps3_system_bus_set_drvdata(dev, card);
1718         card->dev = dev;
1719
1720         /* get internal vlan info */
1721         gelic_card_get_vlan_info(card);
1722
1723         card->link_mode = GELIC_LV1_ETHER_AUTO_NEG;
1724
1725         /* setup interrupt */
1726         result = lv1_net_set_interrupt_status_indicator(bus_id(card),
1727                                                         dev_id(card),
1728                 ps3_mm_phys_to_lpar(__pa(&card->irq_status)),
1729                 0);
1730
1731         if (result) {
1732                 dev_dbg(&dev->core,
1733                         "%s:set_interrupt_status_indicator failed: %s\n",
1734                         __func__, ps3_result(result));
1735                 result = -EIO;
1736                 goto fail_status_indicator;
1737         }
1738
1739         result = ps3_sb_event_receive_port_setup(dev, PS3_BINDING_CPU_ANY,
1740                 &card->irq);
1741
1742         if (result) {
1743                 dev_info(ctodev(card),
1744                          "%s:gelic_net_open_device failed (%d)\n",
1745                          __func__, result);
1746                 result = -EPERM;
1747                 goto fail_alloc_irq;
1748         }
1749         result = request_irq(card->irq, gelic_card_interrupt,
1750                              IRQF_DISABLED, netdev->name, card);
1751
1752         if (result) {
1753                 dev_info(ctodev(card), "%s:request_irq failed (%d)\n",
1754                         __func__, result);
1755                 goto fail_request_irq;
1756         }
1757
1758         /* setup card structure */
1759         card->irq_mask = GELIC_CARD_RXINT | GELIC_CARD_TXINT |
1760                 GELIC_CARD_PORT_STATUS_CHANGED;
1761         card->rx_csum = GELIC_CARD_RX_CSUM_DEFAULT;
1762
1763
1764         if (gelic_card_init_chain(card, &card->tx_chain,
1765                         card->descr, GELIC_NET_TX_DESCRIPTORS))
1766                 goto fail_alloc_tx;
1767         if (gelic_card_init_chain(card, &card->rx_chain,
1768                                  card->descr + GELIC_NET_TX_DESCRIPTORS,
1769                                  GELIC_NET_RX_DESCRIPTORS))
1770                 goto fail_alloc_rx;
1771
1772         /* head of chain */
1773         card->tx_top = card->tx_chain.head;
1774         card->rx_top = card->rx_chain.head;
1775         dev_dbg(ctodev(card), "descr rx %p, tx %p, size %#lx, num %#x\n",
1776                 card->rx_top, card->tx_top, sizeof(struct gelic_descr),
1777                 GELIC_NET_RX_DESCRIPTORS);
1778         /* allocate rx skbs */
1779         if (gelic_card_alloc_rx_skbs(card))
1780                 goto fail_alloc_skbs;
1781
1782         spin_lock_init(&card->tx_lock);
1783         card->tx_dma_progress = 0;
1784
1785         /* setup net_device structure */
1786         netdev->irq = card->irq;
1787         SET_NETDEV_DEV(netdev, &card->dev->core);
1788         gelic_ether_setup_netdev_ops(netdev, &card->napi);
1789         result = gelic_net_setup_netdev(netdev, card);
1790         if (result) {
1791                 dev_dbg(&dev->core, "%s: setup_netdev failed %d",
1792                         __func__, result);
1793                 goto fail_setup_netdev;
1794         }
1795
1796 #ifdef CONFIG_GELIC_WIRELESS
1797         if (gelic_wl_driver_probe(card)) {
1798                 dev_dbg(&dev->core, "%s: WL init failed\n", __func__);
1799                 goto fail_setup_netdev;
1800         }
1801 #endif
1802         pr_debug("%s: done\n", __func__);
1803         return 0;
1804
1805 fail_setup_netdev:
1806 fail_alloc_skbs:
1807         gelic_card_free_chain(card, card->rx_chain.head);
1808 fail_alloc_rx:
1809         gelic_card_free_chain(card, card->tx_chain.head);
1810 fail_alloc_tx:
1811         free_irq(card->irq, card);
1812         netdev->irq = NO_IRQ;
1813 fail_request_irq:
1814         ps3_sb_event_receive_port_destroy(dev, card->irq);
1815 fail_alloc_irq:
1816         lv1_net_set_interrupt_status_indicator(bus_id(card),
1817                                                bus_id(card),
1818                                                0, 0);
1819 fail_status_indicator:
1820         ps3_system_bus_set_drvdata(dev, NULL);
1821         kfree(netdev_card(netdev)->unalign);
1822         free_netdev(netdev);
1823 fail_alloc_card:
1824         ps3_dma_region_free(dev->d_region);
1825 fail_dma_region:
1826         ps3_close_hv_device(dev);
1827 fail_open:
1828         return result;
1829 }
1830
1831 /**
1832  * ps3_gelic_driver_remove - remove a device from the control of this driver
1833  */
1834
1835 static int ps3_gelic_driver_remove(struct ps3_system_bus_device *dev)
1836 {
1837         struct gelic_card *card = ps3_system_bus_get_drvdata(dev);
1838         struct net_device *netdev0;
1839         pr_debug("%s: called\n", __func__);
1840
1841         /* set auto-negotiation */
1842         gelic_card_set_link_mode(card, GELIC_LV1_ETHER_AUTO_NEG);
1843
1844 #ifdef CONFIG_GELIC_WIRELESS
1845         gelic_wl_driver_remove(card);
1846 #endif
1847         /* stop interrupt */
1848         gelic_card_set_irq_mask(card, 0);
1849
1850         /* turn off DMA, force end */
1851         gelic_card_disable_rxdmac(card);
1852         gelic_card_disable_txdmac(card);
1853
1854         /* release chains */
1855         gelic_card_release_tx_chain(card, 1);
1856         gelic_card_release_rx_chain(card);
1857
1858         gelic_card_free_chain(card, card->tx_top);
1859         gelic_card_free_chain(card, card->rx_top);
1860
1861         netdev0 = card->netdev[GELIC_PORT_ETHERNET_0];
1862         /* disconnect event port */
1863         free_irq(card->irq, card);
1864         netdev0->irq = NO_IRQ;
1865         ps3_sb_event_receive_port_destroy(card->dev, card->irq);
1866
1867         wait_event(card->waitq,
1868                    atomic_read(&card->tx_timeout_task_counter) == 0);
1869
1870         lv1_net_set_interrupt_status_indicator(bus_id(card), dev_id(card),
1871                                                0 , 0);
1872
1873         unregister_netdev(netdev0);
1874         kfree(netdev_card(netdev0)->unalign);
1875         free_netdev(netdev0);
1876
1877         ps3_system_bus_set_drvdata(dev, NULL);
1878
1879         ps3_dma_region_free(dev->d_region);
1880
1881         ps3_close_hv_device(dev);
1882
1883         pr_debug("%s: done\n", __func__);
1884         return 0;
1885 }
1886
1887 static struct ps3_system_bus_driver ps3_gelic_driver = {
1888         .match_id = PS3_MATCH_ID_GELIC,
1889         .probe = ps3_gelic_driver_probe,
1890         .remove = ps3_gelic_driver_remove,
1891         .shutdown = ps3_gelic_driver_remove,
1892         .core.name = "ps3_gelic_driver",
1893         .core.owner = THIS_MODULE,
1894 };
1895
1896 static int __init ps3_gelic_driver_init (void)
1897 {
1898         return firmware_has_feature(FW_FEATURE_PS3_LV1)
1899                 ? ps3_system_bus_driver_register(&ps3_gelic_driver)
1900                 : -ENODEV;
1901 }
1902
1903 static void __exit ps3_gelic_driver_exit (void)
1904 {
1905         ps3_system_bus_driver_unregister(&ps3_gelic_driver);
1906 }
1907
1908 module_init(ps3_gelic_driver_init);
1909 module_exit(ps3_gelic_driver_exit);
1910
1911 MODULE_ALIAS(PS3_MODULE_ALIAS_GELIC);
1912