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