drivers/net/ps3_gelic_net.c

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