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