PageRenderTime 116ms CodeModel.GetById 14ms app.highlight 89ms RepoModel.GetById 2ms app.codeStats 0ms

/drivers/net/ethernet/toshiba/ps3_gelic_net.c

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