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