Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ps3_gelic_net.c
Go to the documentation of this file.
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 <[email protected]>
12  * Jens Osterkamp <[email protected]>
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 
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 
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 
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 
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 
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 }
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 
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 
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 
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 
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 }
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 
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 
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 
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));
644  if (status)
645  dev_err(ctodev(card),
646  "lv1_net_stop_rx_dma failed, %d\n", status);
647 }
648 
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));
662  if (status)
663  dev_err(ctodev(card),
664  "lv1_net_stop_tx_dma failed, status=%d\n", status);
665 }
666 
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 
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 
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 
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 
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 
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 
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 
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 
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 }
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 
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 
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 
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 
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 
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_rx_mode = 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 
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 
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 
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 }
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 
1678  udbg_shutdown_ps3gelic();
1679 
1680  result = ps3_open_hv_device(dev);
1681 
1682  if (result) {
1683  dev_dbg(&dev->core, "%s:ps3_open_hv_device failed\n",
1684  __func__);
1685  goto fail_open;
1686  }
1687 
1688  result = ps3_dma_region_create(dev->d_region);
1689 
1690  if (result) {
1691  dev_dbg(&dev->core, "%s:ps3_dma_region_create failed(%d)\n",
1692  __func__, result);
1693  BUG_ON("check region type");
1694  goto fail_dma_region;
1695  }
1696 
1697  /* alloc card/netdevice */
1698  card = gelic_alloc_card_net(&netdev);
1699  if (!card) {
1700  dev_info(&dev->core, "%s:gelic_net_alloc_card failed\n",
1701  __func__);
1702  result = -ENOMEM;
1703  goto fail_alloc_card;
1704  }
1705  ps3_system_bus_set_drvdata(dev, card);
1706  card->dev = dev;
1707 
1708  /* get internal vlan info */
1709  gelic_card_get_vlan_info(card);
1710 
1711  card->link_mode = GELIC_LV1_ETHER_AUTO_NEG;
1712 
1713  /* setup interrupt */
1714  result = lv1_net_set_interrupt_status_indicator(bus_id(card),
1715  dev_id(card),
1716  ps3_mm_phys_to_lpar(__pa(&card->irq_status)),
1717  0);
1718 
1719  if (result) {
1720  dev_dbg(&dev->core,
1721  "%s:set_interrupt_status_indicator failed: %s\n",
1722  __func__, ps3_result(result));
1723  result = -EIO;
1724  goto fail_status_indicator;
1725  }
1726 
1727  result = ps3_sb_event_receive_port_setup(dev, PS3_BINDING_CPU_ANY,
1728  &card->irq);
1729 
1730  if (result) {
1731  dev_info(ctodev(card),
1732  "%s:gelic_net_open_device failed (%d)\n",
1733  __func__, result);
1734  result = -EPERM;
1735  goto fail_alloc_irq;
1736  }
1737  result = request_irq(card->irq, gelic_card_interrupt,
1738  IRQF_DISABLED, netdev->name, card);
1739 
1740  if (result) {
1741  dev_info(ctodev(card), "%s:request_irq failed (%d)\n",
1742  __func__, result);
1743  goto fail_request_irq;
1744  }
1745 
1746  /* setup card structure */
1747  card->irq_mask = GELIC_CARD_RXINT | GELIC_CARD_TXINT |
1748  GELIC_CARD_PORT_STATUS_CHANGED;
1749 
1750 
1751  if (gelic_card_init_chain(card, &card->tx_chain,
1752  card->descr, GELIC_NET_TX_DESCRIPTORS))
1753  goto fail_alloc_tx;
1754  if (gelic_card_init_chain(card, &card->rx_chain,
1755  card->descr + GELIC_NET_TX_DESCRIPTORS,
1756  GELIC_NET_RX_DESCRIPTORS))
1757  goto fail_alloc_rx;
1758 
1759  /* head of chain */
1760  card->tx_top = card->tx_chain.head;
1761  card->rx_top = card->rx_chain.head;
1762  dev_dbg(ctodev(card), "descr rx %p, tx %p, size %#lx, num %#x\n",
1763  card->rx_top, card->tx_top, sizeof(struct gelic_descr),
1764  GELIC_NET_RX_DESCRIPTORS);
1765  /* allocate rx skbs */
1766  if (gelic_card_alloc_rx_skbs(card))
1767  goto fail_alloc_skbs;
1768 
1769  spin_lock_init(&card->tx_lock);
1770  card->tx_dma_progress = 0;
1771 
1772  /* setup net_device structure */
1773  netdev->irq = card->irq;
1774  SET_NETDEV_DEV(netdev, &card->dev->core);
1775  gelic_ether_setup_netdev_ops(netdev, &card->napi);
1776  result = gelic_net_setup_netdev(netdev, card);
1777  if (result) {
1778  dev_dbg(&dev->core, "%s: setup_netdev failed %d",
1779  __func__, result);
1780  goto fail_setup_netdev;
1781  }
1782 
1783 #ifdef CONFIG_GELIC_WIRELESS
1784  if (gelic_wl_driver_probe(card)) {
1785  dev_dbg(&dev->core, "%s: WL init failed\n", __func__);
1786  goto fail_setup_netdev;
1787  }
1788 #endif
1789  pr_debug("%s: done\n", __func__);
1790  return 0;
1791 
1792 fail_setup_netdev:
1793 fail_alloc_skbs:
1794  gelic_card_free_chain(card, card->rx_chain.head);
1795 fail_alloc_rx:
1796  gelic_card_free_chain(card, card->tx_chain.head);
1797 fail_alloc_tx:
1798  free_irq(card->irq, card);
1799  netdev->irq = NO_IRQ;
1800 fail_request_irq:
1801  ps3_sb_event_receive_port_destroy(dev, card->irq);
1802 fail_alloc_irq:
1803  lv1_net_set_interrupt_status_indicator(bus_id(card),
1804  bus_id(card),
1805  0, 0);
1806 fail_status_indicator:
1807  ps3_system_bus_set_drvdata(dev, NULL);
1808  kfree(netdev_card(netdev)->unalign);
1809  free_netdev(netdev);
1810 fail_alloc_card:
1811  ps3_dma_region_free(dev->d_region);
1812 fail_dma_region:
1813  ps3_close_hv_device(dev);
1814 fail_open:
1815  return result;
1816 }
1817 
1822 static int ps3_gelic_driver_remove(struct ps3_system_bus_device *dev)
1823 {
1824  struct gelic_card *card = ps3_system_bus_get_drvdata(dev);
1825  struct net_device *netdev0;
1826  pr_debug("%s: called\n", __func__);
1827 
1828  /* set auto-negotiation */
1829  gelic_card_set_link_mode(card, GELIC_LV1_ETHER_AUTO_NEG);
1830 
1831 #ifdef CONFIG_GELIC_WIRELESS
1832  gelic_wl_driver_remove(card);
1833 #endif
1834  /* stop interrupt */
1835  gelic_card_set_irq_mask(card, 0);
1836 
1837  /* turn off DMA, force end */
1838  gelic_card_disable_rxdmac(card);
1839  gelic_card_disable_txdmac(card);
1840 
1841  /* release chains */
1842  gelic_card_release_tx_chain(card, 1);
1843  gelic_card_release_rx_chain(card);
1844 
1845  gelic_card_free_chain(card, card->tx_top);
1846  gelic_card_free_chain(card, card->rx_top);
1847 
1848  netdev0 = card->netdev[GELIC_PORT_ETHERNET_0];
1849  /* disconnect event port */
1850  free_irq(card->irq, card);
1851  netdev0->irq = NO_IRQ;
1852  ps3_sb_event_receive_port_destroy(card->dev, card->irq);
1853 
1854  wait_event(card->waitq,
1855  atomic_read(&card->tx_timeout_task_counter) == 0);
1856 
1857  lv1_net_set_interrupt_status_indicator(bus_id(card), dev_id(card),
1858  0 , 0);
1859 
1860  unregister_netdev(netdev0);
1861  kfree(netdev_card(netdev0)->unalign);
1862  free_netdev(netdev0);
1863 
1864  ps3_system_bus_set_drvdata(dev, NULL);
1865 
1866  ps3_dma_region_free(dev->d_region);
1867 
1868  ps3_close_hv_device(dev);
1869 
1870  pr_debug("%s: done\n", __func__);
1871  return 0;
1872 }
1873 
1874 static struct ps3_system_bus_driver ps3_gelic_driver = {
1875  .match_id = PS3_MATCH_ID_GELIC,
1876  .probe = ps3_gelic_driver_probe,
1877  .remove = ps3_gelic_driver_remove,
1878  .shutdown = ps3_gelic_driver_remove,
1879  .core.name = "ps3_gelic_driver",
1880  .core.owner = THIS_MODULE,
1881 };
1882 
1883 static int __init ps3_gelic_driver_init (void)
1884 {
1885  return firmware_has_feature(FW_FEATURE_PS3_LV1)
1886  ? ps3_system_bus_driver_register(&ps3_gelic_driver)
1887  : -ENODEV;
1888 }
1889 
1890 static void __exit ps3_gelic_driver_exit (void)
1891 {
1892  ps3_system_bus_driver_unregister(&ps3_gelic_driver);
1893 }
1894 
1895 module_init(ps3_gelic_driver_init);
1896 module_exit(ps3_gelic_driver_exit);
1897 
1898 MODULE_ALIAS(PS3_MODULE_ALIAS_GELIC);
1899 
Generated on Thu Jan 10 2013 14:06:00 for Linux Kernel by   doxygen 1.8.2