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