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