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
  50 #define DRV_NAME "Gelic Network Driver"
  51 #define DRV_VERSION "1.0"
  52
  53 MODULE_AUTHOR("SCE Inc.");
  54 MODULE_DESCRIPTION("Gelic Network driver");
  55 MODULE_LICENSE("GPL");
  56
  57 static inline struct device *ctodev(struct gelic_card *card)
  58 {
  59         return &card->dev->core;
  60 }
  61 static inline u64 bus_id(struct gelic_card *card)
  62 {
  63         return card->dev->bus_id;
  64 }
  65 static inline u64 dev_id(struct gelic_card *card)
  66 {
  67         return card->dev->dev_id;
  68 }
  69
  70 /* set irq_mask */
  71 static int gelic_card_set_irq_mask(struct gelic_card *card, u64 mask)
  72 {
  73         int status;
  74
  75         status = lv1_net_set_interrupt_mask(bus_id(card), dev_id(card),
  76                                             mask, 0);
  77         if (status)
  78                 dev_info(ctodev(card),
  79                          "lv1_net_set_interrupt_mask failed %d\n", status);
  80         return status;
  81 }
  82 static inline void gelic_card_rx_irq_on(struct gelic_card *card)
  83 {
  84         gelic_card_set_irq_mask(card, card->ghiintmask | GELIC_CARD_RXINT);
  85 }
  86 static inline void gelic_card_rx_irq_off(struct gelic_card *card)
  87 {
  88         gelic_card_set_irq_mask(card, card->ghiintmask & ~GELIC_CARD_RXINT);
  89 }
  90 /**
  91  * gelic_descr_get_status -- returns the status of a descriptor
  92  * @descr: descriptor to look at
  93  *
  94  * returns the status as in the dmac_cmd_status field of the descriptor
  95  */
  96 static enum gelic_descr_dma_status
  97 gelic_descr_get_status(struct gelic_descr *descr)
  98 {
  99         return be32_to_cpu(descr->dmac_cmd_status) & GELIC_DESCR_DMA_STAT_MASK;
 100 }
 101
 102 /**
 103  * gelic_descr_set_status -- sets the status of a descriptor
 104  * @descr: descriptor to change
 105  * @status: status to set in the descriptor
 106  *
 107  * changes the status to the specified value. Doesn't change other bits
 108  * in the status
 109  */
 110 static void gelic_descr_set_status(struct gelic_descr *descr,
 111                                    enum gelic_descr_dma_status status)
 112 {
 113         descr->dmac_cmd_status = cpu_to_be32(status |
 114                 (be32_to_cpu(descr->dmac_cmd_status) &
 115                  ~GELIC_DESCR_DMA_STAT_MASK));
 116         /*
 117          * dma_cmd_status field is used to indicate whether the descriptor
 118          * is valid or not.
 119          * Usually caller of this function wants to inform that to the
 120          * hardware, so we assure here the hardware sees the change.
 121          */
 122         wmb();
 123 }
 124
 125 /**
 126  * gelic_card_free_chain - free descriptor chain
 127  * @card: card structure
 128  * @descr_in: address of desc
 129  */
 130 static void gelic_card_free_chain(struct gelic_card *card,
 131                                   struct gelic_descr *descr_in)
 132 {
 133         struct gelic_descr *descr;
 134
 135         for (descr = descr_in; descr && descr->bus_addr; descr = descr->next) {
 136                 dma_unmap_single(ctodev(card), descr->bus_addr,
 137                                  GELIC_DESCR_SIZE, DMA_BIDIRECTIONAL);
 138                 descr->bus_addr = 0;
 139         }
 140 }
 141
 142 /**
 143  * gelic_card_init_chain - links descriptor chain
 144  * @card: card structure
 145  * @chain: address of chain
 146  * @start_descr: address of descriptor array
 147  * @no: number of descriptors
 148  *
 149  * we manage a circular list that mirrors the hardware structure,
 150  * except that the hardware uses bus addresses.
 151  *
 152  * returns 0 on success, <0 on failure
 153  */
 154 static int gelic_card_init_chain(struct gelic_card *card,
 155                                  struct gelic_descr_chain *chain,
 156                                  struct gelic_descr *start_descr, int no)
 157 {
 158         int i;
 159         struct gelic_descr *descr;
 160
 161         descr = start_descr;
 162         memset(descr, 0, sizeof(*descr) * no);
 163
 164         /* set up the hardware pointers in each descriptor */
 165         for (i = 0; i < no; i++, descr++) {
 166                 gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
 167                 descr->bus_addr =
 168                         dma_map_single(ctodev(card), descr,
 169                                        GELIC_DESCR_SIZE,
 170                                        DMA_BIDIRECTIONAL);
 171
 172                 if (!descr->bus_addr)
 173                         goto iommu_error;
 174
 175                 descr->next = descr + 1;
 176                 descr->prev = descr - 1;
 177         }
 178         /* make them as ring */
 179         (descr - 1)->next = start_descr;
 180         start_descr->prev = (descr - 1);
 181
 182         /* chain bus addr of hw descriptor */
 183         descr = start_descr;
 184         for (i = 0; i < no; i++, descr++) {
 185                 descr->next_descr_addr = cpu_to_be32(descr->next->bus_addr);
 186         }
 187
 188         chain->head = start_descr;
 189         chain->tail = start_descr;
 190
 191         /* do not chain last hw descriptor */
 192         (descr - 1)->next_descr_addr = 0;
 193
 194         return 0;
 195
 196 iommu_error:
 197         for (i--, descr--; 0 <= i; i--, descr--)
 198                 if (descr->bus_addr)
 199                         dma_unmap_single(ctodev(card), descr->bus_addr,
 200                                          GELIC_DESCR_SIZE,
 201                                          DMA_BIDIRECTIONAL);
 202         return -ENOMEM;
 203 }
 204
 205 /**
 206  * gelic_descr_prepare_rx - reinitializes a rx descriptor
 207  * @card: card structure
 208  * @descr: descriptor to re-init
 209  *
 210  * return 0 on succes, <0 on failure
 211  *
 212  * allocates a new rx skb, iommu-maps it and attaches it to the descriptor.
 213  * Activate the descriptor state-wise
 214  */
 215 static int gelic_descr_prepare_rx(struct gelic_card *card,
 216                                       struct gelic_descr *descr)
 217 {
 218         int offset;
 219         unsigned int bufsize;
 220
 221         if (gelic_descr_get_status(descr) !=  GELIC_DESCR_DMA_NOT_IN_USE)
 222                 dev_info(ctodev(card), "%s: ERROR status \n", __func__);
 223
 224         /* we need to round up the buffer size to a multiple of 128 */
 225         bufsize = ALIGN(GELIC_NET_MAX_MTU, GELIC_NET_RXBUF_ALIGN);
 226
 227         /* and we need to have it 128 byte aligned, therefore we allocate a
 228          * bit more */
 229         descr->skb = netdev_alloc_skb(card->netdev,
 230                 bufsize + GELIC_NET_RXBUF_ALIGN - 1);
 231         if (!descr->skb) {
 232                 descr->buf_addr = 0; /* tell DMAC don't touch memory */
 233                 dev_info(ctodev(card),
 234                          "%s:allocate skb failed !!\n", __func__);
 235                 return -ENOMEM;
 236         }
 237         descr->buf_size = cpu_to_be32(bufsize);
 238         descr->dmac_cmd_status = 0;
 239         descr->result_size = 0;
 240         descr->valid_size = 0;
 241         descr->data_error = 0;
 242
 243         offset = ((unsigned long)descr->skb->data) &
 244                 (GELIC_NET_RXBUF_ALIGN - 1);
 245         if (offset)
 246                 skb_reserve(descr->skb, GELIC_NET_RXBUF_ALIGN - offset);
 247         /* io-mmu-map the skb */
 248         descr->buf_addr = cpu_to_be32(dma_map_single(ctodev(card),
 249                                                      descr->skb->data,
 250                                                      GELIC_NET_MAX_MTU,
 251                                                      DMA_FROM_DEVICE));
 252         if (!descr->buf_addr) {
 253                 dev_kfree_skb_any(descr->skb);
 254                 descr->skb = NULL;
 255                 dev_info(ctodev(card),
 256                          "%s:Could not iommu-map rx buffer\n", __func__);
 257                 gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
 258                 return -ENOMEM;
 259         } else {
 260                 gelic_descr_set_status(descr, GELIC_DESCR_DMA_CARDOWNED);
 261                 return 0;
 262         }
 263 }
 264
 265 /**
 266  * gelic_card_release_rx_chain - free all skb of rx descr
 267  * @card: card structure
 268  *
 269  */
 270 static void gelic_card_release_rx_chain(struct gelic_card *card)
 271 {
 272         struct gelic_descr *descr = card->rx_chain.head;
 273
 274         do {
 275                 if (descr->skb) {
 276                         dma_unmap_single(ctodev(card),
 277                                          be32_to_cpu(descr->buf_addr),
 278                                          descr->skb->len,
 279                                          DMA_FROM_DEVICE);
 280                         descr->buf_addr = 0;
 281                         dev_kfree_skb_any(descr->skb);
 282                         descr->skb = NULL;
 283                         gelic_descr_set_status(descr,
 284                                                GELIC_DESCR_DMA_NOT_IN_USE);
 285                 }
 286                 descr = descr->next;
 287         } while (descr != card->rx_chain.head);
 288 }
 289
 290 /**
 291  * gelic_card_fill_rx_chain - fills descriptors/skbs in the rx chains
 292  * @card: card structure
 293  *
 294  * fills all descriptors in the rx chain: allocates skbs
 295  * and iommu-maps them.
 296  * returns 0 on success, < 0 on failure
 297  */
 298 static int gelic_card_fill_rx_chain(struct gelic_card *card)
 299 {
 300         struct gelic_descr *descr = card->rx_chain.head;
 301         int ret;
 302
 303         do {
 304                 if (!descr->skb) {
 305                         ret = gelic_descr_prepare_rx(card, descr);
 306                         if (ret)
 307                                 goto rewind;
 308                 }
 309                 descr = descr->next;
 310         } while (descr != card->rx_chain.head);
 311
 312         return 0;
 313 rewind:
 314         gelic_card_release_rx_chain(card);
 315         return ret;
 316 }
 317
 318 /**
 319  * gelic_card_alloc_rx_skbs - allocates rx skbs in rx descriptor chains
 320  * @card: card structure
 321  *
 322  * returns 0 on success, < 0 on failure
 323  */
 324 static int gelic_card_alloc_rx_skbs(struct gelic_card *card)
 325 {
 326         struct gelic_descr_chain *chain;
 327         int ret;
 328         chain = &card->rx_chain;
 329         ret = gelic_card_fill_rx_chain(card);
 330         chain->head = card->rx_top->prev; /* point to the last */
 331         return ret;
 332 }
 333
 334 /**
 335  * gelic_descr_release_tx - processes a used tx descriptor
 336  * @card: card structure
 337  * @descr: descriptor to release
 338  *
 339  * releases a used tx descriptor (unmapping, freeing of skb)
 340  */
 341 static void gelic_descr_release_tx(struct gelic_card *card,
 342                             struct gelic_descr *descr)
 343 {
 344         struct sk_buff *skb = descr->skb;
 345
 346 #ifdef DEBUG
 347         BUG_ON(!(be32_to_cpu(descr->data_status) &
 348                  (1 << GELIC_DESCR_TX_DMA_FRAME_TAIL)));
 349 #endif
 350         dma_unmap_single(ctodev(card),
 351                          be32_to_cpu(descr->buf_addr), skb->len, DMA_TO_DEVICE);
 352         dev_kfree_skb_any(skb);
 353
 354         descr->buf_addr = 0;
 355         descr->buf_size = 0;
 356         descr->next_descr_addr = 0;
 357         descr->result_size = 0;
 358         descr->valid_size = 0;
 359         descr->data_status = 0;
 360         descr->data_error = 0;
 361         descr->skb = NULL;
 362
 363         /* set descr status */
 364         gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
 365 }
 366
 367 /**
 368  * gelic_card_release_tx_chain - processes sent tx descriptors
 369  * @card: adapter structure
 370  * @stop: net_stop sequence
 371  *
 372  * releases the tx descriptors that gelic has finished with
 373  */
 374 static void gelic_card_release_tx_chain(struct gelic_card *card, int stop)
 375 {
 376         struct gelic_descr_chain *tx_chain;
 377         enum gelic_descr_dma_status status;
 378         int release = 0;
 379
 380         for (tx_chain = &card->tx_chain;
 381              tx_chain->head != tx_chain->tail && tx_chain->tail;
 382              tx_chain->tail = tx_chain->tail->next) {
 383                 status = gelic_descr_get_status(tx_chain->tail);
 384                 switch (status) {
 385                 case GELIC_DESCR_DMA_RESPONSE_ERROR:
 386                 case GELIC_DESCR_DMA_PROTECTION_ERROR:
 387                 case GELIC_DESCR_DMA_FORCE_END:
 388                         if (printk_ratelimit())
 389                                 dev_info(ctodev(card),
 390                                          "%s: forcing end of tx descriptor " \
 391                                          "with status %x\n",
 392                                          __func__, status);
 393                         card->netdev->stats.tx_dropped++;
 394                         break;
 395
 396                 case GELIC_DESCR_DMA_COMPLETE:
 397                         if (tx_chain->tail->skb) {
 398                                 card->netdev->stats.tx_packets++;
 399                                 card->netdev->stats.tx_bytes +=
 400                                         tx_chain->tail->skb->len;
 401                         }
 402                         break;
 403
 404                 case GELIC_DESCR_DMA_CARDOWNED:
 405                         /* pending tx request */
 406                 default:
 407                         /* any other value (== GELIC_DESCR_DMA_NOT_IN_USE) */
 408                         if (!stop)
 409                                 goto out;
 410                 }
 411                 gelic_descr_release_tx(card, tx_chain->tail);
 412                 release ++;
 413         }
 414 out:
 415         if (!stop && release)
 416                 netif_wake_queue(card->netdev);
 417 }
 418
 419 /**
 420  * gelic_net_set_multi - sets multicast addresses and promisc flags
 421  * @netdev: interface device structure
 422  *
 423  * gelic_net_set_multi configures multicast addresses as needed for the
 424  * netdev interface. It also sets up multicast, allmulti and promisc
 425  * flags appropriately
 426  */
 427 static void gelic_net_set_multi(struct net_device *netdev)
 428 {
 429         struct gelic_card *card = netdev_priv(netdev);
 430         struct dev_mc_list *mc;
 431         unsigned int i;
 432         uint8_t *p;
 433         u64 addr;
 434         int status;
 435
 436         /* clear all multicast address */
 437         status = lv1_net_remove_multicast_address(bus_id(card), dev_id(card),
 438                                                   0, 1);
 439         if (status)
 440                 dev_err(ctodev(card),
 441                         "lv1_net_remove_multicast_address failed %d\n",
 442                         status);
 443         /* set broadcast address */
 444         status = lv1_net_add_multicast_address(bus_id(card), dev_id(card),
 445                                                GELIC_NET_BROADCAST_ADDR, 0);
 446         if (status)
 447                 dev_err(ctodev(card),
 448                         "lv1_net_add_multicast_address failed, %d\n",
 449                         status);
 450
 451         if (netdev->flags & IFF_ALLMULTI
 452                 || netdev->mc_count > GELIC_NET_MC_COUNT_MAX) { /* list max */
 453                 status = lv1_net_add_multicast_address(bus_id(card),
 454                                                        dev_id(card),
 455                                                        0, 1);
 456                 if (status)
 457                         dev_err(ctodev(card),
 458                                 "lv1_net_add_multicast_address failed, %d\n",
 459                                 status);
 460                 return;
 461         }
 462
 463         /* set multicast address */
 464         for (mc = netdev->mc_list; mc; mc = mc->next) {
 465                 addr = 0;
 466                 p = mc->dmi_addr;
 467                 for (i = 0; i < ETH_ALEN; i++) {
 468                         addr <<= 8;
 469                         addr |= *p++;
 470                 }
 471                 status = lv1_net_add_multicast_address(bus_id(card),
 472                                                        dev_id(card),
 473                                                        addr, 0);
 474                 if (status)
 475                         dev_err(ctodev(card),
 476                                 "lv1_net_add_multicast_address failed, %d\n",
 477                                 status);
 478         }
 479 }
 480
 481 /**
 482  * gelic_card_enable_rxdmac - enables the receive DMA controller
 483  * @card: card structure
 484  *
 485  * gelic_card_enable_rxdmac enables the DMA controller by setting RX_DMA_EN
 486  * in the GDADMACCNTR register
 487  */
 488 static inline void gelic_card_enable_rxdmac(struct gelic_card *card)
 489 {
 490         int status;
 491
 492         status = lv1_net_start_rx_dma(bus_id(card), dev_id(card),
 493                                 card->rx_chain.tail->bus_addr, 0);
 494         if (status)
 495                 dev_info(ctodev(card),
 496                          "lv1_net_start_rx_dma failed, status=%d\n", status);
 497 }
 498
 499 /**
 500  * gelic_card_disable_rxdmac - disables the receive DMA controller
 501  * @card: card structure
 502  *
 503  * gelic_card_disable_rxdmac terminates processing on the DMA controller by
 504  * turing off DMA and issueing a force end
 505  */
 506 static inline void gelic_card_disable_rxdmac(struct gelic_card *card)
 507 {
 508         int status;
 509
 510         /* this hvc blocks until the DMA in progress really stopped */
 511         status = lv1_net_stop_rx_dma(bus_id(card), dev_id(card), 0);
 512         if (status)
 513                 dev_err(ctodev(card),
 514                         "lv1_net_stop_rx_dma faild, %d\n", status);
 515 }
 516
 517 /**
 518  * gelic_card_disable_txdmac - disables the transmit DMA controller
 519  * @card: card structure
 520  *
 521  * gelic_card_disable_txdmac terminates processing on the DMA controller by
 522  * turing off DMA and issueing a force end
 523  */
 524 static inline void gelic_card_disable_txdmac(struct gelic_card *card)
 525 {
 526         int status;
 527
 528         /* this hvc blocks until the DMA in progress really stopped */
 529         status = lv1_net_stop_tx_dma(bus_id(card), dev_id(card), 0);
 530         if (status)
 531                 dev_err(ctodev(card),
 532                         "lv1_net_stop_tx_dma faild, status=%d\n", status);
 533 }
 534
 535 /**
 536  * gelic_net_stop - called upon ifconfig down
 537  * @netdev: interface device structure
 538  *
 539  * always returns 0
 540  */
 541 static int gelic_net_stop(struct net_device *netdev)
 542 {
 543         struct gelic_card *card = netdev_priv(netdev);
 544
 545         napi_disable(&card->napi);
 546         netif_stop_queue(netdev);
 547
 548         /* turn off DMA, force end */
 549         gelic_card_disable_rxdmac(card);
 550         gelic_card_disable_txdmac(card);
 551
 552         gelic_card_set_irq_mask(card, 0);
 553
 554         /* disconnect event port */
 555         free_irq(card->netdev->irq, card->netdev);
 556         ps3_sb_event_receive_port_destroy(card->dev, card->netdev->irq);
 557         card->netdev->irq = NO_IRQ;
 558
 559         netif_carrier_off(netdev);
 560
 561         /* release chains */
 562         gelic_card_release_tx_chain(card, 1);
 563         gelic_card_release_rx_chain(card);
 564
 565         gelic_card_free_chain(card, card->tx_top);
 566         gelic_card_free_chain(card, card->rx_top);
 567
 568         return 0;
 569 }
 570
 571 /**
 572  * gelic_card_get_next_tx_descr - returns the next available tx descriptor
 573  * @card: device structure to get descriptor from
 574  *
 575  * returns the address of the next descriptor, or NULL if not available.
 576  */
 577 static struct gelic_descr *
 578 gelic_card_get_next_tx_descr(struct gelic_card *card)
 579 {
 580         if (!card->tx_chain.head)
 581                 return NULL;
 582         /*  see if the next descriptor is free */
 583         if (card->tx_chain.tail != card->tx_chain.head->next &&
 584             gelic_descr_get_status(card->tx_chain.head) ==
 585             GELIC_DESCR_DMA_NOT_IN_USE)
 586                 return card->tx_chain.head;
 587         else
 588                 return NULL;
 589
 590 }
 591
 592 /**
 593  * gelic_descr_set_tx_cmdstat - sets the tx descriptor command field
 594  * @descr: descriptor structure to fill out
 595  * @skb: packet to consider
 596  *
 597  * fills out the command and status field of the descriptor structure,
 598  * depending on hardware checksum settings. This function assumes a wmb()
 599  * has executed before.
 600  */
 601 static void gelic_descr_set_tx_cmdstat(struct gelic_descr *descr,
 602                                        struct sk_buff *skb)
 603 {
 604         if (skb->ip_summed != CHECKSUM_PARTIAL)
 605                 descr->dmac_cmd_status =
 606                         cpu_to_be32(GELIC_DESCR_DMA_CMD_NO_CHKSUM |
 607                                     GELIC_DESCR_TX_DMA_FRAME_TAIL);
 608         else {
 609                 /* is packet ip?
 610                  * if yes: tcp? udp? */
 611                 if (skb->protocol == htons(ETH_P_IP)) {
 612                         if (ip_hdr(skb)->protocol == IPPROTO_TCP)
 613                                 descr->dmac_cmd_status =
 614                                 cpu_to_be32(GELIC_DESCR_DMA_CMD_TCP_CHKSUM |
 615                                             GELIC_DESCR_TX_DMA_FRAME_TAIL);
 616
 617                         else if (ip_hdr(skb)->protocol == IPPROTO_UDP)
 618                                 descr->dmac_cmd_status =
 619                                 cpu_to_be32(GELIC_DESCR_DMA_CMD_UDP_CHKSUM |
 620                                             GELIC_DESCR_TX_DMA_FRAME_TAIL);
 621                         else    /*
 622                                  * the stack should checksum non-tcp and non-udp
 623                                  * packets on his own: NETIF_F_IP_CSUM
 624                                  */
 625                                 descr->dmac_cmd_status =
 626                                 cpu_to_be32(GELIC_DESCR_DMA_CMD_NO_CHKSUM |
 627                                             GELIC_DESCR_TX_DMA_FRAME_TAIL);
 628                 }
 629         }
 630 }
 631
 632 static inline struct sk_buff *gelic_put_vlan_tag(struct sk_buff *skb,
 633                                                  unsigned short tag)
 634 {
 635         struct vlan_ethhdr *veth;
 636         static unsigned int c;
 637
 638         if (skb_headroom(skb) < VLAN_HLEN) {
 639                 struct sk_buff *sk_tmp = skb;
 640                 pr_debug("%s: hd=%d c=%ud\n", __func__, skb_headroom(skb), c);
 641                 skb = skb_realloc_headroom(sk_tmp, VLAN_HLEN);
 642                 if (!skb)
 643                         return NULL;
 644                 dev_kfree_skb_any(sk_tmp);
 645         }
 646         veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
 647
 648         /* Move the mac addresses to the top of buffer */
 649         memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN);
 650
 651         veth->h_vlan_proto = __constant_htons(ETH_P_8021Q);
 652         veth->h_vlan_TCI = htons(tag);
 653
 654         return skb;
 655 }
 656
 657 /**
 658  * gelic_descr_prepare_tx - get dma address of skb_data
 659  * @card: card structure
 660  * @descr: descriptor structure
 661  * @skb: packet to use
 662  *
 663  * returns 0 on success, <0 on failure.
 664  *
 665  */
 666 static int gelic_descr_prepare_tx(struct gelic_card *card,
 667                                   struct gelic_descr *descr,
 668                                   struct sk_buff *skb)
 669 {
 670         dma_addr_t buf;
 671
 672         if (card->vlan_index != -1) {
 673                 struct sk_buff *skb_tmp;
 674                 skb_tmp = gelic_put_vlan_tag(skb,
 675                                              card->vlan_id[card->vlan_index]);
 676                 if (!skb_tmp)
 677                         return -ENOMEM;
 678                 skb = skb_tmp;
 679         }
 680
 681         buf = dma_map_single(ctodev(card), skb->data, skb->len, DMA_TO_DEVICE);
 682
 683         if (!buf) {
 684                 dev_err(ctodev(card),
 685                         "dma map 2 failed (%p, %i). Dropping packet\n",
 686                         skb->data, skb->len);
 687                 return -ENOMEM;
 688         }
 689
 690         descr->buf_addr = cpu_to_be32(buf);
 691         descr->buf_size = cpu_to_be32(skb->len);
 692         descr->skb = skb;
 693         descr->data_status = 0;
 694         descr->next_descr_addr = 0; /* terminate hw descr */
 695         gelic_descr_set_tx_cmdstat(descr, skb);
 696
 697         /* bump free descriptor pointer */
 698         card->tx_chain.head = descr->next;
 699         return 0;
 700 }
 701
 702 /**
 703  * gelic_card_kick_txdma - enables TX DMA processing
 704  * @card: card structure
 705  * @descr: descriptor address to enable TX processing at
 706  *
 707  */
 708 static int gelic_card_kick_txdma(struct gelic_card *card,
 709                                  struct gelic_descr *descr)
 710 {
 711         int status = 0;
 712
 713         if (card->tx_dma_progress)
 714                 return 0;
 715
 716         if (gelic_descr_get_status(descr) == GELIC_DESCR_DMA_CARDOWNED) {
 717                 card->tx_dma_progress = 1;
 718                 status = lv1_net_start_tx_dma(bus_id(card), dev_id(card),
 719                                               descr->bus_addr, 0);
 720                 if (status)
 721                         dev_info(ctodev(card), "lv1_net_start_txdma failed," \
 722                                  "status=%d\n", status);
 723         }
 724         return status;
 725 }
 726
 727 /**
 728  * gelic_net_xmit - transmits a frame over the device
 729  * @skb: packet to send out
 730  * @netdev: interface device structure
 731  *
 732  * returns 0 on success, <0 on failure
 733  */
 734 static int gelic_net_xmit(struct sk_buff *skb, struct net_device *netdev)
 735 {
 736         struct gelic_card *card = netdev_priv(netdev);
 737         struct gelic_descr *descr;
 738         int result;
 739         unsigned long flags;
 740
 741         spin_lock_irqsave(&card->tx_dma_lock, flags);
 742
 743         gelic_card_release_tx_chain(card, 0);
 744
 745         descr = gelic_card_get_next_tx_descr(card);
 746         if (!descr) {
 747                 /*
 748                  * no more descriptors free
 749                  */
 750                 netif_stop_queue(netdev);
 751                 spin_unlock_irqrestore(&card->tx_dma_lock, flags);
 752                 return NETDEV_TX_BUSY;
 753         }
 754
 755         result = gelic_descr_prepare_tx(card, descr, skb);
 756         if (result) {
 757                 /*
 758                  * DMA map failed.  As chanses are that failure
 759                  * would continue, just release skb and return
 760                  */
 761                 card->netdev->stats.tx_dropped++;
 762                 dev_kfree_skb_any(skb);
 763                 spin_unlock_irqrestore(&card->tx_dma_lock, flags);
 764                 return NETDEV_TX_OK;
 765         }
 766         /*
 767          * link this prepared descriptor to previous one
 768          * to achieve high performance
 769          */
 770         descr->prev->next_descr_addr = cpu_to_be32(descr->bus_addr);
 771         /*
 772          * as hardware descriptor is modified in the above lines,
 773          * ensure that the hardware sees it
 774          */
 775         wmb();
 776         if (gelic_card_kick_txdma(card, descr)) {
 777                 /*
 778                  * kick failed.
 779                  * release descriptors which were just prepared
 780                  */
 781                 card->netdev->stats.tx_dropped++;
 782                 gelic_descr_release_tx(card, descr);
 783                 gelic_descr_release_tx(card, descr->next);
 784                 card->tx_chain.tail = descr->next->next;
 785                 dev_info(ctodev(card), "%s: kick failure\n", __func__);
 786         } else {
 787                 /* OK, DMA started/reserved */
 788                 netdev->trans_start = jiffies;
 789         }
 790
 791         spin_unlock_irqrestore(&card->tx_dma_lock, flags);
 792         return NETDEV_TX_OK;
 793 }
 794
 795 /**
 796  * gelic_net_pass_skb_up - takes an skb from a descriptor and passes it on
 797  * @descr: descriptor to process
 798  * @card: card structure
 799  *
 800  * iommu-unmaps the skb, fills out skb structure and passes the data to the
 801  * stack. The descriptor state is not changed.
 802  */
 803 static void gelic_net_pass_skb_up(struct gelic_descr *descr,
 804                                  struct gelic_card *card)
 805 {
 806         struct sk_buff *skb;
 807         struct net_device *netdev;
 808         u32 data_status, data_error;
 809
 810         data_status = be32_to_cpu(descr->data_status);
 811         data_error = be32_to_cpu(descr->data_error);
 812         netdev = card->netdev;
 813         /* unmap skb buffer */
 814         skb = descr->skb;
 815         dma_unmap_single(ctodev(card),
 816                          be32_to_cpu(descr->buf_addr), GELIC_NET_MAX_MTU,
 817                          DMA_FROM_DEVICE);
 818
 819         skb_put(skb, descr->valid_size ?
 820                 be32_to_cpu(descr->valid_size) :
 821                 be32_to_cpu(descr->result_size));
 822         if (!descr->valid_size)
 823                 dev_info(ctodev(card), "buffer full %x %x %x\n",
 824                          be32_to_cpu(descr->result_size),
 825                          be32_to_cpu(descr->buf_size),
 826                          be32_to_cpu(descr->dmac_cmd_status));
 827
 828         descr->skb = NULL;
 829         /*
 830          * the card put 2 bytes vlan tag in front
 831          * of the ethernet frame
 832          */
 833         skb_pull(skb, 2);
 834         skb->protocol = eth_type_trans(skb, netdev);
 835
 836         /* checksum offload */
 837         if (card->rx_csum) {
 838                 if ((data_status & GELIC_DESCR_DATA_STATUS_CHK_MASK) &&
 839                     (!(data_error & GELIC_DESCR_DATA_ERROR_CHK_MASK)))
 840                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 841                 else
 842                         skb->ip_summed = CHECKSUM_NONE;
 843         } else
 844                 skb->ip_summed = CHECKSUM_NONE;
 845
 846         /* update netdevice statistics */
 847         card->netdev->stats.rx_packets++;
 848         card->netdev->stats.rx_bytes += skb->len;
 849
 850         /* pass skb up to stack */
 851         netif_receive_skb(skb);
 852 }
 853
 854 /**
 855  * gelic_card_decode_one_descr - processes an rx descriptor
 856  * @card: card structure
 857  *
 858  * returns 1 if a packet has been sent to the stack, otherwise 0
 859  *
 860  * processes an rx descriptor by iommu-unmapping the data buffer and passing
 861  * the packet up to the stack
 862  */
 863 static int gelic_card_decode_one_descr(struct gelic_card *card)
 864 {
 865         enum gelic_descr_dma_status status;
 866         struct gelic_descr_chain *chain = &card->rx_chain;
 867         struct gelic_descr *descr = chain->tail;
 868         int dmac_chain_ended;
 869
 870         status = gelic_descr_get_status(descr);
 871         /* is this descriptor terminated with next_descr == NULL? */
 872         dmac_chain_ended =
 873                 be32_to_cpu(descr->dmac_cmd_status) &
 874                 GELIC_DESCR_RX_DMA_CHAIN_END;
 875
 876         if (status == GELIC_DESCR_DMA_CARDOWNED)
 877                 return 0;
 878
 879         if (status == GELIC_DESCR_DMA_NOT_IN_USE) {
 880                 dev_dbg(ctodev(card), "dormant descr? %p\n", descr);
 881                 return 0;
 882         }
 883
 884         if ((status == GELIC_DESCR_DMA_RESPONSE_ERROR) ||
 885             (status == GELIC_DESCR_DMA_PROTECTION_ERROR) ||
 886             (status == GELIC_DESCR_DMA_FORCE_END)) {
 887                 dev_info(ctodev(card), "dropping RX descriptor with state %x\n",
 888                          status);
 889                 card->netdev->stats.rx_dropped++;
 890                 goto refill;
 891         }
 892
 893         if (status == GELIC_DESCR_DMA_BUFFER_FULL) {
 894                 /*
 895                  * Buffer full would occur if and only if
 896                  * the frame length was longer than the size of this
 897                  * descriptor's buffer.  If the frame length was equal
 898                  * to or shorter than buffer'size, FRAME_END condition
 899                  * would occur.
 900                  * Anyway this frame was longer than the MTU,
 901                  * just drop it.
 902                  */
 903                 dev_info(ctodev(card), "overlength frame\n");
 904                 goto refill;
 905         }
 906         /*
 907          * descriptoers any other than FRAME_END here should
 908          * be treated as error.
 909          */
 910         if (status != GELIC_DESCR_DMA_FRAME_END) {
 911                 dev_dbg(ctodev(card), "RX descriptor with state %x\n",
 912                         status);
 913                 goto refill;
 914         }
 915
 916         /* ok, we've got a packet in descr */
 917         gelic_net_pass_skb_up(descr, card);
 918 refill:
 919         /*
 920          * So that always DMAC can see the end
 921          * of the descriptor chain to avoid
 922          * from unwanted DMAC overrun.
 923          */
 924         descr->next_descr_addr = 0;
 925
 926         /* change the descriptor state: */
 927         gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE);
 928
 929         /*
 930          * this call can fail, but for now, just leave this
 931          * decriptor without skb
 932          */
 933         gelic_descr_prepare_rx(card, descr);
 934
 935         chain->head = descr;
 936         chain->tail = descr->next;
 937
 938         /*
 939          * Set this descriptor the end of the chain.
 940          */
 941         descr->prev->next_descr_addr = cpu_to_be32(descr->bus_addr);
 942
 943         /*
 944          * If dmac chain was met, DMAC stopped.
 945          * thus re-enable it
 946          */
 947         if (dmac_chain_ended) {
 948                 card->rx_dma_restart_required = 1;
 949                 dev_dbg(ctodev(card), "reenable rx dma scheduled\n");
 950         }
 951
 952         return 1;
 953 }
 954
 955 /**
 956  * gelic_net_poll - NAPI poll function called by the stack to return packets
 957  * @netdev: interface device structure
 958  * @budget: number of packets we can pass to the stack at most
 959  *
 960  * returns 0 if no more packets available to the driver/stack. Returns 1,
 961  * if the quota is exceeded, but the driver has still packets.
 962  *
 963  */
 964 static int gelic_net_poll(struct napi_struct *napi, int budget)
 965 {
 966         struct gelic_card *card = container_of(napi, struct gelic_card, napi);
 967         struct net_device *netdev = card->netdev;
 968         int packets_done = 0;
 969
 970         while (packets_done < budget) {
 971                 if (!gelic_card_decode_one_descr(card))
 972                         break;
 973
 974                 packets_done++;
 975         }
 976
 977         if (packets_done < budget) {
 978                 netif_rx_complete(netdev, napi);
 979                 gelic_card_rx_irq_on(card);
 980         }
 981         return packets_done;
 982 }
 983 /**
 984  * gelic_net_change_mtu - changes the MTU of an interface
 985  * @netdev: interface device structure
 986  * @new_mtu: new MTU value
 987  *
 988  * returns 0 on success, <0 on failure
 989  */
 990 static int gelic_net_change_mtu(struct net_device *netdev, int new_mtu)
 991 {
 992         /* no need to re-alloc skbs or so -- the max mtu is about 2.3k
 993          * and mtu is outbound only anyway */
 994         if ((new_mtu < GELIC_NET_MIN_MTU) ||
 995             (new_mtu > GELIC_NET_MAX_MTU)) {
 996                 return -EINVAL;
 997         }
 998         netdev->mtu = new_mtu;
 999         return 0;
1000 }
1001
1002 /**
1003  * gelic_card_interrupt - event handler for gelic_net
1004  */
1005 static irqreturn_t gelic_card_interrupt(int irq, void *ptr)
1006 {
1007         unsigned long flags;
1008         struct net_device *netdev = ptr;
1009         struct gelic_card *card = netdev_priv(netdev);
1010         u64 status;
1011
1012         status = card->irq_status;
1013
1014         if (!status)
1015                 return IRQ_NONE;
1016
1017         if (card->rx_dma_restart_required) {
1018                 card->rx_dma_restart_required = 0;
1019                 gelic_card_enable_rxdmac(card);
1020         }
1021
1022         if (status & GELIC_CARD_RXINT) {
1023                 gelic_card_rx_irq_off(card);
1024                 netif_rx_schedule(netdev, &card->napi);
1025         }
1026
1027         if (status & GELIC_CARD_TXINT) {
1028                 spin_lock_irqsave(&card->tx_dma_lock, flags);
1029                 card->tx_dma_progress = 0;
1030                 gelic_card_release_tx_chain(card, 0);
1031                 /* kick outstanding tx descriptor if any */
1032                 gelic_card_kick_txdma(card, card->tx_chain.tail);
1033                 spin_unlock_irqrestore(&card->tx_dma_lock, flags);
1034         }
1035         return IRQ_HANDLED;
1036 }
1037
1038 #ifdef CONFIG_NET_POLL_CONTROLLER
1039 /**
1040  * gelic_net_poll_controller - artificial interrupt for netconsole etc.
1041  * @netdev: interface device structure
1042  *
1043  * see Documentation/networking/netconsole.txt
1044  */
1045 static void gelic_net_poll_controller(struct net_device *netdev)
1046 {
1047         struct gelic_card *card = netdev_priv(netdev);
1048
1049         gelic_card_set_irq_mask(card, 0);
1050         gelic_card_interrupt(netdev->irq, netdev);
1051         gelic_card_set_irq_mask(card, card->ghiintmask);
1052 }
1053 #endif /* CONFIG_NET_POLL_CONTROLLER */
1054
1055 /**
1056  * gelic_card_open - open device and map dma region
1057  * @card: card structure
1058  */
1059 static int gelic_card_open(struct gelic_card *card)
1060 {
1061         int result;
1062
1063         result = ps3_sb_event_receive_port_setup(card->dev, PS3_BINDING_CPU_ANY,
1064                 &card->netdev->irq);
1065
1066         if (result) {
1067                 dev_info(ctodev(card),
1068                          "%s:%d: recieve_port_setup failed (%d)\n",
1069                          __func__, __LINE__, result);
1070                 result = -EPERM;
1071                 goto fail_alloc_irq;
1072         }
1073
1074         result = request_irq(card->netdev->irq, gelic_card_interrupt,
1075                              IRQF_DISABLED, card->netdev->name, card->netdev);
1076
1077         if (result) {
1078                 dev_info(ctodev(card), "%s:%d: request_irq failed (%d)\n",
1079                         __func__, __LINE__, result);
1080                 goto fail_request_irq;
1081         }
1082
1083         return 0;
1084
1085 fail_request_irq:
1086         ps3_sb_event_receive_port_destroy(card->dev, card->netdev->irq);
1087         card->netdev->irq = NO_IRQ;
1088 fail_alloc_irq:
1089         return result;
1090 }
1091
1092
1093 /**
1094  * gelic_net_open - called upon ifonfig up
1095  * @netdev: interface device structure
1096  *
1097  * returns 0 on success, <0 on failure
1098  *
1099  * gelic_net_open allocates all the descriptors and memory needed for
1100  * operation, sets up multicast list and enables interrupts
1101  */
1102 static int gelic_net_open(struct net_device *netdev)
1103 {
1104         struct gelic_card *card = netdev_priv(netdev);
1105
1106         dev_dbg(ctodev(card), " -> %s:%d\n", __func__, __LINE__);
1107
1108         gelic_card_open(card);
1109
1110         if (gelic_card_init_chain(card, &card->tx_chain,
1111                                   card->descr, GELIC_NET_TX_DESCRIPTORS))
1112                 goto alloc_tx_failed;
1113         if (gelic_card_init_chain(card, &card->rx_chain,
1114                                   card->descr + GELIC_NET_TX_DESCRIPTORS,
1115                                   GELIC_NET_RX_DESCRIPTORS))
1116                 goto alloc_rx_failed;
1117
1118         /* head of chain */
1119         card->tx_top = card->tx_chain.head;
1120         card->rx_top = card->rx_chain.head;
1121         dev_dbg(ctodev(card), "descr rx %p, tx %p, size %#lx, num %#x\n",
1122                 card->rx_top, card->tx_top, sizeof(struct gelic_descr),
1123                 GELIC_NET_RX_DESCRIPTORS);
1124         /* allocate rx skbs */
1125         if (gelic_card_alloc_rx_skbs(card))
1126                 goto alloc_skbs_failed;
1127
1128         napi_enable(&card->napi);
1129
1130         card->tx_dma_progress = 0;
1131         card->ghiintmask = GELIC_CARD_RXINT | GELIC_CARD_TXINT;
1132
1133         gelic_card_set_irq_mask(card, card->ghiintmask);
1134         gelic_card_enable_rxdmac(card);
1135
1136         netif_start_queue(netdev);
1137         netif_carrier_on(netdev);
1138
1139         return 0;
1140
1141 alloc_skbs_failed:
1142         gelic_card_free_chain(card, card->rx_top);
1143 alloc_rx_failed:
1144         gelic_card_free_chain(card, card->tx_top);
1145 alloc_tx_failed:
1146         return -ENOMEM;
1147 }
1148
1149 static void gelic_net_get_drvinfo(struct net_device *netdev,
1150                                   struct ethtool_drvinfo *info)
1151 {
1152         strncpy(info->driver, DRV_NAME, sizeof(info->driver) - 1);
1153         strncpy(info->version, DRV_VERSION, sizeof(info->version) - 1);
1154 }
1155
1156 static int gelic_ether_get_settings(struct net_device *netdev,
1157                                     struct ethtool_cmd *cmd)
1158 {
1159         struct gelic_card *card = netdev_priv(netdev);
1160         int status;
1161         u64 v1, v2;
1162         int speed, duplex;
1163
1164         speed = duplex = -1;
1165         status = lv1_net_control(bus_id(card), dev_id(card),
1166                                  GELIC_LV1_GET_ETH_PORT_STATUS,
1167                                  GELIC_LV1_VLAN_TX_ETHERNET, 0, 0,
1168                                  &v1, &v2);
1169         if (status) {
1170                 /* link down */
1171         } else {
1172                 if (v1 & GELIC_LV1_ETHER_FULL_DUPLEX) {
1173                         duplex = DUPLEX_FULL;
1174                 } else {
1175                         duplex = DUPLEX_HALF;
1176                 }
1177
1178                 if (v1 & GELIC_LV1_ETHER_SPEED_10) {
1179                         speed = SPEED_10;
1180                 } else if (v1 & GELIC_LV1_ETHER_SPEED_100) {
1181                         speed = SPEED_100;
1182                 } else if (v1 & GELIC_LV1_ETHER_SPEED_1000) {
1183                         speed = SPEED_1000;
1184                 }
1185         }
1186         cmd->supported = SUPPORTED_TP | SUPPORTED_Autoneg |
1187                         SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
1188                         SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
1189                         SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full;
1190         cmd->advertising = cmd->supported;
1191         cmd->speed = speed;
1192         cmd->duplex = duplex;
1193         cmd->autoneg = AUTONEG_ENABLE; /* always enabled */
1194         cmd->port = PORT_TP;
1195
1196         return 0;
1197 }
1198
1199 static int gelic_net_nway_reset(struct net_device *netdev)
1200 {
1201         if (netif_running(netdev)) {
1202                 gelic_net_stop(netdev);
1203                 gelic_net_open(netdev);
1204         }
1205         return 0;
1206 }
1207
1208 static u32 gelic_net_get_rx_csum(struct net_device *netdev)
1209 {
1210         struct gelic_card *card = netdev_priv(netdev);
1211
1212         return card->rx_csum;
1213 }
1214
1215 static int gelic_net_set_rx_csum(struct net_device *netdev, u32 data)
1216 {
1217         struct gelic_card *card = netdev_priv(netdev);
1218
1219         card->rx_csum = data;
1220         return 0;
1221 }
1222
1223 static struct ethtool_ops gelic_net_ethtool_ops = {
1224         .get_drvinfo    = gelic_net_get_drvinfo,
1225         .get_settings   = gelic_ether_get_settings,
1226         .get_link       = ethtool_op_get_link,
1227         .nway_reset     = gelic_net_nway_reset,
1228         .get_tx_csum    = ethtool_op_get_tx_csum,
1229         .set_tx_csum    = ethtool_op_set_tx_csum,
1230         .get_rx_csum    = gelic_net_get_rx_csum,
1231         .set_rx_csum    = gelic_net_set_rx_csum,
1232 };
1233
1234 /**
1235  * gelic_net_tx_timeout_task - task scheduled by the watchdog timeout
1236  * function (to be called not under interrupt status)
1237  * @work: work is context of tx timout task
1238  *
1239  * called as task when tx hangs, resets interface (if interface is up)
1240  */
1241 static void gelic_net_tx_timeout_task(struct work_struct *work)
1242 {
1243         struct gelic_card *card =
1244                 container_of(work, struct gelic_card, tx_timeout_task);
1245         struct net_device *netdev = card->netdev;
1246
1247         dev_info(ctodev(card), "%s:Timed out. Restarting... \n", __func__);
1248
1249         if (!(netdev->flags & IFF_UP))
1250                 goto out;
1251
1252         netif_device_detach(netdev);
1253         gelic_net_stop(netdev);
1254
1255         gelic_net_open(netdev);
1256         netif_device_attach(netdev);
1257
1258 out:
1259         atomic_dec(&card->tx_timeout_task_counter);
1260 }
1261
1262 /**
1263  * gelic_net_tx_timeout - called when the tx timeout watchdog kicks in.
1264  * @netdev: interface device structure
1265  *
1266  * called, if tx hangs. Schedules a task that resets the interface
1267  */
1268 static void gelic_net_tx_timeout(struct net_device *netdev)
1269 {
1270         struct gelic_card *card;
1271
1272         card = netdev_priv(netdev);
1273         atomic_inc(&card->tx_timeout_task_counter);
1274         if (netdev->flags & IFF_UP)
1275                 schedule_work(&card->tx_timeout_task);
1276         else
1277                 atomic_dec(&card->tx_timeout_task_counter);
1278 }
1279
1280 /**
1281  * gelic_ether_setup_netdev_ops - initialization of net_device operations
1282  * @netdev: net_device structure
1283  *
1284  * fills out function pointers in the net_device structure
1285  */
1286 static void gelic_ether_setup_netdev_ops(struct net_device *netdev)
1287 {
1288         netdev->open = &gelic_net_open;
1289         netdev->stop = &gelic_net_stop;
1290         netdev->hard_start_xmit = &gelic_net_xmit;
1291         netdev->set_multicast_list = &gelic_net_set_multi;
1292         netdev->change_mtu = &gelic_net_change_mtu;
1293         /* tx watchdog */
1294         netdev->tx_timeout = &gelic_net_tx_timeout;
1295         netdev->watchdog_timeo = GELIC_NET_WATCHDOG_TIMEOUT;
1296         netdev->ethtool_ops = &gelic_net_ethtool_ops;
1297 }
1298
1299 /**
1300  * gelic_net_setup_netdev - initialization of net_device
1301  * @card: card structure
1302  *
1303  * Returns 0 on success or <0 on failure
1304  *
1305  * gelic_net_setup_netdev initializes the net_device structure
1306  **/
1307 static int gelic_net_setup_netdev(struct gelic_card *card)
1308 {
1309         struct net_device *netdev = card->netdev;
1310         struct sockaddr addr;
1311         unsigned int i;
1312         int status;
1313         u64 v1, v2;
1314         DECLARE_MAC_BUF(mac);
1315
1316         SET_NETDEV_DEV(netdev, &card->dev->core);
1317         spin_lock_init(&card->tx_dma_lock);
1318
1319         card->rx_csum = GELIC_NET_RX_CSUM_DEFAULT;
1320
1321         gelic_ether_setup_netdev_ops(netdev);
1322
1323         netif_napi_add(netdev, &card->napi,
1324                        gelic_net_poll, GELIC_NET_NAPI_WEIGHT);
1325
1326         netdev->features = NETIF_F_IP_CSUM;
1327
1328         status = lv1_net_control(bus_id(card), dev_id(card),
1329                                  GELIC_LV1_GET_MAC_ADDRESS,
1330                                  0, 0, 0, &v1, &v2);
1331         if (status || !is_valid_ether_addr((u8 *)&v1)) {
1332                 dev_info(ctodev(card),
1333                          "%s:lv1_net_control GET_MAC_ADDR failed %d\n",
1334                          __func__, status);
1335                 return -EINVAL;
1336         }
1337         v1 <<= 16;
1338         memcpy(addr.sa_data, &v1, ETH_ALEN);
1339         memcpy(netdev->dev_addr, addr.sa_data, ETH_ALEN);
1340         dev_info(ctodev(card), "MAC addr %s\n",
1341                  print_mac(mac, netdev->dev_addr));
1342
1343         card->vlan_index = -1;  /* no vlan */
1344         for (i = 0; i < GELIC_NET_VLAN_MAX; i++) {
1345                 status = lv1_net_control(bus_id(card), dev_id(card),
1346                                         GELIC_LV1_GET_VLAN_ID,
1347                                         i + 1, /* index; one based */
1348                                         0, 0, &v1, &v2);
1349                 if (status == LV1_NO_ENTRY) {
1350                         dev_dbg(ctodev(card),
1351                                 "GELIC_VLAN_ID no entry:%d, VLAN disabled\n",
1352                                 status);
1353                         card->vlan_id[i] = 0;
1354                 } else if (status) {
1355                         dev_dbg(ctodev(card),
1356                                 "%s:get vlan id faild, status=%d\n",
1357                                 __func__, status);
1358                         card->vlan_id[i] = 0;
1359                 } else {
1360                         card->vlan_id[i] = (u32)v1;
1361                         dev_dbg(ctodev(card), "vlan_id:%d, %lx\n", i, v1);
1362                 }
1363         }
1364
1365         if (card->vlan_id[GELIC_LV1_VLAN_TX_ETHERNET - 1]) {
1366                 card->vlan_index = GELIC_LV1_VLAN_TX_ETHERNET - 1;
1367                 netdev->hard_header_len += VLAN_HLEN;
1368         }
1369
1370         status = register_netdev(netdev);
1371         if (status) {
1372                 dev_err(ctodev(card), "%s:Couldn't register net_device: %d\n",
1373                         __func__, status);
1374                 return status;
1375         }
1376
1377         return 0;
1378 }
1379
1380 /**
1381  * gelic_alloc_card_net - allocates net_device and card structure
1382  *
1383  * returns the card structure or NULL in case of errors
1384  *
1385  * the card and net_device structures are linked to each other
1386  */
1387 static struct gelic_card *gelic_alloc_card_net(void)
1388 {
1389         struct net_device *netdev;
1390         struct gelic_card *card;
1391         size_t alloc_size;
1392
1393         alloc_size = sizeof(*card) +
1394                 sizeof(struct gelic_descr) * GELIC_NET_RX_DESCRIPTORS +
1395                 sizeof(struct gelic_descr) * GELIC_NET_TX_DESCRIPTORS;
1396         /*
1397          * we assume private data is allocated 32 bytes (or more) aligned
1398          * so that gelic_descr should be 32 bytes aligned.
1399          * Current alloc_etherdev() does do it because NETDEV_ALIGN
1400          * is 32.
1401          * check this assumption here.
1402          */
1403         BUILD_BUG_ON(NETDEV_ALIGN < 32);
1404         BUILD_BUG_ON(offsetof(struct gelic_card, irq_status) % 8);
1405         BUILD_BUG_ON(offsetof(struct gelic_card, descr) % 32);
1406
1407         netdev = alloc_etherdev(alloc_size);
1408         if (!netdev)
1409                 return NULL;
1410
1411         card = netdev_priv(netdev);
1412         card->netdev = netdev;
1413         INIT_WORK(&card->tx_timeout_task, gelic_net_tx_timeout_task);
1414         init_waitqueue_head(&card->waitq);
1415         atomic_set(&card->tx_timeout_task_counter, 0);
1416
1417         return card;
1418 }
1419
1420 /**
1421  * ps3_gelic_driver_probe - add a device to the control of this driver
1422  */
1423 static int ps3_gelic_driver_probe(struct ps3_system_bus_device *dev)
1424 {
1425         struct gelic_card *card = gelic_alloc_card_net();
1426         int result;
1427
1428         if (!card) {
1429                 dev_info(&dev->core, "gelic_net_alloc_card failed\n");
1430                 result = -ENOMEM;
1431                 goto fail_alloc_card;
1432         }
1433
1434         ps3_system_bus_set_driver_data(dev, card);
1435         card->dev = dev;
1436
1437         result = ps3_open_hv_device(dev);
1438
1439         if (result) {
1440                 dev_dbg(&dev->core, "ps3_open_hv_device failed\n");
1441                 goto fail_open;
1442         }
1443
1444         result = ps3_dma_region_create(dev->d_region);
1445
1446         if (result) {
1447                 dev_dbg(&dev->core, "ps3_dma_region_create failed(%d)\n",
1448                         result);
1449                 BUG_ON("check region type");
1450                 goto fail_dma_region;
1451         }
1452
1453         result = lv1_net_set_interrupt_status_indicator(bus_id(card),
1454                                                         dev_id(card),
1455                 ps3_mm_phys_to_lpar(__pa(&card->irq_status)),
1456                 0);
1457
1458         if (result) {
1459                 dev_dbg(&dev->core,
1460                         "lv1_net_set_interrupt_status_indicator failed: %s\n",
1461                         ps3_result(result));
1462                 result = -EIO;
1463                 goto fail_status_indicator;
1464         }
1465
1466         result = gelic_net_setup_netdev(card);
1467
1468         if (result) {
1469                 dev_dbg(&dev->core, "%s:%d: ps3_dma_region_create failed: "
1470                         "(%d)\n", __func__, __LINE__, result);
1471                 goto fail_setup_netdev;
1472         }
1473
1474         return 0;
1475
1476 fail_setup_netdev:
1477         lv1_net_set_interrupt_status_indicator(bus_id(card),
1478                                                dev_id(card),
1479                                                0 , 0);
1480 fail_status_indicator:
1481         ps3_dma_region_free(dev->d_region);
1482 fail_dma_region:
1483         ps3_close_hv_device(dev);
1484 fail_open:
1485         ps3_system_bus_set_driver_data(dev, NULL);
1486         free_netdev(card->netdev);
1487 fail_alloc_card:
1488         return result;
1489 }
1490
1491 /**
1492  * ps3_gelic_driver_remove - remove a device from the control of this driver
1493  */
1494
1495 static int ps3_gelic_driver_remove(struct ps3_system_bus_device *dev)
1496 {
1497         struct gelic_card *card = ps3_system_bus_get_driver_data(dev);
1498
1499         wait_event(card->waitq,
1500                    atomic_read(&card->tx_timeout_task_counter) == 0);
1501
1502         lv1_net_set_interrupt_status_indicator(bus_id(card), dev_id(card),
1503                                                0 , 0);
1504
1505         unregister_netdev(card->netdev);
1506         free_netdev(card->netdev);
1507
1508         ps3_system_bus_set_driver_data(dev, NULL);
1509
1510         ps3_dma_region_free(dev->d_region);
1511
1512         ps3_close_hv_device(dev);
1513
1514         return 0;
1515 }
1516
1517 static struct ps3_system_bus_driver ps3_gelic_driver = {
1518         .match_id = PS3_MATCH_ID_GELIC,
1519         .probe = ps3_gelic_driver_probe,
1520         .remove = ps3_gelic_driver_remove,
1521         .shutdown = ps3_gelic_driver_remove,
1522         .core.name = "ps3_gelic_driver",
1523         .core.owner = THIS_MODULE,
1524 };
1525
1526 static int __init ps3_gelic_driver_init (void)
1527 {
1528         return firmware_has_feature(FW_FEATURE_PS3_LV1)
1529                 ? ps3_system_bus_driver_register(&ps3_gelic_driver)
1530                 : -ENODEV;
1531 }
1532
1533 static void __exit ps3_gelic_driver_exit (void)
1534 {
1535         ps3_system_bus_driver_unregister(&ps3_gelic_driver);
1536 }
1537
1538 module_init(ps3_gelic_driver_init);
1539 module_exit(ps3_gelic_driver_exit);
1540
1541 MODULE_ALIAS(PS3_MODULE_ALIAS_GELIC);
1542