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 43 MODULE_AUTHOR("SCE Inc."); 44 MODULE_DESCRIPTION("Gelic Network driver"); 45 MODULE_LICENSE("GPL"); 46 47 48 /* set irq_mask */ 49 int 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 61 static 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 } 66 static 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 72 static 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 hw_regs.dmac_cmd_status field of the descriptor 97 */ 98 static enum gelic_descr_dma_status 99 gelic_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 105 static 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 controller 125 * @card: card structure 126 * 127 * gelic_card_disable_txdmac terminates processing on the DMA controller by 128 * turing off DMA and issuing a force end 129 */ 130 static 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 controller 143 * @card: card structure 144 * 145 * gelic_card_enable_rxdmac enables the DMA controller by setting RX_DMA_EN 146 * in the GDADMACCNTR register 147 */ 148 static void gelic_card_enable_rxdmac(struct gelic_card *card) 149 { 150 int status; 151 152 #ifdef DEBUG 153 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 #endif 163 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 controller 172 * @card: card structure 173 * 174 * gelic_card_disable_rxdmac terminates processing on the DMA controller by 175 * turing off DMA and issuing a force end 176 */ 177 static 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 descriptor 190 * @descr: descriptor to change 191 * @status: status to set in the descriptor 192 * 193 * changes the status to the specified value. Doesn't change other bits 194 * in the status 195 */ 196 static 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 descriptor 204 * is valid or not. 205 * Usually caller of this function wants to inform that to the 206 * 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 chain 213 * @card: card structure 214 * @chain: address of chain 215 * @start_descr: address of descriptor array 216 * 217 * Reset the status of dma descriptors to ready state 218 * and re-initialize the hardware chain for later use 219 */ 220 static 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_addr 229 = 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 238 void 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 255 void 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 will 265 * be disabled later if any 266 */ 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 chain 283 * @card: card structure 284 * @descr_in: address of desc 285 */ 286 static 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 chain 302 * @card: card structure 303 * @chain: address of chain 304 * @start_descr: address of descriptor array 305 * @no: number of descriptors 306 * 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 failure 311 */ 312 static 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 descriptor 364 * @card: card structure 365 * @descr: descriptor to re-init 366 * 367 * return 0 on success, <0 on failure 368 * 369 * allocates a new rx skb, iommu-maps it and attaches it to the descriptor. 370 * Activate the descriptor state-wise 371 * 372 * Gelic RX sk_buffs must be aligned to GELIC_NET_RXBUF_ALIGN and the length 373 * must be a multiple of GELIC_NET_RXBUF_ALIGN. 374 */ 375 static 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->skb = netdev_alloc_skb(*card->netdev, rx_skb_size); 388 if (!descr->skb) { 389 descr->hw_regs.payload.dev_addr = 0; /* tell DMAC don't touch memory */ 390 return -ENOMEM; 391 } 392 descr->hw_regs.dmac_cmd_status = 0; 393 descr->hw_regs.result_size = 0; 394 descr->hw_regs.valid_size = 0; 395 descr->hw_regs.data_error = 0; 396 descr->hw_regs.payload.dev_addr = 0; 397 descr->hw_regs.payload.size = 0; 398 descr->skb = NULL; 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 descr 427 * @card: card structure 428 * 429 */ 430 static 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 chains 453 * @card: card structure 454 * 455 * fills all descriptors in the rx chain: allocates skbs 456 * and iommu-maps them. 457 * returns 0 on success, < 0 on failure 458 */ 459 static 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; 474 rewind: 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 chains 481 * @card: card structure 482 * 483 * returns 0 on success, < 0 on failure 484 */ 485 static 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 descriptor 497 * @card: card structure 498 * @descr: descriptor to release 499 * 500 * releases a used tx descriptor (unmapping, freeing of skb) 501 */ 502 static 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 527 static 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 } 534 static 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 descriptors 543 * @card: adapter structure 544 * @stop: net_stop sequence 545 * 546 * releases the tx descriptors that gelic has finished with 547 */ 548 static 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 } 590 out: 591 if (!stop && release) 592 gelic_card_wake_queues(card); 593 } 594 595 /** 596 * gelic_net_set_multi - sets multicast addresses and promisc flags 597 * @netdev: interface device structure 598 * 599 * gelic_net_set_multi configures multicast addresses as needed for the 600 * netdev interface. It also sets up multicast, allmulti and promisc 601 * flags appropriately 602 */ 603 void 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 down 659 * @netdev: interface device structure 660 * 661 * always returns 0 662 */ 663 int 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 descriptor 681 * @card: device structure to get descriptor from 682 * 683 * returns the address of the next descriptor, or NULL if not available. 684 */ 685 static struct gelic_descr * 686 gelic_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 else 696 return NULL; 697 698 } 699 700 /** 701 * gelic_net_set_txdescr_cmdstat - sets the tx descriptor command field 702 * @descr: descriptor structure to fill out 703 * @skb: packet to consider 704 * 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 */ 709 static 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-udp 731 * packets on his own: NETIF_F_IP_CSUM 732 */ 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 740 static 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 packets 767 * @card: card structure 768 * @descr: descriptor structure 769 * @skb: packet to use 770 * 771 * returns 0 on success, <0 on failure. 772 * 773 */ 774 static 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 processing 815 * @card: card structure 816 * @descr: descriptor address to enable TX processing at 817 * 818 */ 819 static 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 device 842 * @skb: packet to send out 843 * @netdev: interface device structure 844 * 845 * returns NETDEV_TX_OK on success, NETDEV_TX_BUSY on failure 846 */ 847 netdev_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 free 862 */ 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 failure 872 * would continue, just release skb and return 873 */ 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 one 881 * to achieve high performance 882 */ 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 it 888 */ 889 wmb(); 890 if (gelic_card_kick_txdma(card, descr)) { 891 /* 892 * kick failed. 893 * release descriptor which was just prepared 894 */ 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 on 912 * @descr: descriptor to process 913 * @card: card structure 914 * @netdev: net_device structure to be passed packet 915 * 916 * iommu-unmaps the skb, fills out skb structure and passes the data to the 917 * stack. The descriptor state is not changed. 918 */ 919 static 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 front 946 * of the ethernet frame 947 */ 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 else 957 skb_checksum_none_assert(skb); 958 } else 959 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 descriptor 971 * @card: card structure 972 * 973 * returns 1 if a packet has been sent to the stack, otherwise 0 974 * 975 * processes an rx descriptor by iommu-unmapping the data buffer and passing 976 * the packet up to the stack 977 */ 978 static 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 } else 1012 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 if 1026 * the frame length was longer than the size of this 1027 * descriptor's buffer. If the frame length was equal 1028 * to or shorter than buffer'size, FRAME_END condition 1029 * 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 should 1038 * 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); 1048 refill: 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 end 1056 * of the descriptor chain to avoid 1057 * 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 this 1066 * descriptor without skb 1067 */ 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 it 1082 */ 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 packets 1092 * @napi: napi structure 1093 * @budget: number of packets we can pass to the stack at most 1094 * 1095 * returns the number of the processed packets 1096 * 1097 */ 1098 static 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_net 1119 */ 1120 static 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_WIRELESS 1152 if (status & (GELIC_CARD_WLAN_EVENT_RECEIVED | 1153 GELIC_CARD_WLAN_COMMAND_COMPLETED)) 1154 gelic_wl_interrupt(card->netdev[GELIC_PORT_WIRELESS], status); 1155 #endif 1156 1157 return IRQ_HANDLED; 1158 } 1159 1160 #ifdef CONFIG_NET_POLL_CONTROLLER 1161 /** 1162 * gelic_net_poll_controller - artificial interrupt for netconsole etc. 1163 * @netdev: interface device structure 1164 * 1165 * see Documentation/networking/netconsole.rst 1166 */ 1167 void 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 up 1179 * @netdev: interface device structure 1180 * 1181 * returns 0 on success, <0 on failure 1182 * 1183 * gelic_net_open allocates all the descriptors and memory needed for 1184 * operation, sets up multicast list and enables interrupts 1185 */ 1186 int 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 1201 void 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 1208 static 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 else 1219 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 1258 static int 1259 gelic_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 1298 static 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 else 1304 wol->supported = 0; 1305 1306 wol->wolopts = ps3_sys_manager_get_wol() ? wol->supported : 0; 1307 memset(&wol->sopass, 0, sizeof(wol->sopass)); 1308 } 1309 static 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 } 1373 done: 1374 return status; 1375 } 1376 1377 static 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 timeout 1388 * function (to be called not under interrupt status) 1389 * @work: work is context of tx timout task 1390 * 1391 * called as task when tx hangs, resets interface (if interface is up) 1392 */ 1393 static 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 1410 out: 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 structure 1417 * @txqueue: unused 1418 * 1419 * called, if tx hangs. Schedules a task that resets the interface 1420 */ 1421 void 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 else 1430 atomic_dec(&card->tx_timeout_task_counter); 1431 } 1432 1433 static 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_CONTROLLER 1442 .ndo_poll_controller = gelic_net_poll_controller, 1443 #endif 1444 }; 1445 1446 /** 1447 * gelic_ether_setup_netdev_ops - initialization of net_device operations 1448 * @netdev: net_device structure 1449 * @napi: napi structure 1450 * 1451 * fills out function pointers in the net_device structure 1452 */ 1453 static 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_ether_setup_netdev - initialization of net_device 1465 * @netdev: net_device structure 1466 * @card: card structure 1467 * 1468 * Returns 0 on success or <0 on failure 1469 * 1470 * gelic_ether_setup_netdev initializes the net_device structure 1471 * and register it. 1472 **/ 1473 int 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 packets 1501 */ 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 /** 1522 * gelic_alloc_card_net - allocates net_device and card structure 1523 * 1524 * returns the card structure or NULL in case of errors 1525 * 1526 * the card and net_device structures are linked to each other 1527 */ 1528 #define GELIC_ALIGN (32) 1529 static struct gelic_card *gelic_alloc_card_net(struct net_device **netdev) 1530 { 1531 struct gelic_card *card; 1532 struct gelic_port *port; 1533 void *p; 1534 size_t alloc_size; 1535 /* 1536 * gelic requires dma descriptor is 32 bytes aligned and 1537 * the hypervisor requires irq_status is 8 bytes aligned. 1538 */ 1539 BUILD_BUG_ON(offsetof(struct gelic_card, irq_status) % 8); 1540 BUILD_BUG_ON(offsetof(struct gelic_card, descr) % 32); 1541 alloc_size = 1542 sizeof(struct gelic_card) + 1543 sizeof(struct gelic_descr) * GELIC_NET_RX_DESCRIPTORS + 1544 sizeof(struct gelic_descr) * GELIC_NET_TX_DESCRIPTORS + 1545 GELIC_ALIGN - 1; 1546 1547 p = kzalloc(alloc_size, GFP_KERNEL); 1548 if (!p) 1549 return NULL; 1550 card = PTR_ALIGN(p, GELIC_ALIGN); 1551 card->unalign = p; 1552 1553 /* 1554 * alloc netdev 1555 */ 1556 *netdev = alloc_etherdev(sizeof(struct gelic_port)); 1557 if (!*netdev) { 1558 kfree(card->unalign); 1559 return NULL; 1560 } 1561 port = netdev_priv(*netdev); 1562 1563 /* gelic_port */ 1564 port->netdev = *netdev; 1565 port->card = card; 1566 port->type = GELIC_PORT_ETHERNET_0; 1567 1568 /* gelic_card */ 1569 card->netdev[GELIC_PORT_ETHERNET_0] = *netdev; 1570 1571 INIT_WORK(&card->tx_timeout_task, gelic_net_tx_timeout_task); 1572 init_waitqueue_head(&card->waitq); 1573 atomic_set(&card->tx_timeout_task_counter, 0); 1574 mutex_init(&card->updown_lock); 1575 atomic_set(&card->users, 0); 1576 1577 return card; 1578 } 1579 1580 static void gelic_card_get_vlan_info(struct gelic_card *card) 1581 { 1582 u64 v1, v2; 1583 int status; 1584 unsigned int i; 1585 struct { 1586 int tx; 1587 int rx; 1588 } vlan_id_ix[2] = { 1589 [GELIC_PORT_ETHERNET_0] = { 1590 .tx = GELIC_LV1_VLAN_TX_ETHERNET_0, 1591 .rx = GELIC_LV1_VLAN_RX_ETHERNET_0 1592 }, 1593 [GELIC_PORT_WIRELESS] = { 1594 .tx = GELIC_LV1_VLAN_TX_WIRELESS, 1595 .rx = GELIC_LV1_VLAN_RX_WIRELESS 1596 } 1597 }; 1598 1599 for (i = 0; i < ARRAY_SIZE(vlan_id_ix); i++) { 1600 /* tx tag */ 1601 status = lv1_net_control(bus_id(card), dev_id(card), 1602 GELIC_LV1_GET_VLAN_ID, 1603 vlan_id_ix[i].tx, 1604 0, 0, &v1, &v2); 1605 if (status || !v1) { 1606 if (status != LV1_NO_ENTRY) 1607 dev_dbg(ctodev(card), 1608 "get vlan id for tx(%d) failed(%d)\n", 1609 vlan_id_ix[i].tx, status); 1610 card->vlan[i].tx = 0; 1611 card->vlan[i].rx = 0; 1612 continue; 1613 } 1614 card->vlan[i].tx = (u16)v1; 1615 1616 /* rx tag */ 1617 status = lv1_net_control(bus_id(card), dev_id(card), 1618 GELIC_LV1_GET_VLAN_ID, 1619 vlan_id_ix[i].rx, 1620 0, 0, &v1, &v2); 1621 if (status || !v1) { 1622 if (status != LV1_NO_ENTRY) 1623 dev_info(ctodev(card), 1624 "get vlan id for rx(%d) failed(%d)\n", 1625 vlan_id_ix[i].rx, status); 1626 card->vlan[i].tx = 0; 1627 card->vlan[i].rx = 0; 1628 continue; 1629 } 1630 card->vlan[i].rx = (u16)v1; 1631 1632 dev_dbg(ctodev(card), "vlan_id[%d] tx=%02x rx=%02x\n", 1633 i, card->vlan[i].tx, card->vlan[i].rx); 1634 } 1635 1636 if (card->vlan[GELIC_PORT_ETHERNET_0].tx) { 1637 BUG_ON(!card->vlan[GELIC_PORT_WIRELESS].tx); 1638 card->vlan_required = 1; 1639 } else 1640 card->vlan_required = 0; 1641 1642 /* check wirelss capable firmware */ 1643 if (ps3_compare_firmware_version(1, 6, 0) < 0) { 1644 card->vlan[GELIC_PORT_WIRELESS].tx = 0; 1645 card->vlan[GELIC_PORT_WIRELESS].rx = 0; 1646 } 1647 1648 dev_info(ctodev(card), "internal vlan %s\n", 1649 card->vlan_required? "enabled" : "disabled"); 1650 } 1651 /* 1652 * ps3_gelic_driver_probe - add a device to the control of this driver 1653 */ 1654 static int ps3_gelic_driver_probe(struct ps3_system_bus_device *dev) 1655 { 1656 struct gelic_card *card; 1657 struct net_device *netdev; 1658 int result; 1659 1660 pr_debug("%s: called\n", __func__); 1661 1662 udbg_shutdown_ps3gelic(); 1663 1664 result = ps3_open_hv_device(dev); 1665 1666 if (result) { 1667 dev_dbg(&dev->core, "%s:ps3_open_hv_device failed\n", 1668 __func__); 1669 goto fail_open; 1670 } 1671 1672 result = ps3_dma_region_create(dev->d_region); 1673 1674 if (result) { 1675 dev_dbg(&dev->core, "%s:ps3_dma_region_create failed(%d)\n", 1676 __func__, result); 1677 BUG_ON("check region type"); 1678 goto fail_dma_region; 1679 } 1680 1681 /* alloc card/netdevice */ 1682 card = gelic_alloc_card_net(&netdev); 1683 if (!card) { 1684 dev_info(&dev->core, "%s:gelic_net_alloc_card failed\n", 1685 __func__); 1686 result = -ENOMEM; 1687 goto fail_alloc_card; 1688 } 1689 ps3_system_bus_set_drvdata(dev, card); 1690 card->dev = dev; 1691 1692 /* get internal vlan info */ 1693 gelic_card_get_vlan_info(card); 1694 1695 card->link_mode = GELIC_LV1_ETHER_AUTO_NEG; 1696 1697 /* setup interrupt */ 1698 result = lv1_net_set_interrupt_status_indicator(bus_id(card), 1699 dev_id(card), 1700 ps3_mm_phys_to_lpar(__pa(&card->irq_status)), 1701 0); 1702 1703 if (result) { 1704 dev_dbg(&dev->core, 1705 "%s:set_interrupt_status_indicator failed: %s\n", 1706 __func__, ps3_result(result)); 1707 result = -EIO; 1708 goto fail_status_indicator; 1709 } 1710 1711 result = ps3_sb_event_receive_port_setup(dev, PS3_BINDING_CPU_ANY, 1712 &card->irq); 1713 1714 if (result) { 1715 dev_info(ctodev(card), 1716 "%s:gelic_net_open_device failed (%d)\n", 1717 __func__, result); 1718 result = -EPERM; 1719 goto fail_alloc_irq; 1720 } 1721 result = request_irq(card->irq, gelic_card_interrupt, 1722 0, netdev->name, card); 1723 1724 if (result) { 1725 dev_info(ctodev(card), "%s:request_irq failed (%d)\n", 1726 __func__, result); 1727 goto fail_request_irq; 1728 } 1729 1730 /* setup card structure */ 1731 card->irq_mask = GELIC_CARD_RXINT | GELIC_CARD_TXINT | 1732 GELIC_CARD_PORT_STATUS_CHANGED; 1733 1734 1735 result = gelic_card_init_chain(card, &card->tx_chain, 1736 card->descr, GELIC_NET_TX_DESCRIPTORS); 1737 if (result) 1738 goto fail_alloc_tx; 1739 result = gelic_card_init_chain(card, &card->rx_chain, 1740 card->descr + GELIC_NET_TX_DESCRIPTORS, 1741 GELIC_NET_RX_DESCRIPTORS); 1742 if (result) 1743 goto fail_alloc_rx; 1744 1745 /* head of chain */ 1746 card->tx_top = card->tx_chain.head; 1747 card->rx_top = card->rx_chain.head; 1748 dev_dbg(ctodev(card), "descr rx %p, tx %p, size %#lx, num %#x\n", 1749 card->rx_top, card->tx_top, sizeof(struct gelic_descr), 1750 GELIC_NET_RX_DESCRIPTORS); 1751 /* allocate rx skbs */ 1752 result = gelic_card_alloc_rx_skbs(card); 1753 if (result) 1754 goto fail_alloc_skbs; 1755 1756 spin_lock_init(&card->tx_lock); 1757 card->tx_dma_progress = 0; 1758 1759 /* setup net_device structure */ 1760 netdev->irq = card->irq; 1761 SET_NETDEV_DEV(netdev, &card->dev->core); 1762 gelic_ether_setup_netdev_ops(netdev, &card->napi); 1763 result = gelic_net_setup_netdev(netdev, card); 1764 if (result) { 1765 dev_dbg(&dev->core, "%s: setup_netdev failed %d\n", 1766 __func__, result); 1767 goto fail_setup_netdev; 1768 } 1769 1770 #ifdef CONFIG_GELIC_WIRELESS 1771 result = gelic_wl_driver_probe(card); 1772 if (result) { 1773 dev_dbg(&dev->core, "%s: WL init failed\n", __func__); 1774 goto fail_setup_netdev; 1775 } 1776 #endif 1777 pr_debug("%s: done\n", __func__); 1778 return 0; 1779 1780 fail_setup_netdev: 1781 fail_alloc_skbs: 1782 gelic_card_free_chain(card, card->rx_chain.head); 1783 fail_alloc_rx: 1784 gelic_card_free_chain(card, card->tx_chain.head); 1785 fail_alloc_tx: 1786 free_irq(card->irq, card); 1787 netdev->irq = 0; 1788 fail_request_irq: 1789 ps3_sb_event_receive_port_destroy(dev, card->irq); 1790 fail_alloc_irq: 1791 lv1_net_set_interrupt_status_indicator(bus_id(card), 1792 bus_id(card), 1793 0, 0); 1794 fail_status_indicator: 1795 ps3_system_bus_set_drvdata(dev, NULL); 1796 kfree(netdev_card(netdev)->unalign); 1797 free_netdev(netdev); 1798 fail_alloc_card: 1799 ps3_dma_region_free(dev->d_region); 1800 fail_dma_region: 1801 ps3_close_hv_device(dev); 1802 fail_open: 1803 return result; 1804 } 1805 1806 /* 1807 * ps3_gelic_driver_remove - remove a device from the control of this driver 1808 */ 1809 1810 static void ps3_gelic_driver_remove(struct ps3_system_bus_device *dev) 1811 { 1812 struct gelic_card *card = ps3_system_bus_get_drvdata(dev); 1813 struct net_device *netdev0; 1814 pr_debug("%s: called\n", __func__); 1815 1816 /* set auto-negotiation */ 1817 gelic_card_set_link_mode(card, GELIC_LV1_ETHER_AUTO_NEG); 1818 1819 #ifdef CONFIG_GELIC_WIRELESS 1820 gelic_wl_driver_remove(card); 1821 #endif 1822 /* stop interrupt */ 1823 gelic_card_set_irq_mask(card, 0); 1824 1825 /* turn off DMA, force end */ 1826 gelic_card_disable_rxdmac(card); 1827 gelic_card_disable_txdmac(card); 1828 1829 /* release chains */ 1830 gelic_card_release_tx_chain(card, 1); 1831 gelic_card_release_rx_chain(card); 1832 1833 gelic_card_free_chain(card, card->tx_top); 1834 gelic_card_free_chain(card, card->rx_top); 1835 1836 netdev0 = card->netdev[GELIC_PORT_ETHERNET_0]; 1837 /* disconnect event port */ 1838 free_irq(card->irq, card); 1839 netdev0->irq = 0; 1840 ps3_sb_event_receive_port_destroy(card->dev, card->irq); 1841 1842 wait_event(card->waitq, 1843 atomic_read(&card->tx_timeout_task_counter) == 0); 1844 1845 lv1_net_set_interrupt_status_indicator(bus_id(card), dev_id(card), 1846 0 , 0); 1847 1848 unregister_netdev(netdev0); 1849 kfree(netdev_card(netdev0)->unalign); 1850 free_netdev(netdev0); 1851 1852 ps3_system_bus_set_drvdata(dev, NULL); 1853 1854 ps3_dma_region_free(dev->d_region); 1855 1856 ps3_close_hv_device(dev); 1857 1858 pr_debug("%s: done\n", __func__); 1859 } 1860 1861 static struct ps3_system_bus_driver ps3_gelic_driver = { 1862 .match_id = PS3_MATCH_ID_GELIC, 1863 .probe = ps3_gelic_driver_probe, 1864 .remove = ps3_gelic_driver_remove, 1865 .shutdown = ps3_gelic_driver_remove, 1866 .core.name = "ps3_gelic_driver", 1867 .core.owner = THIS_MODULE, 1868 }; 1869 1870 static int __init ps3_gelic_driver_init (void) 1871 { 1872 return firmware_has_feature(FW_FEATURE_PS3_LV1) 1873 ? ps3_system_bus_driver_register(&ps3_gelic_driver) 1874 : -ENODEV; 1875 } 1876 1877 static void __exit ps3_gelic_driver_exit (void) 1878 { 1879 ps3_system_bus_driver_unregister(&ps3_gelic_driver); 1880 } 1881 1882 module_init(ps3_gelic_driver_init); 1883 module_exit(ps3_gelic_driver_exit); 1884 1885 MODULE_ALIAS(PS3_MODULE_ALIAS_GELIC); 1886 1887