2 * PS3 gelic network driver.
4 * Copyright (C) 2007 Sony Computer Entertainment Inc.
5 * Copyright 2006, 2007 Sony Corporation
7 * This file is based on: spider_net.c
9 * (C) Copyright IBM Corp. 2005
11 * Authors : Utz Bacher <utz.bacher@de.ibm.com>
12 * Jens Osterkamp <Jens.Osterkamp@de.ibm.com>
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)
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.
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.
31 #include <linux/kernel.h>
32 #include <linux/module.h>
34 #include <linux/etherdevice.h>
35 #include <linux/ethtool.h>
36 #include <linux/if_vlan.h>
40 #include <linux/tcp.h>
42 #include <linux/dma-mapping.h>
43 #include <net/checksum.h>
44 #include <asm/firmware.h>
46 #include <asm/lv1call.h>
48 #include "ps3_gelic_net.h"
49 #include "ps3_gelic_wireless.h"
51 #define DRV_NAME "Gelic Network Driver"
52 #define DRV_VERSION "2.0"
54 MODULE_AUTHOR("SCE Inc.");
55 MODULE_DESCRIPTION("Gelic Network driver");
56 MODULE_LICENSE("GPL");
59 static inline void gelic_card_enable_rxdmac(struct gelic_card
*card
);
60 static inline void gelic_card_disable_rxdmac(struct gelic_card
*card
);
61 static inline void gelic_card_disable_txdmac(struct gelic_card
*card
);
62 static inline void gelic_card_reset_chain(struct gelic_card
*card
,
63 struct gelic_descr_chain
*chain
,
64 struct gelic_descr
*start_descr
);
67 int gelic_card_set_irq_mask(struct gelic_card
*card
, u64 mask
)
71 status
= lv1_net_set_interrupt_mask(bus_id(card
), dev_id(card
),
74 dev_info(ctodev(card
),
75 "%s failed %d\n", __func__
, status
);
79 static inline void gelic_card_rx_irq_on(struct gelic_card
*card
)
81 card
->irq_mask
|= GELIC_CARD_RXINT
;
82 gelic_card_set_irq_mask(card
, card
->irq_mask
);
84 static inline void gelic_card_rx_irq_off(struct gelic_card
*card
)
86 card
->irq_mask
&= ~GELIC_CARD_RXINT
;
87 gelic_card_set_irq_mask(card
, card
->irq_mask
);
90 static void gelic_card_get_ether_port_status(struct gelic_card
*card
,
94 struct net_device
*ether_netdev
;
96 lv1_net_control(bus_id(card
), dev_id(card
),
97 GELIC_LV1_GET_ETH_PORT_STATUS
,
98 GELIC_LV1_VLAN_TX_ETHERNET
, 0, 0,
99 &card
->ether_port_status
, &v2
);
102 ether_netdev
= card
->netdev
[GELIC_PORT_ETHERNET
];
103 if (card
->ether_port_status
& GELIC_LV1_ETHER_LINK_UP
)
104 netif_carrier_on(ether_netdev
);
106 netif_carrier_off(ether_netdev
);
110 void gelic_card_up(struct gelic_card
*card
)
112 pr_debug("%s: called\n", __func__
);
113 mutex_lock(&card
->updown_lock
);
114 if (atomic_inc_return(&card
->users
) == 1) {
115 pr_debug("%s: real do\n", __func__
);
117 gelic_card_set_irq_mask(card
, card
->irq_mask
);
119 gelic_card_enable_rxdmac(card
);
121 napi_enable(&card
->napi
);
123 mutex_unlock(&card
->updown_lock
);
124 pr_debug("%s: done\n", __func__
);
127 void gelic_card_down(struct gelic_card
*card
)
130 pr_debug("%s: called\n", __func__
);
131 mutex_lock(&card
->updown_lock
);
132 if (atomic_dec_if_positive(&card
->users
) == 0) {
133 pr_debug("%s: real do\n", __func__
);
134 napi_disable(&card
->napi
);
136 * Disable irq. Wireless interrupts will
137 * be disabled later if any
139 mask
= card
->irq_mask
& (GELIC_CARD_WLAN_EVENT_RECEIVED
|
140 GELIC_CARD_WLAN_COMMAND_COMPLETED
);
141 gelic_card_set_irq_mask(card
, mask
);
143 gelic_card_disable_rxdmac(card
);
144 gelic_card_reset_chain(card
, &card
->rx_chain
,
145 card
->descr
+ GELIC_NET_TX_DESCRIPTORS
);
147 gelic_card_disable_txdmac(card
);
149 mutex_unlock(&card
->updown_lock
);
150 pr_debug("%s: done\n", __func__
);
154 * gelic_descr_get_status -- returns the status of a descriptor
155 * @descr: descriptor to look at
157 * returns the status as in the dmac_cmd_status field of the descriptor
159 static enum gelic_descr_dma_status
160 gelic_descr_get_status(struct gelic_descr
*descr
)
162 return be32_to_cpu(descr
->dmac_cmd_status
) & GELIC_DESCR_DMA_STAT_MASK
;
166 * gelic_descr_set_status -- sets the status of a descriptor
167 * @descr: descriptor to change
168 * @status: status to set in the descriptor
170 * changes the status to the specified value. Doesn't change other bits
173 static void gelic_descr_set_status(struct gelic_descr
*descr
,
174 enum gelic_descr_dma_status status
)
176 descr
->dmac_cmd_status
= cpu_to_be32(status
|
177 (be32_to_cpu(descr
->dmac_cmd_status
) &
178 ~GELIC_DESCR_DMA_STAT_MASK
));
180 * dma_cmd_status field is used to indicate whether the descriptor
182 * Usually caller of this function wants to inform that to the
183 * hardware, so we assure here the hardware sees the change.
189 * gelic_card_free_chain - free descriptor chain
190 * @card: card structure
191 * @descr_in: address of desc
193 static void gelic_card_free_chain(struct gelic_card
*card
,
194 struct gelic_descr
*descr_in
)
196 struct gelic_descr
*descr
;
198 for (descr
= descr_in
; descr
&& descr
->bus_addr
; descr
= descr
->next
) {
199 dma_unmap_single(ctodev(card
), descr
->bus_addr
,
200 GELIC_DESCR_SIZE
, DMA_BIDIRECTIONAL
);
206 * gelic_card_init_chain - links descriptor chain
207 * @card: card structure
208 * @chain: address of chain
209 * @start_descr: address of descriptor array
210 * @no: number of descriptors
212 * we manage a circular list that mirrors the hardware structure,
213 * except that the hardware uses bus addresses.
215 * returns 0 on success, <0 on failure
217 static int __devinit
gelic_card_init_chain(struct gelic_card
*card
,
218 struct gelic_descr_chain
*chain
,
219 struct gelic_descr
*start_descr
,
223 struct gelic_descr
*descr
;
226 memset(descr
, 0, sizeof(*descr
) * no
);
228 /* set up the hardware pointers in each descriptor */
229 for (i
= 0; i
< no
; i
++, descr
++) {
230 gelic_descr_set_status(descr
, GELIC_DESCR_DMA_NOT_IN_USE
);
232 dma_map_single(ctodev(card
), descr
,
236 if (!descr
->bus_addr
)
239 descr
->next
= descr
+ 1;
240 descr
->prev
= descr
- 1;
242 /* make them as ring */
243 (descr
- 1)->next
= start_descr
;
244 start_descr
->prev
= (descr
- 1);
246 /* chain bus addr of hw descriptor */
248 for (i
= 0; i
< no
; i
++, descr
++) {
249 descr
->next_descr_addr
= cpu_to_be32(descr
->next
->bus_addr
);
252 chain
->head
= start_descr
;
253 chain
->tail
= start_descr
;
255 /* do not chain last hw descriptor */
256 (descr
- 1)->next_descr_addr
= 0;
261 for (i
--, descr
--; 0 <= i
; i
--, descr
--)
263 dma_unmap_single(ctodev(card
), descr
->bus_addr
,
270 * gelic_card_reset_chain - reset status of a descriptor chain
271 * @card: card structure
272 * @chain: address of chain
273 * @start_descr: address of descriptor array
275 * Reset the status of dma descriptors to ready state
276 * and re-initialize the hardware chain for later use
278 static void gelic_card_reset_chain(struct gelic_card
*card
,
279 struct gelic_descr_chain
*chain
,
280 struct gelic_descr
*start_descr
)
282 struct gelic_descr
*descr
;
284 for (descr
= start_descr
; start_descr
!= descr
->next
; descr
++) {
285 gelic_descr_set_status(descr
, GELIC_DESCR_DMA_CARDOWNED
);
286 descr
->next_descr_addr
= cpu_to_be32(descr
->next
->bus_addr
);
289 chain
->head
= start_descr
;
290 chain
->tail
= (descr
- 1);
292 (descr
- 1)->next_descr_addr
= 0;
295 * gelic_descr_prepare_rx - reinitializes a rx descriptor
296 * @card: card structure
297 * @descr: descriptor to re-init
299 * return 0 on succes, <0 on failure
301 * allocates a new rx skb, iommu-maps it and attaches it to the descriptor.
302 * Activate the descriptor state-wise
304 static int gelic_descr_prepare_rx(struct gelic_card
*card
,
305 struct gelic_descr
*descr
)
308 unsigned int bufsize
;
310 if (gelic_descr_get_status(descr
) != GELIC_DESCR_DMA_NOT_IN_USE
)
311 dev_info(ctodev(card
), "%s: ERROR status \n", __func__
);
312 /* we need to round up the buffer size to a multiple of 128 */
313 bufsize
= ALIGN(GELIC_NET_MAX_MTU
, GELIC_NET_RXBUF_ALIGN
);
315 /* and we need to have it 128 byte aligned, therefore we allocate a
317 descr
->skb
= dev_alloc_skb(bufsize
+ GELIC_NET_RXBUF_ALIGN
- 1);
319 descr
->buf_addr
= 0; /* tell DMAC don't touch memory */
320 dev_info(ctodev(card
),
321 "%s:allocate skb failed !!\n", __func__
);
324 descr
->buf_size
= cpu_to_be32(bufsize
);
325 descr
->dmac_cmd_status
= 0;
326 descr
->result_size
= 0;
327 descr
->valid_size
= 0;
328 descr
->data_error
= 0;
330 offset
= ((unsigned long)descr
->skb
->data
) &
331 (GELIC_NET_RXBUF_ALIGN
- 1);
333 skb_reserve(descr
->skb
, GELIC_NET_RXBUF_ALIGN
- offset
);
334 /* io-mmu-map the skb */
335 descr
->buf_addr
= cpu_to_be32(dma_map_single(ctodev(card
),
339 if (!descr
->buf_addr
) {
340 dev_kfree_skb_any(descr
->skb
);
342 dev_info(ctodev(card
),
343 "%s:Could not iommu-map rx buffer\n", __func__
);
344 gelic_descr_set_status(descr
, GELIC_DESCR_DMA_NOT_IN_USE
);
347 gelic_descr_set_status(descr
, GELIC_DESCR_DMA_CARDOWNED
);
353 * gelic_card_release_rx_chain - free all skb of rx descr
354 * @card: card structure
357 static void gelic_card_release_rx_chain(struct gelic_card
*card
)
359 struct gelic_descr
*descr
= card
->rx_chain
.head
;
363 dma_unmap_single(ctodev(card
),
364 be32_to_cpu(descr
->buf_addr
),
368 dev_kfree_skb_any(descr
->skb
);
370 gelic_descr_set_status(descr
,
371 GELIC_DESCR_DMA_NOT_IN_USE
);
374 } while (descr
!= card
->rx_chain
.head
);
378 * gelic_card_fill_rx_chain - fills descriptors/skbs in the rx chains
379 * @card: card structure
381 * fills all descriptors in the rx chain: allocates skbs
382 * and iommu-maps them.
383 * returns 0 on success, < 0 on failure
385 static int gelic_card_fill_rx_chain(struct gelic_card
*card
)
387 struct gelic_descr
*descr
= card
->rx_chain
.head
;
392 ret
= gelic_descr_prepare_rx(card
, descr
);
397 } while (descr
!= card
->rx_chain
.head
);
401 gelic_card_release_rx_chain(card
);
406 * gelic_card_alloc_rx_skbs - allocates rx skbs in rx descriptor chains
407 * @card: card structure
409 * returns 0 on success, < 0 on failure
411 static int __devinit
gelic_card_alloc_rx_skbs(struct gelic_card
*card
)
413 struct gelic_descr_chain
*chain
;
415 chain
= &card
->rx_chain
;
416 ret
= gelic_card_fill_rx_chain(card
);
417 chain
->tail
= card
->rx_top
->prev
; /* point to the last */
422 * gelic_descr_release_tx - processes a used tx descriptor
423 * @card: card structure
424 * @descr: descriptor to release
426 * releases a used tx descriptor (unmapping, freeing of skb)
428 static void gelic_descr_release_tx(struct gelic_card
*card
,
429 struct gelic_descr
*descr
)
431 struct sk_buff
*skb
= descr
->skb
;
433 BUG_ON(!(be32_to_cpu(descr
->data_status
) & GELIC_DESCR_TX_TAIL
));
435 dma_unmap_single(ctodev(card
), be32_to_cpu(descr
->buf_addr
), skb
->len
,
437 dev_kfree_skb_any(skb
);
441 descr
->next_descr_addr
= 0;
442 descr
->result_size
= 0;
443 descr
->valid_size
= 0;
444 descr
->data_status
= 0;
445 descr
->data_error
= 0;
448 /* set descr status */
449 gelic_descr_set_status(descr
, GELIC_DESCR_DMA_NOT_IN_USE
);
452 static void gelic_card_stop_queues(struct gelic_card
*card
)
454 netif_stop_queue(card
->netdev
[GELIC_PORT_ETHERNET
]);
456 if (card
->netdev
[GELIC_PORT_WIRELESS
])
457 netif_stop_queue(card
->netdev
[GELIC_PORT_WIRELESS
]);
459 static void gelic_card_wake_queues(struct gelic_card
*card
)
461 netif_wake_queue(card
->netdev
[GELIC_PORT_ETHERNET
]);
463 if (card
->netdev
[GELIC_PORT_WIRELESS
])
464 netif_wake_queue(card
->netdev
[GELIC_PORT_WIRELESS
]);
467 * gelic_card_release_tx_chain - processes sent tx descriptors
468 * @card: adapter structure
469 * @stop: net_stop sequence
471 * releases the tx descriptors that gelic has finished with
473 static void gelic_card_release_tx_chain(struct gelic_card
*card
, int stop
)
475 struct gelic_descr_chain
*tx_chain
;
476 enum gelic_descr_dma_status status
;
477 struct net_device
*netdev
;
480 for (tx_chain
= &card
->tx_chain
;
481 tx_chain
->head
!= tx_chain
->tail
&& tx_chain
->tail
;
482 tx_chain
->tail
= tx_chain
->tail
->next
) {
483 status
= gelic_descr_get_status(tx_chain
->tail
);
484 netdev
= tx_chain
->tail
->skb
->dev
;
486 case GELIC_DESCR_DMA_RESPONSE_ERROR
:
487 case GELIC_DESCR_DMA_PROTECTION_ERROR
:
488 case GELIC_DESCR_DMA_FORCE_END
:
489 if (printk_ratelimit())
490 dev_info(ctodev(card
),
491 "%s: forcing end of tx descriptor " \
494 netdev
->stats
.tx_dropped
++;
497 case GELIC_DESCR_DMA_COMPLETE
:
498 if (tx_chain
->tail
->skb
) {
499 netdev
->stats
.tx_packets
++;
500 netdev
->stats
.tx_bytes
+=
501 tx_chain
->tail
->skb
->len
;
505 case GELIC_DESCR_DMA_CARDOWNED
:
506 /* pending tx request */
508 /* any other value (== GELIC_DESCR_DMA_NOT_IN_USE) */
512 gelic_descr_release_tx(card
, tx_chain
->tail
);
516 if (!stop
&& release
)
517 gelic_card_wake_queues(card
);
521 * gelic_net_set_multi - sets multicast addresses and promisc flags
522 * @netdev: interface device structure
524 * gelic_net_set_multi configures multicast addresses as needed for the
525 * netdev interface. It also sets up multicast, allmulti and promisc
526 * flags appropriately
528 void gelic_net_set_multi(struct net_device
*netdev
)
530 struct gelic_card
*card
= netdev_card(netdev
);
531 struct dev_mc_list
*mc
;
537 /* clear all multicast address */
538 status
= lv1_net_remove_multicast_address(bus_id(card
), dev_id(card
),
541 dev_err(ctodev(card
),
542 "lv1_net_remove_multicast_address failed %d\n",
544 /* set broadcast address */
545 status
= lv1_net_add_multicast_address(bus_id(card
), dev_id(card
),
546 GELIC_NET_BROADCAST_ADDR
, 0);
548 dev_err(ctodev(card
),
549 "lv1_net_add_multicast_address failed, %d\n",
552 if ((netdev
->flags
& IFF_ALLMULTI
) ||
553 (netdev
->mc_count
> GELIC_NET_MC_COUNT_MAX
)) {
554 status
= lv1_net_add_multicast_address(bus_id(card
),
558 dev_err(ctodev(card
),
559 "lv1_net_add_multicast_address failed, %d\n",
564 /* set multicast addresses */
565 for (mc
= netdev
->mc_list
; mc
; mc
= mc
->next
) {
568 for (i
= 0; i
< ETH_ALEN
; i
++) {
572 status
= lv1_net_add_multicast_address(bus_id(card
),
576 dev_err(ctodev(card
),
577 "lv1_net_add_multicast_address failed, %d\n",
583 * gelic_card_enable_rxdmac - enables the receive DMA controller
584 * @card: card structure
586 * gelic_card_enable_rxdmac enables the DMA controller by setting RX_DMA_EN
587 * in the GDADMACCNTR register
589 static inline void gelic_card_enable_rxdmac(struct gelic_card
*card
)
594 if (gelic_descr_get_status(card
->rx_chain
.head
) !=
595 GELIC_DESCR_DMA_CARDOWNED
) {
596 printk(KERN_ERR
"%s: status=%x\n", __func__
,
597 be32_to_cpu(card
->rx_chain
.head
->dmac_cmd_status
));
598 printk(KERN_ERR
"%s: nextphy=%x\n", __func__
,
599 be32_to_cpu(card
->rx_chain
.head
->next_descr_addr
));
600 printk(KERN_ERR
"%s: head=%p\n", __func__
,
601 card
->rx_chain
.head
);
604 status
= lv1_net_start_rx_dma(bus_id(card
), dev_id(card
),
605 card
->rx_chain
.head
->bus_addr
, 0);
607 dev_info(ctodev(card
),
608 "lv1_net_start_rx_dma failed, status=%d\n", status
);
612 * gelic_card_disable_rxdmac - disables the receive DMA controller
613 * @card: card structure
615 * gelic_card_disable_rxdmac terminates processing on the DMA controller by
616 * turing off DMA and issueing a force end
618 static inline void gelic_card_disable_rxdmac(struct gelic_card
*card
)
622 /* this hvc blocks until the DMA in progress really stopped */
623 status
= lv1_net_stop_rx_dma(bus_id(card
), dev_id(card
), 0);
625 dev_err(ctodev(card
),
626 "lv1_net_stop_rx_dma faild, %d\n", status
);
630 * gelic_card_disable_txdmac - disables the transmit DMA controller
631 * @card: card structure
633 * gelic_card_disable_txdmac terminates processing on the DMA controller by
634 * turing off DMA and issueing a force end
636 static inline void gelic_card_disable_txdmac(struct gelic_card
*card
)
640 /* this hvc blocks until the DMA in progress really stopped */
641 status
= lv1_net_stop_tx_dma(bus_id(card
), dev_id(card
), 0);
643 dev_err(ctodev(card
),
644 "lv1_net_stop_tx_dma faild, status=%d\n", status
);
648 * gelic_net_stop - called upon ifconfig down
649 * @netdev: interface device structure
653 int gelic_net_stop(struct net_device
*netdev
)
655 struct gelic_card
*card
;
657 pr_debug("%s: start\n", __func__
);
659 netif_stop_queue(netdev
);
660 netif_carrier_off(netdev
);
662 card
= netdev_card(netdev
);
663 gelic_card_down(card
);
665 pr_debug("%s: done\n", __func__
);
670 * gelic_card_get_next_tx_descr - returns the next available tx descriptor
671 * @card: device structure to get descriptor from
673 * returns the address of the next descriptor, or NULL if not available.
675 static struct gelic_descr
*
676 gelic_card_get_next_tx_descr(struct gelic_card
*card
)
678 if (!card
->tx_chain
.head
)
680 /* see if the next descriptor is free */
681 if (card
->tx_chain
.tail
!= card
->tx_chain
.head
->next
&&
682 gelic_descr_get_status(card
->tx_chain
.head
) ==
683 GELIC_DESCR_DMA_NOT_IN_USE
)
684 return card
->tx_chain
.head
;
691 * gelic_net_set_txdescr_cmdstat - sets the tx descriptor command field
692 * @descr: descriptor structure to fill out
693 * @skb: packet to consider
695 * fills out the command and status field of the descriptor structure,
696 * depending on hardware checksum settings. This function assumes a wmb()
697 * has executed before.
699 static void gelic_descr_set_tx_cmdstat(struct gelic_descr
*descr
,
702 if (skb
->ip_summed
!= CHECKSUM_PARTIAL
)
703 descr
->dmac_cmd_status
=
704 cpu_to_be32(GELIC_DESCR_DMA_CMD_NO_CHKSUM
|
705 GELIC_DESCR_TX_DMA_FRAME_TAIL
);
708 * if yes: tcp? udp? */
709 if (skb
->protocol
== htons(ETH_P_IP
)) {
710 if (ip_hdr(skb
)->protocol
== IPPROTO_TCP
)
711 descr
->dmac_cmd_status
=
712 cpu_to_be32(GELIC_DESCR_DMA_CMD_TCP_CHKSUM
|
713 GELIC_DESCR_TX_DMA_FRAME_TAIL
);
715 else if (ip_hdr(skb
)->protocol
== IPPROTO_UDP
)
716 descr
->dmac_cmd_status
=
717 cpu_to_be32(GELIC_DESCR_DMA_CMD_UDP_CHKSUM
|
718 GELIC_DESCR_TX_DMA_FRAME_TAIL
);
720 * the stack should checksum non-tcp and non-udp
721 * packets on his own: NETIF_F_IP_CSUM
723 descr
->dmac_cmd_status
=
724 cpu_to_be32(GELIC_DESCR_DMA_CMD_NO_CHKSUM
|
725 GELIC_DESCR_TX_DMA_FRAME_TAIL
);
730 static inline struct sk_buff
*gelic_put_vlan_tag(struct sk_buff
*skb
,
733 struct vlan_ethhdr
*veth
;
734 static unsigned int c
;
736 if (skb_headroom(skb
) < VLAN_HLEN
) {
737 struct sk_buff
*sk_tmp
= skb
;
738 pr_debug("%s: hd=%d c=%ud\n", __func__
, skb_headroom(skb
), c
);
739 skb
= skb_realloc_headroom(sk_tmp
, VLAN_HLEN
);
742 dev_kfree_skb_any(sk_tmp
);
744 veth
= (struct vlan_ethhdr
*)skb_push(skb
, VLAN_HLEN
);
746 /* Move the mac addresses to the top of buffer */
747 memmove(skb
->data
, skb
->data
+ VLAN_HLEN
, 2 * ETH_ALEN
);
749 veth
->h_vlan_proto
= cpu_to_be16(ETH_P_8021Q
);
750 veth
->h_vlan_TCI
= htons(tag
);
756 * gelic_descr_prepare_tx - setup a descriptor for sending packets
757 * @card: card structure
758 * @descr: descriptor structure
759 * @skb: packet to use
761 * returns 0 on success, <0 on failure.
764 static int gelic_descr_prepare_tx(struct gelic_card
*card
,
765 struct gelic_descr
*descr
,
770 if (card
->vlan_required
) {
771 struct sk_buff
*skb_tmp
;
772 enum gelic_port_type type
;
774 type
= netdev_port(skb
->dev
)->type
;
775 skb_tmp
= gelic_put_vlan_tag(skb
,
776 card
->vlan
[type
].tx
);
782 buf
= dma_map_single(ctodev(card
), skb
->data
, skb
->len
, DMA_TO_DEVICE
);
785 dev_err(ctodev(card
),
786 "dma map 2 failed (%p, %i). Dropping packet\n",
787 skb
->data
, skb
->len
);
791 descr
->buf_addr
= cpu_to_be32(buf
);
792 descr
->buf_size
= cpu_to_be32(skb
->len
);
794 descr
->data_status
= 0;
795 descr
->next_descr_addr
= 0; /* terminate hw descr */
796 gelic_descr_set_tx_cmdstat(descr
, skb
);
798 /* bump free descriptor pointer */
799 card
->tx_chain
.head
= descr
->next
;
804 * gelic_card_kick_txdma - enables TX DMA processing
805 * @card: card structure
806 * @descr: descriptor address to enable TX processing at
809 static int gelic_card_kick_txdma(struct gelic_card
*card
,
810 struct gelic_descr
*descr
)
814 if (card
->tx_dma_progress
)
817 if (gelic_descr_get_status(descr
) == GELIC_DESCR_DMA_CARDOWNED
) {
818 card
->tx_dma_progress
= 1;
819 status
= lv1_net_start_tx_dma(bus_id(card
), dev_id(card
),
822 dev_info(ctodev(card
), "lv1_net_start_txdma failed," \
823 "status=%d\n", status
);
829 * gelic_net_xmit - transmits a frame over the device
830 * @skb: packet to send out
831 * @netdev: interface device structure
833 * returns 0 on success, <0 on failure
835 int gelic_net_xmit(struct sk_buff
*skb
, struct net_device
*netdev
)
837 struct gelic_card
*card
= netdev_card(netdev
);
838 struct gelic_descr
*descr
;
842 spin_lock_irqsave(&card
->tx_lock
, flags
);
844 gelic_card_release_tx_chain(card
, 0);
846 descr
= gelic_card_get_next_tx_descr(card
);
849 * no more descriptors free
851 gelic_card_stop_queues(card
);
852 spin_unlock_irqrestore(&card
->tx_lock
, flags
);
853 return NETDEV_TX_BUSY
;
856 result
= gelic_descr_prepare_tx(card
, descr
, skb
);
859 * DMA map failed. As chanses are that failure
860 * would continue, just release skb and return
862 netdev
->stats
.tx_dropped
++;
863 dev_kfree_skb_any(skb
);
864 spin_unlock_irqrestore(&card
->tx_lock
, flags
);
868 * link this prepared descriptor to previous one
869 * to achieve high performance
871 descr
->prev
->next_descr_addr
= cpu_to_be32(descr
->bus_addr
);
873 * as hardware descriptor is modified in the above lines,
874 * ensure that the hardware sees it
877 if (gelic_card_kick_txdma(card
, descr
)) {
880 * release descriptors which were just prepared
882 netdev
->stats
.tx_dropped
++;
883 gelic_descr_release_tx(card
, descr
);
884 gelic_descr_release_tx(card
, descr
->next
);
885 card
->tx_chain
.tail
= descr
->next
->next
;
886 dev_info(ctodev(card
), "%s: kick failure\n", __func__
);
888 /* OK, DMA started/reserved */
889 netdev
->trans_start
= jiffies
;
892 spin_unlock_irqrestore(&card
->tx_lock
, flags
);
897 * gelic_net_pass_skb_up - takes an skb from a descriptor and passes it on
898 * @descr: descriptor to process
899 * @card: card structure
900 * @netdev: net_device structure to be passed packet
902 * iommu-unmaps the skb, fills out skb structure and passes the data to the
903 * stack. The descriptor state is not changed.
905 static void gelic_net_pass_skb_up(struct gelic_descr
*descr
,
906 struct gelic_card
*card
,
907 struct net_device
*netdev
)
910 struct sk_buff
*skb
= descr
->skb
;
911 u32 data_status
, data_error
;
913 data_status
= be32_to_cpu(descr
->data_status
);
914 data_error
= be32_to_cpu(descr
->data_error
);
915 /* unmap skb buffer */
916 dma_unmap_single(ctodev(card
), be32_to_cpu(descr
->buf_addr
),
920 skb_put(skb
, be32_to_cpu(descr
->valid_size
)?
921 be32_to_cpu(descr
->valid_size
) :
922 be32_to_cpu(descr
->result_size
));
923 if (!descr
->valid_size
)
924 dev_info(ctodev(card
), "buffer full %x %x %x\n",
925 be32_to_cpu(descr
->result_size
),
926 be32_to_cpu(descr
->buf_size
),
927 be32_to_cpu(descr
->dmac_cmd_status
));
931 * the card put 2 bytes vlan tag in front
932 * of the ethernet frame
935 skb
->protocol
= eth_type_trans(skb
, netdev
);
937 /* checksum offload */
939 if ((data_status
& GELIC_DESCR_DATA_STATUS_CHK_MASK
) &&
940 (!(data_error
& GELIC_DESCR_DATA_ERROR_CHK_MASK
)))
941 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
943 skb
->ip_summed
= CHECKSUM_NONE
;
945 skb
->ip_summed
= CHECKSUM_NONE
;
947 /* update netdevice statistics */
948 netdev
->stats
.rx_packets
++;
949 netdev
->stats
.rx_bytes
+= skb
->len
;
951 /* pass skb up to stack */
952 netif_receive_skb(skb
);
956 * gelic_card_decode_one_descr - processes an rx descriptor
957 * @card: card structure
959 * returns 1 if a packet has been sent to the stack, otherwise 0
961 * processes an rx descriptor by iommu-unmapping the data buffer and passing
962 * the packet up to the stack
964 static int gelic_card_decode_one_descr(struct gelic_card
*card
)
966 enum gelic_descr_dma_status status
;
967 struct gelic_descr_chain
*chain
= &card
->rx_chain
;
968 struct gelic_descr
*descr
= chain
->head
;
969 struct net_device
*netdev
= NULL
;
970 int dmac_chain_ended
;
972 status
= gelic_descr_get_status(descr
);
973 /* is this descriptor terminated with next_descr == NULL? */
975 be32_to_cpu(descr
->dmac_cmd_status
) &
976 GELIC_DESCR_RX_DMA_CHAIN_END
;
978 if (status
== GELIC_DESCR_DMA_CARDOWNED
)
981 if (status
== GELIC_DESCR_DMA_NOT_IN_USE
) {
982 dev_dbg(ctodev(card
), "dormant descr? %p\n", descr
);
986 /* netdevice select */
987 if (card
->vlan_required
) {
990 vid
= *(u16
*)(descr
->skb
->data
) & VLAN_VID_MASK
;
991 for (i
= 0; i
< GELIC_PORT_MAX
; i
++) {
992 if (card
->vlan
[i
].rx
== vid
) {
993 netdev
= card
->netdev
[i
];
997 if (GELIC_PORT_MAX
<= i
) {
998 pr_info("%s: unknown packet vid=%x\n", __func__
, vid
);
1002 netdev
= card
->netdev
[GELIC_PORT_ETHERNET
];
1004 if ((status
== GELIC_DESCR_DMA_RESPONSE_ERROR
) ||
1005 (status
== GELIC_DESCR_DMA_PROTECTION_ERROR
) ||
1006 (status
== GELIC_DESCR_DMA_FORCE_END
)) {
1007 dev_info(ctodev(card
), "dropping RX descriptor with state %x\n",
1009 netdev
->stats
.rx_dropped
++;
1013 if (status
== GELIC_DESCR_DMA_BUFFER_FULL
) {
1015 * Buffer full would occur if and only if
1016 * the frame length was longer than the size of this
1017 * descriptor's buffer. If the frame length was equal
1018 * to or shorter than buffer'size, FRAME_END condition
1020 * Anyway this frame was longer than the MTU,
1023 dev_info(ctodev(card
), "overlength frame\n");
1027 * descriptoers any other than FRAME_END here should
1028 * be treated as error.
1030 if (status
!= GELIC_DESCR_DMA_FRAME_END
) {
1031 dev_dbg(ctodev(card
), "RX descriptor with state %x\n",
1036 /* ok, we've got a packet in descr */
1037 gelic_net_pass_skb_up(descr
, card
, netdev
);
1040 * So that always DMAC can see the end
1041 * of the descriptor chain to avoid
1042 * from unwanted DMAC overrun.
1044 descr
->next_descr_addr
= 0;
1046 /* change the descriptor state: */
1047 gelic_descr_set_status(descr
, GELIC_DESCR_DMA_NOT_IN_USE
);
1050 * this call can fail, but for now, just leave this
1051 * decriptor without skb
1053 gelic_descr_prepare_rx(card
, descr
);
1055 chain
->tail
= descr
;
1056 chain
->head
= descr
->next
;
1059 * Set this descriptor the end of the chain.
1061 descr
->prev
->next_descr_addr
= cpu_to_be32(descr
->bus_addr
);
1064 * If dmac chain was met, DMAC stopped.
1067 if (dmac_chain_ended
) {
1068 card
->rx_dma_restart_required
= 1;
1069 dev_dbg(ctodev(card
), "reenable rx dma scheduled\n");
1076 * gelic_net_poll - NAPI poll function called by the stack to return packets
1077 * @napi: napi structure
1078 * @budget: number of packets we can pass to the stack at most
1080 * returns the number of the processed packets
1083 static int gelic_net_poll(struct napi_struct
*napi
, int budget
)
1085 struct gelic_card
*card
= container_of(napi
, struct gelic_card
, napi
);
1086 int packets_done
= 0;
1088 while (packets_done
< budget
) {
1089 if (!gelic_card_decode_one_descr(card
))
1095 if (packets_done
< budget
) {
1096 napi_complete(napi
);
1097 gelic_card_rx_irq_on(card
);
1099 return packets_done
;
1102 * gelic_net_change_mtu - changes the MTU of an interface
1103 * @netdev: interface device structure
1104 * @new_mtu: new MTU value
1106 * returns 0 on success, <0 on failure
1108 int gelic_net_change_mtu(struct net_device
*netdev
, int new_mtu
)
1110 /* no need to re-alloc skbs or so -- the max mtu is about 2.3k
1111 * and mtu is outbound only anyway */
1112 if ((new_mtu
< GELIC_NET_MIN_MTU
) ||
1113 (new_mtu
> GELIC_NET_MAX_MTU
)) {
1116 netdev
->mtu
= new_mtu
;
1121 * gelic_card_interrupt - event handler for gelic_net
1123 static irqreturn_t
gelic_card_interrupt(int irq
, void *ptr
)
1125 unsigned long flags
;
1126 struct gelic_card
*card
= ptr
;
1129 status
= card
->irq_status
;
1134 status
&= card
->irq_mask
;
1136 if (card
->rx_dma_restart_required
) {
1137 card
->rx_dma_restart_required
= 0;
1138 gelic_card_enable_rxdmac(card
);
1141 if (status
& GELIC_CARD_RXINT
) {
1142 gelic_card_rx_irq_off(card
);
1143 napi_schedule(&card
->napi
);
1146 if (status
& GELIC_CARD_TXINT
) {
1147 spin_lock_irqsave(&card
->tx_lock
, flags
);
1148 card
->tx_dma_progress
= 0;
1149 gelic_card_release_tx_chain(card
, 0);
1150 /* kick outstanding tx descriptor if any */
1151 gelic_card_kick_txdma(card
, card
->tx_chain
.tail
);
1152 spin_unlock_irqrestore(&card
->tx_lock
, flags
);
1155 /* ether port status changed */
1156 if (status
& GELIC_CARD_PORT_STATUS_CHANGED
)
1157 gelic_card_get_ether_port_status(card
, 1);
1159 #ifdef CONFIG_GELIC_WIRELESS
1160 if (status
& (GELIC_CARD_WLAN_EVENT_RECEIVED
|
1161 GELIC_CARD_WLAN_COMMAND_COMPLETED
))
1162 gelic_wl_interrupt(card
->netdev
[GELIC_PORT_WIRELESS
], status
);
1168 #ifdef CONFIG_NET_POLL_CONTROLLER
1170 * gelic_net_poll_controller - artificial interrupt for netconsole etc.
1171 * @netdev: interface device structure
1173 * see Documentation/networking/netconsole.txt
1175 void gelic_net_poll_controller(struct net_device
*netdev
)
1177 struct gelic_card
*card
= netdev_card(netdev
);
1179 gelic_card_set_irq_mask(card
, 0);
1180 gelic_card_interrupt(netdev
->irq
, netdev
);
1181 gelic_card_set_irq_mask(card
, card
->irq_mask
);
1183 #endif /* CONFIG_NET_POLL_CONTROLLER */
1186 * gelic_net_open - called upon ifonfig up
1187 * @netdev: interface device structure
1189 * returns 0 on success, <0 on failure
1191 * gelic_net_open allocates all the descriptors and memory needed for
1192 * operation, sets up multicast list and enables interrupts
1194 int gelic_net_open(struct net_device
*netdev
)
1196 struct gelic_card
*card
= netdev_card(netdev
);
1198 dev_dbg(ctodev(card
), " -> %s %p\n", __func__
, netdev
);
1200 gelic_card_up(card
);
1202 netif_start_queue(netdev
);
1203 gelic_card_get_ether_port_status(card
, 1);
1205 dev_dbg(ctodev(card
), " <- %s\n", __func__
);
1209 void gelic_net_get_drvinfo(struct net_device
*netdev
,
1210 struct ethtool_drvinfo
*info
)
1212 strncpy(info
->driver
, DRV_NAME
, sizeof(info
->driver
) - 1);
1213 strncpy(info
->version
, DRV_VERSION
, sizeof(info
->version
) - 1);
1216 static int gelic_ether_get_settings(struct net_device
*netdev
,
1217 struct ethtool_cmd
*cmd
)
1219 struct gelic_card
*card
= netdev_card(netdev
);
1221 gelic_card_get_ether_port_status(card
, 0);
1223 if (card
->ether_port_status
& GELIC_LV1_ETHER_FULL_DUPLEX
)
1224 cmd
->duplex
= DUPLEX_FULL
;
1226 cmd
->duplex
= DUPLEX_HALF
;
1228 switch (card
->ether_port_status
& GELIC_LV1_ETHER_SPEED_MASK
) {
1229 case GELIC_LV1_ETHER_SPEED_10
:
1230 cmd
->speed
= SPEED_10
;
1232 case GELIC_LV1_ETHER_SPEED_100
:
1233 cmd
->speed
= SPEED_100
;
1235 case GELIC_LV1_ETHER_SPEED_1000
:
1236 cmd
->speed
= SPEED_1000
;
1239 pr_info("%s: speed unknown\n", __func__
);
1240 cmd
->speed
= SPEED_10
;
1244 cmd
->supported
= SUPPORTED_TP
| SUPPORTED_Autoneg
|
1245 SUPPORTED_10baseT_Half
| SUPPORTED_10baseT_Full
|
1246 SUPPORTED_100baseT_Half
| SUPPORTED_100baseT_Full
|
1247 SUPPORTED_1000baseT_Half
| SUPPORTED_1000baseT_Full
;
1248 cmd
->advertising
= cmd
->supported
;
1249 cmd
->autoneg
= AUTONEG_ENABLE
; /* always enabled */
1250 cmd
->port
= PORT_TP
;
1255 u32
gelic_net_get_rx_csum(struct net_device
*netdev
)
1257 struct gelic_card
*card
= netdev_card(netdev
);
1259 return card
->rx_csum
;
1262 int gelic_net_set_rx_csum(struct net_device
*netdev
, u32 data
)
1264 struct gelic_card
*card
= netdev_card(netdev
);
1266 card
->rx_csum
= data
;
1270 static void gelic_net_get_wol(struct net_device
*netdev
,
1271 struct ethtool_wolinfo
*wol
)
1273 if (0 <= ps3_compare_firmware_version(2, 2, 0))
1274 wol
->supported
= WAKE_MAGIC
;
1278 wol
->wolopts
= ps3_sys_manager_get_wol() ? wol
->supported
: 0;
1279 memset(&wol
->sopass
, 0, sizeof(wol
->sopass
));
1281 static int gelic_net_set_wol(struct net_device
*netdev
,
1282 struct ethtool_wolinfo
*wol
)
1285 struct gelic_card
*card
;
1288 if (ps3_compare_firmware_version(2, 2, 0) < 0 ||
1289 !capable(CAP_NET_ADMIN
))
1292 if (wol
->wolopts
& ~WAKE_MAGIC
)
1295 card
= netdev_card(netdev
);
1296 if (wol
->wolopts
& WAKE_MAGIC
) {
1297 status
= lv1_net_control(bus_id(card
), dev_id(card
),
1299 GELIC_LV1_WOL_MAGIC_PACKET
,
1300 0, GELIC_LV1_WOL_MP_ENABLE
,
1303 pr_info("%s: enabling WOL failed %d\n", __func__
,
1308 status
= lv1_net_control(bus_id(card
), dev_id(card
),
1310 GELIC_LV1_WOL_ADD_MATCH_ADDR
,
1311 0, GELIC_LV1_WOL_MATCH_ALL
,
1314 ps3_sys_manager_set_wol(1);
1316 pr_info("%s: enabling WOL filter failed %d\n",
1321 status
= lv1_net_control(bus_id(card
), dev_id(card
),
1323 GELIC_LV1_WOL_MAGIC_PACKET
,
1324 0, GELIC_LV1_WOL_MP_DISABLE
,
1327 pr_info("%s: disabling WOL failed %d\n", __func__
,
1332 status
= lv1_net_control(bus_id(card
), dev_id(card
),
1334 GELIC_LV1_WOL_DELETE_MATCH_ADDR
,
1335 0, GELIC_LV1_WOL_MATCH_ALL
,
1338 ps3_sys_manager_set_wol(0);
1340 pr_info("%s: removing WOL filter failed %d\n",
1349 static struct ethtool_ops gelic_ether_ethtool_ops
= {
1350 .get_drvinfo
= gelic_net_get_drvinfo
,
1351 .get_settings
= gelic_ether_get_settings
,
1352 .get_link
= ethtool_op_get_link
,
1353 .get_tx_csum
= ethtool_op_get_tx_csum
,
1354 .set_tx_csum
= ethtool_op_set_tx_csum
,
1355 .get_rx_csum
= gelic_net_get_rx_csum
,
1356 .set_rx_csum
= gelic_net_set_rx_csum
,
1357 .get_wol
= gelic_net_get_wol
,
1358 .set_wol
= gelic_net_set_wol
,
1362 * gelic_net_tx_timeout_task - task scheduled by the watchdog timeout
1363 * function (to be called not under interrupt status)
1364 * @work: work is context of tx timout task
1366 * called as task when tx hangs, resets interface (if interface is up)
1368 static void gelic_net_tx_timeout_task(struct work_struct
*work
)
1370 struct gelic_card
*card
=
1371 container_of(work
, struct gelic_card
, tx_timeout_task
);
1372 struct net_device
*netdev
= card
->netdev
[GELIC_PORT_ETHERNET
];
1374 dev_info(ctodev(card
), "%s:Timed out. Restarting... \n", __func__
);
1376 if (!(netdev
->flags
& IFF_UP
))
1379 netif_device_detach(netdev
);
1380 gelic_net_stop(netdev
);
1382 gelic_net_open(netdev
);
1383 netif_device_attach(netdev
);
1386 atomic_dec(&card
->tx_timeout_task_counter
);
1390 * gelic_net_tx_timeout - called when the tx timeout watchdog kicks in.
1391 * @netdev: interface device structure
1393 * called, if tx hangs. Schedules a task that resets the interface
1395 void gelic_net_tx_timeout(struct net_device
*netdev
)
1397 struct gelic_card
*card
;
1399 card
= netdev_card(netdev
);
1400 atomic_inc(&card
->tx_timeout_task_counter
);
1401 if (netdev
->flags
& IFF_UP
)
1402 schedule_work(&card
->tx_timeout_task
);
1404 atomic_dec(&card
->tx_timeout_task_counter
);
1407 static const struct net_device_ops gelic_netdevice_ops
= {
1408 .ndo_open
= gelic_net_open
,
1409 .ndo_stop
= gelic_net_stop
,
1410 .ndo_start_xmit
= gelic_net_xmit
,
1411 .ndo_set_multicast_list
= gelic_net_set_multi
,
1412 .ndo_change_mtu
= gelic_net_change_mtu
,
1413 .ndo_tx_timeout
= gelic_net_tx_timeout
,
1414 .ndo_validate_addr
= eth_validate_addr
,
1415 #ifdef CONFIG_NET_POLL_CONTROLLER
1416 .ndo_poll_controller
= gelic_net_poll_controller
,
1421 * gelic_ether_setup_netdev_ops - initialization of net_device operations
1422 * @netdev: net_device structure
1424 * fills out function pointers in the net_device structure
1426 static void __devinit
gelic_ether_setup_netdev_ops(struct net_device
*netdev
,
1427 struct napi_struct
*napi
)
1429 netdev
->watchdog_timeo
= GELIC_NET_WATCHDOG_TIMEOUT
;
1431 netif_napi_add(netdev
, napi
,
1432 gelic_net_poll
, GELIC_NET_NAPI_WEIGHT
);
1433 netdev
->ethtool_ops
= &gelic_ether_ethtool_ops
;
1434 netdev
->netdev_ops
= &gelic_netdevice_ops
;
1438 * gelic_ether_setup_netdev - initialization of net_device
1439 * @netdev: net_device structure
1440 * @card: card structure
1442 * Returns 0 on success or <0 on failure
1444 * gelic_ether_setup_netdev initializes the net_device structure
1447 int __devinit
gelic_net_setup_netdev(struct net_device
*netdev
,
1448 struct gelic_card
*card
)
1453 netdev
->features
= NETIF_F_IP_CSUM
;
1455 status
= lv1_net_control(bus_id(card
), dev_id(card
),
1456 GELIC_LV1_GET_MAC_ADDRESS
,
1459 if (status
|| !is_valid_ether_addr((u8
*)&v1
)) {
1460 dev_info(ctodev(card
),
1461 "%s:lv1_net_control GET_MAC_ADDR failed %d\n",
1465 memcpy(netdev
->dev_addr
, &v1
, ETH_ALEN
);
1467 if (card
->vlan_required
) {
1468 netdev
->hard_header_len
+= VLAN_HLEN
;
1470 * As vlan is internally used,
1471 * we can not receive vlan packets
1473 netdev
->features
|= NETIF_F_VLAN_CHALLENGED
;
1476 status
= register_netdev(netdev
);
1478 dev_err(ctodev(card
), "%s:Couldn't register %s %d\n",
1479 __func__
, netdev
->name
, status
);
1482 dev_info(ctodev(card
), "%s: MAC addr %pM\n",
1483 netdev
->name
, netdev
->dev_addr
);
1489 * gelic_alloc_card_net - allocates net_device and card structure
1491 * returns the card structure or NULL in case of errors
1493 * the card and net_device structures are linked to each other
1495 #define GELIC_ALIGN (32)
1496 static struct gelic_card
* __devinit
gelic_alloc_card_net(struct net_device
**netdev
)
1498 struct gelic_card
*card
;
1499 struct gelic_port
*port
;
1503 * gelic requires dma descriptor is 32 bytes aligned and
1504 * the hypervisor requires irq_status is 8 bytes aligned.
1506 BUILD_BUG_ON(offsetof(struct gelic_card
, irq_status
) % 8);
1507 BUILD_BUG_ON(offsetof(struct gelic_card
, descr
) % 32);
1509 sizeof(struct gelic_card
) +
1510 sizeof(struct gelic_descr
) * GELIC_NET_RX_DESCRIPTORS
+
1511 sizeof(struct gelic_descr
) * GELIC_NET_TX_DESCRIPTORS
+
1514 p
= kzalloc(alloc_size
, GFP_KERNEL
);
1517 card
= PTR_ALIGN(p
, GELIC_ALIGN
);
1523 *netdev
= alloc_etherdev(sizeof(struct gelic_port
));
1525 kfree(card
->unalign
);
1528 port
= netdev_priv(*netdev
);
1531 port
->netdev
= *netdev
;
1533 port
->type
= GELIC_PORT_ETHERNET
;
1536 card
->netdev
[GELIC_PORT_ETHERNET
] = *netdev
;
1538 INIT_WORK(&card
->tx_timeout_task
, gelic_net_tx_timeout_task
);
1539 init_waitqueue_head(&card
->waitq
);
1540 atomic_set(&card
->tx_timeout_task_counter
, 0);
1541 mutex_init(&card
->updown_lock
);
1542 atomic_set(&card
->users
, 0);
1547 static void __devinit
gelic_card_get_vlan_info(struct gelic_card
*card
)
1556 [GELIC_PORT_ETHERNET
] = {
1557 .tx
= GELIC_LV1_VLAN_TX_ETHERNET
,
1558 .rx
= GELIC_LV1_VLAN_RX_ETHERNET
1560 [GELIC_PORT_WIRELESS
] = {
1561 .tx
= GELIC_LV1_VLAN_TX_WIRELESS
,
1562 .rx
= GELIC_LV1_VLAN_RX_WIRELESS
1566 for (i
= 0; i
< ARRAY_SIZE(vlan_id_ix
); i
++) {
1568 status
= lv1_net_control(bus_id(card
), dev_id(card
),
1569 GELIC_LV1_GET_VLAN_ID
,
1572 if (status
|| !v1
) {
1573 if (status
!= LV1_NO_ENTRY
)
1574 dev_dbg(ctodev(card
),
1575 "get vlan id for tx(%d) failed(%d)\n",
1576 vlan_id_ix
[i
].tx
, status
);
1577 card
->vlan
[i
].tx
= 0;
1578 card
->vlan
[i
].rx
= 0;
1581 card
->vlan
[i
].tx
= (u16
)v1
;
1584 status
= lv1_net_control(bus_id(card
), dev_id(card
),
1585 GELIC_LV1_GET_VLAN_ID
,
1588 if (status
|| !v1
) {
1589 if (status
!= LV1_NO_ENTRY
)
1590 dev_info(ctodev(card
),
1591 "get vlan id for rx(%d) failed(%d)\n",
1592 vlan_id_ix
[i
].rx
, status
);
1593 card
->vlan
[i
].tx
= 0;
1594 card
->vlan
[i
].rx
= 0;
1597 card
->vlan
[i
].rx
= (u16
)v1
;
1599 dev_dbg(ctodev(card
), "vlan_id[%d] tx=%02x rx=%02x\n",
1600 i
, card
->vlan
[i
].tx
, card
->vlan
[i
].rx
);
1603 if (card
->vlan
[GELIC_PORT_ETHERNET
].tx
) {
1604 BUG_ON(!card
->vlan
[GELIC_PORT_WIRELESS
].tx
);
1605 card
->vlan_required
= 1;
1607 card
->vlan_required
= 0;
1609 /* check wirelss capable firmware */
1610 if (ps3_compare_firmware_version(1, 6, 0) < 0) {
1611 card
->vlan
[GELIC_PORT_WIRELESS
].tx
= 0;
1612 card
->vlan
[GELIC_PORT_WIRELESS
].rx
= 0;
1615 dev_info(ctodev(card
), "internal vlan %s\n",
1616 card
->vlan_required
? "enabled" : "disabled");
1619 * ps3_gelic_driver_probe - add a device to the control of this driver
1621 static int __devinit
ps3_gelic_driver_probe(struct ps3_system_bus_device
*dev
)
1623 struct gelic_card
*card
;
1624 struct net_device
*netdev
;
1627 pr_debug("%s: called\n", __func__
);
1628 result
= ps3_open_hv_device(dev
);
1631 dev_dbg(&dev
->core
, "%s:ps3_open_hv_device failed\n",
1636 result
= ps3_dma_region_create(dev
->d_region
);
1639 dev_dbg(&dev
->core
, "%s:ps3_dma_region_create failed(%d)\n",
1641 BUG_ON("check region type");
1642 goto fail_dma_region
;
1645 /* alloc card/netdevice */
1646 card
= gelic_alloc_card_net(&netdev
);
1648 dev_info(&dev
->core
, "%s:gelic_net_alloc_card failed\n",
1651 goto fail_alloc_card
;
1653 ps3_system_bus_set_drvdata(dev
, card
);
1656 /* get internal vlan info */
1657 gelic_card_get_vlan_info(card
);
1659 /* setup interrupt */
1660 result
= lv1_net_set_interrupt_status_indicator(bus_id(card
),
1662 ps3_mm_phys_to_lpar(__pa(&card
->irq_status
)),
1667 "%s:set_interrupt_status_indicator failed: %s\n",
1668 __func__
, ps3_result(result
));
1670 goto fail_status_indicator
;
1673 result
= ps3_sb_event_receive_port_setup(dev
, PS3_BINDING_CPU_ANY
,
1677 dev_info(ctodev(card
),
1678 "%s:gelic_net_open_device failed (%d)\n",
1681 goto fail_alloc_irq
;
1683 result
= request_irq(card
->irq
, gelic_card_interrupt
,
1684 IRQF_DISABLED
, netdev
->name
, card
);
1687 dev_info(ctodev(card
), "%s:request_irq failed (%d)\n",
1689 goto fail_request_irq
;
1692 /* setup card structure */
1693 card
->irq_mask
= GELIC_CARD_RXINT
| GELIC_CARD_TXINT
|
1694 GELIC_CARD_PORT_STATUS_CHANGED
;
1695 card
->rx_csum
= GELIC_CARD_RX_CSUM_DEFAULT
;
1698 if (gelic_card_init_chain(card
, &card
->tx_chain
,
1699 card
->descr
, GELIC_NET_TX_DESCRIPTORS
))
1701 if (gelic_card_init_chain(card
, &card
->rx_chain
,
1702 card
->descr
+ GELIC_NET_TX_DESCRIPTORS
,
1703 GELIC_NET_RX_DESCRIPTORS
))
1707 card
->tx_top
= card
->tx_chain
.head
;
1708 card
->rx_top
= card
->rx_chain
.head
;
1709 dev_dbg(ctodev(card
), "descr rx %p, tx %p, size %#lx, num %#x\n",
1710 card
->rx_top
, card
->tx_top
, sizeof(struct gelic_descr
),
1711 GELIC_NET_RX_DESCRIPTORS
);
1712 /* allocate rx skbs */
1713 if (gelic_card_alloc_rx_skbs(card
))
1714 goto fail_alloc_skbs
;
1716 spin_lock_init(&card
->tx_lock
);
1717 card
->tx_dma_progress
= 0;
1719 /* setup net_device structure */
1720 netdev
->irq
= card
->irq
;
1721 SET_NETDEV_DEV(netdev
, &card
->dev
->core
);
1722 gelic_ether_setup_netdev_ops(netdev
, &card
->napi
);
1723 result
= gelic_net_setup_netdev(netdev
, card
);
1725 dev_dbg(&dev
->core
, "%s: setup_netdev failed %d",
1727 goto fail_setup_netdev
;
1730 #ifdef CONFIG_GELIC_WIRELESS
1731 if (gelic_wl_driver_probe(card
)) {
1732 dev_dbg(&dev
->core
, "%s: WL init failed\n", __func__
);
1733 goto fail_setup_netdev
;
1736 pr_debug("%s: done\n", __func__
);
1741 gelic_card_free_chain(card
, card
->rx_chain
.head
);
1743 gelic_card_free_chain(card
, card
->tx_chain
.head
);
1745 free_irq(card
->irq
, card
);
1746 netdev
->irq
= NO_IRQ
;
1748 ps3_sb_event_receive_port_destroy(dev
, card
->irq
);
1750 lv1_net_set_interrupt_status_indicator(bus_id(card
),
1753 fail_status_indicator
:
1754 ps3_system_bus_set_drvdata(dev
, NULL
);
1755 kfree(netdev_card(netdev
)->unalign
);
1756 free_netdev(netdev
);
1758 ps3_dma_region_free(dev
->d_region
);
1760 ps3_close_hv_device(dev
);
1766 * ps3_gelic_driver_remove - remove a device from the control of this driver
1769 static int ps3_gelic_driver_remove(struct ps3_system_bus_device
*dev
)
1771 struct gelic_card
*card
= ps3_system_bus_get_drvdata(dev
);
1772 struct net_device
*netdev0
;
1773 pr_debug("%s: called\n", __func__
);
1775 #ifdef CONFIG_GELIC_WIRELESS
1776 gelic_wl_driver_remove(card
);
1778 /* stop interrupt */
1779 gelic_card_set_irq_mask(card
, 0);
1781 /* turn off DMA, force end */
1782 gelic_card_disable_rxdmac(card
);
1783 gelic_card_disable_txdmac(card
);
1785 /* release chains */
1786 gelic_card_release_tx_chain(card
, 1);
1787 gelic_card_release_rx_chain(card
);
1789 gelic_card_free_chain(card
, card
->tx_top
);
1790 gelic_card_free_chain(card
, card
->rx_top
);
1792 netdev0
= card
->netdev
[GELIC_PORT_ETHERNET
];
1793 /* disconnect event port */
1794 free_irq(card
->irq
, card
);
1795 netdev0
->irq
= NO_IRQ
;
1796 ps3_sb_event_receive_port_destroy(card
->dev
, card
->irq
);
1798 wait_event(card
->waitq
,
1799 atomic_read(&card
->tx_timeout_task_counter
) == 0);
1801 lv1_net_set_interrupt_status_indicator(bus_id(card
), dev_id(card
),
1804 unregister_netdev(netdev0
);
1805 kfree(netdev_card(netdev0
)->unalign
);
1806 free_netdev(netdev0
);
1808 ps3_system_bus_set_drvdata(dev
, NULL
);
1810 ps3_dma_region_free(dev
->d_region
);
1812 ps3_close_hv_device(dev
);
1814 pr_debug("%s: done\n", __func__
);
1818 static struct ps3_system_bus_driver ps3_gelic_driver
= {
1819 .match_id
= PS3_MATCH_ID_GELIC
,
1820 .probe
= ps3_gelic_driver_probe
,
1821 .remove
= ps3_gelic_driver_remove
,
1822 .shutdown
= ps3_gelic_driver_remove
,
1823 .core
.name
= "ps3_gelic_driver",
1824 .core
.owner
= THIS_MODULE
,
1827 static int __init
ps3_gelic_driver_init (void)
1829 return firmware_has_feature(FW_FEATURE_PS3_LV1
)
1830 ? ps3_system_bus_driver_register(&ps3_gelic_driver
)
1834 static void __exit
ps3_gelic_driver_exit (void)
1836 ps3_system_bus_driver_unregister(&ps3_gelic_driver
);
1839 module_init(ps3_gelic_driver_init
);
1840 module_exit(ps3_gelic_driver_exit
);
1842 MODULE_ALIAS(PS3_MODULE_ALIAS_GELIC
);