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 = 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_done(napi, packets_done); 1113 gelic_card_rx_irq_on(card); 1114 } 1115 return packets_done; 1116 } 1117 1118 /** 1119 * gelic_card_interrupt - event handler for gelic_net 1120 */ 1121 static irqreturn_t gelic_card_interrupt(int irq, void *ptr) 1122 { 1123 unsigned long flags; 1124 struct gelic_card *card = ptr; 1125 u64 status; 1126 1127 status = card->irq_status; 1128 1129 if (!status) 1130 return IRQ_NONE; 1131 1132 status &= card->irq_mask; 1133 1134 if (status & GELIC_CARD_RXINT) { 1135 gelic_card_rx_irq_off(card); 1136 napi_schedule(&card->napi); 1137 } 1138 1139 if (status & GELIC_CARD_TXINT) { 1140 spin_lock_irqsave(&card->tx_lock, flags); 1141 card->tx_dma_progress = 0; 1142 gelic_card_release_tx_chain(card, 0); 1143 /* kick outstanding tx descriptor if any */ 1144 gelic_card_kick_txdma(card, card->tx_chain.tail); 1145 spin_unlock_irqrestore(&card->tx_lock, flags); 1146 } 1147 1148 /* ether port status changed */ 1149 if (status & GELIC_CARD_PORT_STATUS_CHANGED) 1150 gelic_card_get_ether_port_status(card, 1); 1151 1152 #ifdef CONFIG_GELIC_WIRELESS 1153 if (status & (GELIC_CARD_WLAN_EVENT_RECEIVED | 1154 GELIC_CARD_WLAN_COMMAND_COMPLETED)) 1155 gelic_wl_interrupt(card->netdev[GELIC_PORT_WIRELESS], status); 1156 #endif 1157 1158 return IRQ_HANDLED; 1159 } 1160 1161 #ifdef CONFIG_NET_POLL_CONTROLLER 1162 /** 1163 * gelic_net_poll_controller - artificial interrupt for netconsole etc. 1164 * @netdev: interface device structure 1165 * 1166 * see Documentation/networking/netconsole.txt 1167 */ 1168 void gelic_net_poll_controller(struct net_device *netdev) 1169 { 1170 struct gelic_card *card = netdev_card(netdev); 1171 1172 gelic_card_set_irq_mask(card, 0); 1173 gelic_card_interrupt(netdev->irq, netdev); 1174 gelic_card_set_irq_mask(card, card->irq_mask); 1175 } 1176 #endif /* CONFIG_NET_POLL_CONTROLLER */ 1177 1178 /** 1179 * gelic_net_open - called upon ifconfig up 1180 * @netdev: interface device structure 1181 * 1182 * returns 0 on success, <0 on failure 1183 * 1184 * gelic_net_open allocates all the descriptors and memory needed for 1185 * operation, sets up multicast list and enables interrupts 1186 */ 1187 int gelic_net_open(struct net_device *netdev) 1188 { 1189 struct gelic_card *card = netdev_card(netdev); 1190 1191 dev_dbg(ctodev(card), " -> %s %p\n", __func__, netdev); 1192 1193 gelic_card_up(card); 1194 1195 netif_start_queue(netdev); 1196 gelic_card_get_ether_port_status(card, 1); 1197 1198 dev_dbg(ctodev(card), " <- %s\n", __func__); 1199 return 0; 1200 } 1201 1202 void gelic_net_get_drvinfo(struct net_device *netdev, 1203 struct ethtool_drvinfo *info) 1204 { 1205 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 1206 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 1207 } 1208 1209 static int gelic_ether_get_link_ksettings(struct net_device *netdev, 1210 struct ethtool_link_ksettings *cmd) 1211 { 1212 struct gelic_card *card = netdev_card(netdev); 1213 u32 supported, advertising; 1214 1215 gelic_card_get_ether_port_status(card, 0); 1216 1217 if (card->ether_port_status & GELIC_LV1_ETHER_FULL_DUPLEX) 1218 cmd->base.duplex = DUPLEX_FULL; 1219 else 1220 cmd->base.duplex = DUPLEX_HALF; 1221 1222 switch (card->ether_port_status & GELIC_LV1_ETHER_SPEED_MASK) { 1223 case GELIC_LV1_ETHER_SPEED_10: 1224 cmd->base.speed = SPEED_10; 1225 break; 1226 case GELIC_LV1_ETHER_SPEED_100: 1227 cmd->base.speed = SPEED_100; 1228 break; 1229 case GELIC_LV1_ETHER_SPEED_1000: 1230 cmd->base.speed = SPEED_1000; 1231 break; 1232 default: 1233 pr_info("%s: speed unknown\n", __func__); 1234 cmd->base.speed = SPEED_10; 1235 break; 1236 } 1237 1238 supported = SUPPORTED_TP | SUPPORTED_Autoneg | 1239 SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | 1240 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full | 1241 SUPPORTED_1000baseT_Full; 1242 advertising = supported; 1243 if (card->link_mode & GELIC_LV1_ETHER_AUTO_NEG) { 1244 cmd->base.autoneg = AUTONEG_ENABLE; 1245 } else { 1246 cmd->base.autoneg = AUTONEG_DISABLE; 1247 advertising &= ~ADVERTISED_Autoneg; 1248 } 1249 cmd->base.port = PORT_TP; 1250 1251 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported, 1252 supported); 1253 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising, 1254 advertising); 1255 1256 return 0; 1257 } 1258 1259 static int 1260 gelic_ether_set_link_ksettings(struct net_device *netdev, 1261 const struct ethtool_link_ksettings *cmd) 1262 { 1263 struct gelic_card *card = netdev_card(netdev); 1264 u64 mode; 1265 int ret; 1266 1267 if (cmd->base.autoneg == AUTONEG_ENABLE) { 1268 mode = GELIC_LV1_ETHER_AUTO_NEG; 1269 } else { 1270 switch (cmd->base.speed) { 1271 case SPEED_10: 1272 mode = GELIC_LV1_ETHER_SPEED_10; 1273 break; 1274 case SPEED_100: 1275 mode = GELIC_LV1_ETHER_SPEED_100; 1276 break; 1277 case SPEED_1000: 1278 mode = GELIC_LV1_ETHER_SPEED_1000; 1279 break; 1280 default: 1281 return -EINVAL; 1282 } 1283 if (cmd->base.duplex == DUPLEX_FULL) { 1284 mode |= GELIC_LV1_ETHER_FULL_DUPLEX; 1285 } else if (cmd->base.speed == SPEED_1000) { 1286 pr_info("1000 half duplex is not supported.\n"); 1287 return -EINVAL; 1288 } 1289 } 1290 1291 ret = gelic_card_set_link_mode(card, mode); 1292 1293 if (ret) 1294 return ret; 1295 1296 return 0; 1297 } 1298 1299 static void gelic_net_get_wol(struct net_device *netdev, 1300 struct ethtool_wolinfo *wol) 1301 { 1302 if (0 <= ps3_compare_firmware_version(2, 2, 0)) 1303 wol->supported = WAKE_MAGIC; 1304 else 1305 wol->supported = 0; 1306 1307 wol->wolopts = ps3_sys_manager_get_wol() ? wol->supported : 0; 1308 memset(&wol->sopass, 0, sizeof(wol->sopass)); 1309 } 1310 static int gelic_net_set_wol(struct net_device *netdev, 1311 struct ethtool_wolinfo *wol) 1312 { 1313 int status; 1314 struct gelic_card *card; 1315 u64 v1, v2; 1316 1317 if (ps3_compare_firmware_version(2, 2, 0) < 0 || 1318 !capable(CAP_NET_ADMIN)) 1319 return -EPERM; 1320 1321 if (wol->wolopts & ~WAKE_MAGIC) 1322 return -EINVAL; 1323 1324 card = netdev_card(netdev); 1325 if (wol->wolopts & WAKE_MAGIC) { 1326 status = lv1_net_control(bus_id(card), dev_id(card), 1327 GELIC_LV1_SET_WOL, 1328 GELIC_LV1_WOL_MAGIC_PACKET, 1329 0, GELIC_LV1_WOL_MP_ENABLE, 1330 &v1, &v2); 1331 if (status) { 1332 pr_info("%s: enabling WOL failed %d\n", __func__, 1333 status); 1334 status = -EIO; 1335 goto done; 1336 } 1337 status = lv1_net_control(bus_id(card), dev_id(card), 1338 GELIC_LV1_SET_WOL, 1339 GELIC_LV1_WOL_ADD_MATCH_ADDR, 1340 0, GELIC_LV1_WOL_MATCH_ALL, 1341 &v1, &v2); 1342 if (!status) 1343 ps3_sys_manager_set_wol(1); 1344 else { 1345 pr_info("%s: enabling WOL filter failed %d\n", 1346 __func__, status); 1347 status = -EIO; 1348 } 1349 } else { 1350 status = lv1_net_control(bus_id(card), dev_id(card), 1351 GELIC_LV1_SET_WOL, 1352 GELIC_LV1_WOL_MAGIC_PACKET, 1353 0, GELIC_LV1_WOL_MP_DISABLE, 1354 &v1, &v2); 1355 if (status) { 1356 pr_info("%s: disabling WOL failed %d\n", __func__, 1357 status); 1358 status = -EIO; 1359 goto done; 1360 } 1361 status = lv1_net_control(bus_id(card), dev_id(card), 1362 GELIC_LV1_SET_WOL, 1363 GELIC_LV1_WOL_DELETE_MATCH_ADDR, 1364 0, GELIC_LV1_WOL_MATCH_ALL, 1365 &v1, &v2); 1366 if (!status) 1367 ps3_sys_manager_set_wol(0); 1368 else { 1369 pr_info("%s: removing WOL filter failed %d\n", 1370 __func__, status); 1371 status = -EIO; 1372 } 1373 } 1374 done: 1375 return status; 1376 } 1377 1378 static const struct ethtool_ops gelic_ether_ethtool_ops = { 1379 .get_drvinfo = gelic_net_get_drvinfo, 1380 .get_link = ethtool_op_get_link, 1381 .get_wol = gelic_net_get_wol, 1382 .set_wol = gelic_net_set_wol, 1383 .get_link_ksettings = gelic_ether_get_link_ksettings, 1384 .set_link_ksettings = gelic_ether_set_link_ksettings, 1385 }; 1386 1387 /** 1388 * gelic_net_tx_timeout_task - task scheduled by the watchdog timeout 1389 * function (to be called not under interrupt status) 1390 * @work: work is context of tx timout task 1391 * 1392 * called as task when tx hangs, resets interface (if interface is up) 1393 */ 1394 static void gelic_net_tx_timeout_task(struct work_struct *work) 1395 { 1396 struct gelic_card *card = 1397 container_of(work, struct gelic_card, tx_timeout_task); 1398 struct net_device *netdev = card->netdev[GELIC_PORT_ETHERNET_0]; 1399 1400 dev_info(ctodev(card), "%s:Timed out. Restarting...\n", __func__); 1401 1402 if (!(netdev->flags & IFF_UP)) 1403 goto out; 1404 1405 netif_device_detach(netdev); 1406 gelic_net_stop(netdev); 1407 1408 gelic_net_open(netdev); 1409 netif_device_attach(netdev); 1410 1411 out: 1412 atomic_dec(&card->tx_timeout_task_counter); 1413 } 1414 1415 /** 1416 * gelic_net_tx_timeout - called when the tx timeout watchdog kicks in. 1417 * @netdev: interface device structure 1418 * 1419 * called, if tx hangs. Schedules a task that resets the interface 1420 */ 1421 void gelic_net_tx_timeout(struct net_device *netdev) 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 * 1450 * fills out function pointers in the net_device structure 1451 */ 1452 static void gelic_ether_setup_netdev_ops(struct net_device *netdev, 1453 struct napi_struct *napi) 1454 { 1455 netdev->watchdog_timeo = GELIC_NET_WATCHDOG_TIMEOUT; 1456 /* NAPI */ 1457 netif_napi_add(netdev, napi, gelic_net_poll, NAPI_POLL_WEIGHT); 1458 netdev->ethtool_ops = &gelic_ether_ethtool_ops; 1459 netdev->netdev_ops = &gelic_netdevice_ops; 1460 } 1461 1462 /** 1463 * gelic_ether_setup_netdev - initialization of net_device 1464 * @netdev: net_device structure 1465 * @card: card structure 1466 * 1467 * Returns 0 on success or <0 on failure 1468 * 1469 * gelic_ether_setup_netdev initializes the net_device structure 1470 * and register it. 1471 **/ 1472 int gelic_net_setup_netdev(struct net_device *netdev, struct gelic_card *card) 1473 { 1474 int status; 1475 u64 v1, v2; 1476 1477 netdev->hw_features = NETIF_F_IP_CSUM | NETIF_F_RXCSUM; 1478 1479 netdev->features = NETIF_F_IP_CSUM; 1480 if (GELIC_CARD_RX_CSUM_DEFAULT) 1481 netdev->features |= NETIF_F_RXCSUM; 1482 1483 status = lv1_net_control(bus_id(card), dev_id(card), 1484 GELIC_LV1_GET_MAC_ADDRESS, 1485 0, 0, 0, &v1, &v2); 1486 v1 <<= 16; 1487 if (status || !is_valid_ether_addr((u8 *)&v1)) { 1488 dev_info(ctodev(card), 1489 "%s:lv1_net_control GET_MAC_ADDR failed %d\n", 1490 __func__, status); 1491 return -EINVAL; 1492 } 1493 memcpy(netdev->dev_addr, &v1, ETH_ALEN); 1494 1495 if (card->vlan_required) { 1496 netdev->hard_header_len += VLAN_HLEN; 1497 /* 1498 * As vlan is internally used, 1499 * we can not receive vlan packets 1500 */ 1501 netdev->features |= NETIF_F_VLAN_CHALLENGED; 1502 } 1503 1504 /* MTU range: 64 - 1518 */ 1505 netdev->min_mtu = GELIC_NET_MIN_MTU; 1506 netdev->max_mtu = GELIC_NET_MAX_MTU; 1507 1508 status = register_netdev(netdev); 1509 if (status) { 1510 dev_err(ctodev(card), "%s:Couldn't register %s %d\n", 1511 __func__, netdev->name, status); 1512 return status; 1513 } 1514 dev_info(ctodev(card), "%s: MAC addr %pM\n", 1515 netdev->name, netdev->dev_addr); 1516 1517 return 0; 1518 } 1519 1520 /** 1521 * gelic_alloc_card_net - allocates net_device and card structure 1522 * 1523 * returns the card structure or NULL in case of errors 1524 * 1525 * the card and net_device structures are linked to each other 1526 */ 1527 #define GELIC_ALIGN (32) 1528 static struct gelic_card *gelic_alloc_card_net(struct net_device **netdev) 1529 { 1530 struct gelic_card *card; 1531 struct gelic_port *port; 1532 void *p; 1533 size_t alloc_size; 1534 /* 1535 * gelic requires dma descriptor is 32 bytes aligned and 1536 * the hypervisor requires irq_status is 8 bytes aligned. 1537 */ 1538 BUILD_BUG_ON(offsetof(struct gelic_card, irq_status) % 8); 1539 BUILD_BUG_ON(offsetof(struct gelic_card, descr) % 32); 1540 alloc_size = 1541 sizeof(struct gelic_card) + 1542 sizeof(struct gelic_descr) * GELIC_NET_RX_DESCRIPTORS + 1543 sizeof(struct gelic_descr) * GELIC_NET_TX_DESCRIPTORS + 1544 GELIC_ALIGN - 1; 1545 1546 p = kzalloc(alloc_size, GFP_KERNEL); 1547 if (!p) 1548 return NULL; 1549 card = PTR_ALIGN(p, GELIC_ALIGN); 1550 card->unalign = p; 1551 1552 /* 1553 * alloc netdev 1554 */ 1555 *netdev = alloc_etherdev(sizeof(struct gelic_port)); 1556 if (!*netdev) { 1557 kfree(card->unalign); 1558 return NULL; 1559 } 1560 port = netdev_priv(*netdev); 1561 1562 /* gelic_port */ 1563 port->netdev = *netdev; 1564 port->card = card; 1565 port->type = GELIC_PORT_ETHERNET_0; 1566 1567 /* gelic_card */ 1568 card->netdev[GELIC_PORT_ETHERNET_0] = *netdev; 1569 1570 INIT_WORK(&card->tx_timeout_task, gelic_net_tx_timeout_task); 1571 init_waitqueue_head(&card->waitq); 1572 atomic_set(&card->tx_timeout_task_counter, 0); 1573 mutex_init(&card->updown_lock); 1574 atomic_set(&card->users, 0); 1575 1576 return card; 1577 } 1578 1579 static void gelic_card_get_vlan_info(struct gelic_card *card) 1580 { 1581 u64 v1, v2; 1582 int status; 1583 unsigned int i; 1584 struct { 1585 int tx; 1586 int rx; 1587 } vlan_id_ix[2] = { 1588 [GELIC_PORT_ETHERNET_0] = { 1589 .tx = GELIC_LV1_VLAN_TX_ETHERNET_0, 1590 .rx = GELIC_LV1_VLAN_RX_ETHERNET_0 1591 }, 1592 [GELIC_PORT_WIRELESS] = { 1593 .tx = GELIC_LV1_VLAN_TX_WIRELESS, 1594 .rx = GELIC_LV1_VLAN_RX_WIRELESS 1595 } 1596 }; 1597 1598 for (i = 0; i < ARRAY_SIZE(vlan_id_ix); i++) { 1599 /* tx tag */ 1600 status = lv1_net_control(bus_id(card), dev_id(card), 1601 GELIC_LV1_GET_VLAN_ID, 1602 vlan_id_ix[i].tx, 1603 0, 0, &v1, &v2); 1604 if (status || !v1) { 1605 if (status != LV1_NO_ENTRY) 1606 dev_dbg(ctodev(card), 1607 "get vlan id for tx(%d) failed(%d)\n", 1608 vlan_id_ix[i].tx, status); 1609 card->vlan[i].tx = 0; 1610 card->vlan[i].rx = 0; 1611 continue; 1612 } 1613 card->vlan[i].tx = (u16)v1; 1614 1615 /* rx tag */ 1616 status = lv1_net_control(bus_id(card), dev_id(card), 1617 GELIC_LV1_GET_VLAN_ID, 1618 vlan_id_ix[i].rx, 1619 0, 0, &v1, &v2); 1620 if (status || !v1) { 1621 if (status != LV1_NO_ENTRY) 1622 dev_info(ctodev(card), 1623 "get vlan id for rx(%d) failed(%d)\n", 1624 vlan_id_ix[i].rx, status); 1625 card->vlan[i].tx = 0; 1626 card->vlan[i].rx = 0; 1627 continue; 1628 } 1629 card->vlan[i].rx = (u16)v1; 1630 1631 dev_dbg(ctodev(card), "vlan_id[%d] tx=%02x rx=%02x\n", 1632 i, card->vlan[i].tx, card->vlan[i].rx); 1633 } 1634 1635 if (card->vlan[GELIC_PORT_ETHERNET_0].tx) { 1636 BUG_ON(!card->vlan[GELIC_PORT_WIRELESS].tx); 1637 card->vlan_required = 1; 1638 } else 1639 card->vlan_required = 0; 1640 1641 /* check wirelss capable firmware */ 1642 if (ps3_compare_firmware_version(1, 6, 0) < 0) { 1643 card->vlan[GELIC_PORT_WIRELESS].tx = 0; 1644 card->vlan[GELIC_PORT_WIRELESS].rx = 0; 1645 } 1646 1647 dev_info(ctodev(card), "internal vlan %s\n", 1648 card->vlan_required? "enabled" : "disabled"); 1649 } 1650 /** 1651 * ps3_gelic_driver_probe - add a device to the control of this driver 1652 */ 1653 static int ps3_gelic_driver_probe(struct ps3_system_bus_device *dev) 1654 { 1655 struct gelic_card *card; 1656 struct net_device *netdev; 1657 int result; 1658 1659 pr_debug("%s: called\n", __func__); 1660 1661 udbg_shutdown_ps3gelic(); 1662 1663 result = ps3_open_hv_device(dev); 1664 1665 if (result) { 1666 dev_dbg(&dev->core, "%s:ps3_open_hv_device failed\n", 1667 __func__); 1668 goto fail_open; 1669 } 1670 1671 result = ps3_dma_region_create(dev->d_region); 1672 1673 if (result) { 1674 dev_dbg(&dev->core, "%s:ps3_dma_region_create failed(%d)\n", 1675 __func__, result); 1676 BUG_ON("check region type"); 1677 goto fail_dma_region; 1678 } 1679 1680 /* alloc card/netdevice */ 1681 card = gelic_alloc_card_net(&netdev); 1682 if (!card) { 1683 dev_info(&dev->core, "%s:gelic_net_alloc_card failed\n", 1684 __func__); 1685 result = -ENOMEM; 1686 goto fail_alloc_card; 1687 } 1688 ps3_system_bus_set_drvdata(dev, card); 1689 card->dev = dev; 1690 1691 /* get internal vlan info */ 1692 gelic_card_get_vlan_info(card); 1693 1694 card->link_mode = GELIC_LV1_ETHER_AUTO_NEG; 1695 1696 /* setup interrupt */ 1697 result = lv1_net_set_interrupt_status_indicator(bus_id(card), 1698 dev_id(card), 1699 ps3_mm_phys_to_lpar(__pa(&card->irq_status)), 1700 0); 1701 1702 if (result) { 1703 dev_dbg(&dev->core, 1704 "%s:set_interrupt_status_indicator failed: %s\n", 1705 __func__, ps3_result(result)); 1706 result = -EIO; 1707 goto fail_status_indicator; 1708 } 1709 1710 result = ps3_sb_event_receive_port_setup(dev, PS3_BINDING_CPU_ANY, 1711 &card->irq); 1712 1713 if (result) { 1714 dev_info(ctodev(card), 1715 "%s:gelic_net_open_device failed (%d)\n", 1716 __func__, result); 1717 result = -EPERM; 1718 goto fail_alloc_irq; 1719 } 1720 result = request_irq(card->irq, gelic_card_interrupt, 1721 0, netdev->name, card); 1722 1723 if (result) { 1724 dev_info(ctodev(card), "%s:request_irq failed (%d)\n", 1725 __func__, result); 1726 goto fail_request_irq; 1727 } 1728 1729 /* setup card structure */ 1730 card->irq_mask = GELIC_CARD_RXINT | GELIC_CARD_TXINT | 1731 GELIC_CARD_PORT_STATUS_CHANGED; 1732 1733 1734 result = gelic_card_init_chain(card, &card->tx_chain, 1735 card->descr, GELIC_NET_TX_DESCRIPTORS); 1736 if (result) 1737 goto fail_alloc_tx; 1738 result = gelic_card_init_chain(card, &card->rx_chain, 1739 card->descr + GELIC_NET_TX_DESCRIPTORS, 1740 GELIC_NET_RX_DESCRIPTORS); 1741 if (result) 1742 goto fail_alloc_rx; 1743 1744 /* head of chain */ 1745 card->tx_top = card->tx_chain.head; 1746 card->rx_top = card->rx_chain.head; 1747 dev_dbg(ctodev(card), "descr rx %p, tx %p, size %#lx, num %#x\n", 1748 card->rx_top, card->tx_top, sizeof(struct gelic_descr), 1749 GELIC_NET_RX_DESCRIPTORS); 1750 /* allocate rx skbs */ 1751 result = gelic_card_alloc_rx_skbs(card); 1752 if (result) 1753 goto fail_alloc_skbs; 1754 1755 spin_lock_init(&card->tx_lock); 1756 card->tx_dma_progress = 0; 1757 1758 /* setup net_device structure */ 1759 netdev->irq = card->irq; 1760 SET_NETDEV_DEV(netdev, &card->dev->core); 1761 gelic_ether_setup_netdev_ops(netdev, &card->napi); 1762 result = gelic_net_setup_netdev(netdev, card); 1763 if (result) { 1764 dev_dbg(&dev->core, "%s: setup_netdev failed %d\n", 1765 __func__, result); 1766 goto fail_setup_netdev; 1767 } 1768 1769 #ifdef CONFIG_GELIC_WIRELESS 1770 result = gelic_wl_driver_probe(card); 1771 if (result) { 1772 dev_dbg(&dev->core, "%s: WL init failed\n", __func__); 1773 goto fail_setup_netdev; 1774 } 1775 #endif 1776 pr_debug("%s: done\n", __func__); 1777 return 0; 1778 1779 fail_setup_netdev: 1780 fail_alloc_skbs: 1781 gelic_card_free_chain(card, card->rx_chain.head); 1782 fail_alloc_rx: 1783 gelic_card_free_chain(card, card->tx_chain.head); 1784 fail_alloc_tx: 1785 free_irq(card->irq, card); 1786 netdev->irq = 0; 1787 fail_request_irq: 1788 ps3_sb_event_receive_port_destroy(dev, card->irq); 1789 fail_alloc_irq: 1790 lv1_net_set_interrupt_status_indicator(bus_id(card), 1791 bus_id(card), 1792 0, 0); 1793 fail_status_indicator: 1794 ps3_system_bus_set_drvdata(dev, NULL); 1795 kfree(netdev_card(netdev)->unalign); 1796 free_netdev(netdev); 1797 fail_alloc_card: 1798 ps3_dma_region_free(dev->d_region); 1799 fail_dma_region: 1800 ps3_close_hv_device(dev); 1801 fail_open: 1802 return result; 1803 } 1804 1805 /** 1806 * ps3_gelic_driver_remove - remove a device from the control of this driver 1807 */ 1808 1809 static int ps3_gelic_driver_remove(struct ps3_system_bus_device *dev) 1810 { 1811 struct gelic_card *card = ps3_system_bus_get_drvdata(dev); 1812 struct net_device *netdev0; 1813 pr_debug("%s: called\n", __func__); 1814 1815 /* set auto-negotiation */ 1816 gelic_card_set_link_mode(card, GELIC_LV1_ETHER_AUTO_NEG); 1817 1818 #ifdef CONFIG_GELIC_WIRELESS 1819 gelic_wl_driver_remove(card); 1820 #endif 1821 /* stop interrupt */ 1822 gelic_card_set_irq_mask(card, 0); 1823 1824 /* turn off DMA, force end */ 1825 gelic_card_disable_rxdmac(card); 1826 gelic_card_disable_txdmac(card); 1827 1828 /* release chains */ 1829 gelic_card_release_tx_chain(card, 1); 1830 gelic_card_release_rx_chain(card); 1831 1832 gelic_card_free_chain(card, card->tx_top); 1833 gelic_card_free_chain(card, card->rx_top); 1834 1835 netdev0 = card->netdev[GELIC_PORT_ETHERNET_0]; 1836 /* disconnect event port */ 1837 free_irq(card->irq, card); 1838 netdev0->irq = 0; 1839 ps3_sb_event_receive_port_destroy(card->dev, card->irq); 1840 1841 wait_event(card->waitq, 1842 atomic_read(&card->tx_timeout_task_counter) == 0); 1843 1844 lv1_net_set_interrupt_status_indicator(bus_id(card), dev_id(card), 1845 0 , 0); 1846 1847 unregister_netdev(netdev0); 1848 kfree(netdev_card(netdev0)->unalign); 1849 free_netdev(netdev0); 1850 1851 ps3_system_bus_set_drvdata(dev, NULL); 1852 1853 ps3_dma_region_free(dev->d_region); 1854 1855 ps3_close_hv_device(dev); 1856 1857 pr_debug("%s: done\n", __func__); 1858 return 0; 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