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