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