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