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