1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * FUJITSU Extended Socket Network Device driver 4 * Copyright (c) 2015 FUJITSU LIMITED 5 */ 6 7 #include <linux/module.h> 8 #include <linux/types.h> 9 #include <linux/nls.h> 10 #include <linux/platform_device.h> 11 #include <linux/netdevice.h> 12 #include <linux/interrupt.h> 13 14 #include "fjes.h" 15 #include "fjes_trace.h" 16 17 #define DRV_VERSION "1.2" 18 #define DRV_NAME "fjes" 19 char fjes_driver_name[] = DRV_NAME; 20 char fjes_driver_version[] = DRV_VERSION; 21 static const char fjes_driver_string[] = 22 "FUJITSU Extended Socket Network Device Driver"; 23 static const char fjes_copyright[] = 24 "Copyright (c) 2015 FUJITSU LIMITED"; 25 26 MODULE_AUTHOR("Taku Izumi <izumi.taku@jp.fujitsu.com>"); 27 MODULE_DESCRIPTION("FUJITSU Extended Socket Network Device Driver"); 28 MODULE_LICENSE("GPL"); 29 MODULE_VERSION(DRV_VERSION); 30 31 #define ACPI_MOTHERBOARD_RESOURCE_HID "PNP0C02" 32 33 static const struct acpi_device_id fjes_acpi_ids[] = { 34 {ACPI_MOTHERBOARD_RESOURCE_HID, 0}, 35 {"", 0}, 36 }; 37 MODULE_DEVICE_TABLE(acpi, fjes_acpi_ids); 38 39 static bool is_extended_socket_device(struct acpi_device *device) 40 { 41 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL}; 42 char str_buf[sizeof(FJES_ACPI_SYMBOL) + 1]; 43 union acpi_object *str; 44 acpi_status status; 45 int result; 46 47 status = acpi_evaluate_object(device->handle, "_STR", NULL, &buffer); 48 if (ACPI_FAILURE(status)) 49 return false; 50 51 str = buffer.pointer; 52 result = utf16s_to_utf8s((wchar_t *)str->string.pointer, 53 str->string.length, UTF16_LITTLE_ENDIAN, 54 str_buf, sizeof(str_buf) - 1); 55 str_buf[result] = 0; 56 57 if (strncmp(FJES_ACPI_SYMBOL, str_buf, strlen(FJES_ACPI_SYMBOL)) != 0) { 58 kfree(buffer.pointer); 59 return false; 60 } 61 kfree(buffer.pointer); 62 63 return true; 64 } 65 66 static int acpi_check_extended_socket_status(struct acpi_device *device) 67 { 68 unsigned long long sta; 69 acpi_status status; 70 71 status = acpi_evaluate_integer(device->handle, "_STA", NULL, &sta); 72 if (ACPI_FAILURE(status)) 73 return -ENODEV; 74 75 if (!((sta & ACPI_STA_DEVICE_PRESENT) && 76 (sta & ACPI_STA_DEVICE_ENABLED) && 77 (sta & ACPI_STA_DEVICE_UI) && 78 (sta & ACPI_STA_DEVICE_FUNCTIONING))) 79 return -ENODEV; 80 81 return 0; 82 } 83 84 static acpi_status 85 fjes_get_acpi_resource(struct acpi_resource *acpi_res, void *data) 86 { 87 struct acpi_resource_address32 *addr; 88 struct acpi_resource_irq *irq; 89 struct resource *res = data; 90 91 switch (acpi_res->type) { 92 case ACPI_RESOURCE_TYPE_ADDRESS32: 93 addr = &acpi_res->data.address32; 94 res[0].start = addr->address.minimum; 95 res[0].end = addr->address.minimum + 96 addr->address.address_length - 1; 97 break; 98 99 case ACPI_RESOURCE_TYPE_IRQ: 100 irq = &acpi_res->data.irq; 101 if (irq->interrupt_count != 1) 102 return AE_ERROR; 103 res[1].start = irq->interrupts[0]; 104 res[1].end = irq->interrupts[0]; 105 break; 106 107 default: 108 break; 109 } 110 111 return AE_OK; 112 } 113 114 static struct resource fjes_resource[] = { 115 DEFINE_RES_MEM(0, 1), 116 DEFINE_RES_IRQ(0) 117 }; 118 119 static int fjes_acpi_add(struct acpi_device *device) 120 { 121 struct platform_device *plat_dev; 122 acpi_status status; 123 124 if (!is_extended_socket_device(device)) 125 return -ENODEV; 126 127 if (acpi_check_extended_socket_status(device)) 128 return -ENODEV; 129 130 status = acpi_walk_resources(device->handle, METHOD_NAME__CRS, 131 fjes_get_acpi_resource, fjes_resource); 132 if (ACPI_FAILURE(status)) 133 return -ENODEV; 134 135 /* create platform_device */ 136 plat_dev = platform_device_register_simple(DRV_NAME, 0, fjes_resource, 137 ARRAY_SIZE(fjes_resource)); 138 if (IS_ERR(plat_dev)) 139 return PTR_ERR(plat_dev); 140 141 device->driver_data = plat_dev; 142 143 return 0; 144 } 145 146 static void fjes_acpi_remove(struct acpi_device *device) 147 { 148 struct platform_device *plat_dev; 149 150 plat_dev = (struct platform_device *)acpi_driver_data(device); 151 platform_device_unregister(plat_dev); 152 } 153 154 static struct acpi_driver fjes_acpi_driver = { 155 .name = DRV_NAME, 156 .class = DRV_NAME, 157 .ids = fjes_acpi_ids, 158 .ops = { 159 .add = fjes_acpi_add, 160 .remove = fjes_acpi_remove, 161 }, 162 }; 163 164 static int fjes_setup_resources(struct fjes_adapter *adapter) 165 { 166 struct net_device *netdev = adapter->netdev; 167 struct ep_share_mem_info *buf_pair; 168 struct fjes_hw *hw = &adapter->hw; 169 unsigned long flags; 170 int result; 171 int epidx; 172 173 mutex_lock(&hw->hw_info.lock); 174 result = fjes_hw_request_info(hw); 175 switch (result) { 176 case 0: 177 for (epidx = 0; epidx < hw->max_epid; epidx++) { 178 hw->ep_shm_info[epidx].es_status = 179 hw->hw_info.res_buf->info.info[epidx].es_status; 180 hw->ep_shm_info[epidx].zone = 181 hw->hw_info.res_buf->info.info[epidx].zone; 182 } 183 break; 184 default: 185 case -ENOMSG: 186 case -EBUSY: 187 adapter->force_reset = true; 188 189 mutex_unlock(&hw->hw_info.lock); 190 return result; 191 } 192 mutex_unlock(&hw->hw_info.lock); 193 194 for (epidx = 0; epidx < (hw->max_epid); epidx++) { 195 if ((epidx != hw->my_epid) && 196 (hw->ep_shm_info[epidx].es_status == 197 FJES_ZONING_STATUS_ENABLE)) { 198 fjes_hw_raise_interrupt(hw, epidx, 199 REG_ICTL_MASK_INFO_UPDATE); 200 hw->ep_shm_info[epidx].ep_stats 201 .send_intr_zoneupdate += 1; 202 } 203 } 204 205 msleep(FJES_OPEN_ZONE_UPDATE_WAIT * hw->max_epid); 206 207 for (epidx = 0; epidx < (hw->max_epid); epidx++) { 208 if (epidx == hw->my_epid) 209 continue; 210 211 buf_pair = &hw->ep_shm_info[epidx]; 212 213 spin_lock_irqsave(&hw->rx_status_lock, flags); 214 fjes_hw_setup_epbuf(&buf_pair->tx, netdev->dev_addr, 215 netdev->mtu); 216 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 217 218 if (fjes_hw_epid_is_same_zone(hw, epidx)) { 219 mutex_lock(&hw->hw_info.lock); 220 result = 221 fjes_hw_register_buff_addr(hw, epidx, buf_pair); 222 mutex_unlock(&hw->hw_info.lock); 223 224 switch (result) { 225 case 0: 226 break; 227 case -ENOMSG: 228 case -EBUSY: 229 default: 230 adapter->force_reset = true; 231 return result; 232 } 233 234 hw->ep_shm_info[epidx].ep_stats 235 .com_regist_buf_exec += 1; 236 } 237 } 238 239 return 0; 240 } 241 242 static void fjes_rx_irq(struct fjes_adapter *adapter, int src_epid) 243 { 244 struct fjes_hw *hw = &adapter->hw; 245 246 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_RX_DATA, true); 247 248 adapter->unset_rx_last = true; 249 napi_schedule(&adapter->napi); 250 } 251 252 static void fjes_stop_req_irq(struct fjes_adapter *adapter, int src_epid) 253 { 254 struct fjes_hw *hw = &adapter->hw; 255 enum ep_partner_status status; 256 unsigned long flags; 257 258 set_bit(src_epid, &hw->hw_info.buffer_unshare_reserve_bit); 259 260 status = fjes_hw_get_partner_ep_status(hw, src_epid); 261 trace_fjes_stop_req_irq_pre(hw, src_epid, status); 262 switch (status) { 263 case EP_PARTNER_WAITING: 264 spin_lock_irqsave(&hw->rx_status_lock, flags); 265 hw->ep_shm_info[src_epid].tx.info->v1i.rx_status |= 266 FJES_RX_STOP_REQ_DONE; 267 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 268 clear_bit(src_epid, &hw->txrx_stop_req_bit); 269 fallthrough; 270 case EP_PARTNER_UNSHARE: 271 case EP_PARTNER_COMPLETE: 272 default: 273 set_bit(src_epid, &adapter->unshare_watch_bitmask); 274 if (!work_pending(&adapter->unshare_watch_task)) 275 queue_work(adapter->control_wq, 276 &adapter->unshare_watch_task); 277 break; 278 case EP_PARTNER_SHARED: 279 set_bit(src_epid, &hw->epstop_req_bit); 280 281 if (!work_pending(&hw->epstop_task)) 282 queue_work(adapter->control_wq, &hw->epstop_task); 283 break; 284 } 285 trace_fjes_stop_req_irq_post(hw, src_epid); 286 } 287 288 static void fjes_txrx_stop_req_irq(struct fjes_adapter *adapter, 289 int src_epid) 290 { 291 struct fjes_hw *hw = &adapter->hw; 292 enum ep_partner_status status; 293 unsigned long flags; 294 295 status = fjes_hw_get_partner_ep_status(hw, src_epid); 296 trace_fjes_txrx_stop_req_irq_pre(hw, src_epid, status); 297 switch (status) { 298 case EP_PARTNER_UNSHARE: 299 case EP_PARTNER_COMPLETE: 300 default: 301 break; 302 case EP_PARTNER_WAITING: 303 if (src_epid < hw->my_epid) { 304 spin_lock_irqsave(&hw->rx_status_lock, flags); 305 hw->ep_shm_info[src_epid].tx.info->v1i.rx_status |= 306 FJES_RX_STOP_REQ_DONE; 307 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 308 309 clear_bit(src_epid, &hw->txrx_stop_req_bit); 310 set_bit(src_epid, &adapter->unshare_watch_bitmask); 311 312 if (!work_pending(&adapter->unshare_watch_task)) 313 queue_work(adapter->control_wq, 314 &adapter->unshare_watch_task); 315 } 316 break; 317 case EP_PARTNER_SHARED: 318 if (hw->ep_shm_info[src_epid].rx.info->v1i.rx_status & 319 FJES_RX_STOP_REQ_REQUEST) { 320 set_bit(src_epid, &hw->epstop_req_bit); 321 if (!work_pending(&hw->epstop_task)) 322 queue_work(adapter->control_wq, 323 &hw->epstop_task); 324 } 325 break; 326 } 327 trace_fjes_txrx_stop_req_irq_post(hw, src_epid); 328 } 329 330 static void fjes_update_zone_irq(struct fjes_adapter *adapter, 331 int src_epid) 332 { 333 struct fjes_hw *hw = &adapter->hw; 334 335 if (!work_pending(&hw->update_zone_task)) 336 queue_work(adapter->control_wq, &hw->update_zone_task); 337 } 338 339 static irqreturn_t fjes_intr(int irq, void *data) 340 { 341 struct fjes_adapter *adapter = data; 342 struct fjes_hw *hw = &adapter->hw; 343 irqreturn_t ret; 344 u32 icr; 345 346 icr = fjes_hw_capture_interrupt_status(hw); 347 348 if (icr & REG_IS_MASK_IS_ASSERT) { 349 if (icr & REG_ICTL_MASK_RX_DATA) { 350 fjes_rx_irq(adapter, icr & REG_IS_MASK_EPID); 351 hw->ep_shm_info[icr & REG_IS_MASK_EPID].ep_stats 352 .recv_intr_rx += 1; 353 } 354 355 if (icr & REG_ICTL_MASK_DEV_STOP_REQ) { 356 fjes_stop_req_irq(adapter, icr & REG_IS_MASK_EPID); 357 hw->ep_shm_info[icr & REG_IS_MASK_EPID].ep_stats 358 .recv_intr_stop += 1; 359 } 360 361 if (icr & REG_ICTL_MASK_TXRX_STOP_REQ) { 362 fjes_txrx_stop_req_irq(adapter, icr & REG_IS_MASK_EPID); 363 hw->ep_shm_info[icr & REG_IS_MASK_EPID].ep_stats 364 .recv_intr_unshare += 1; 365 } 366 367 if (icr & REG_ICTL_MASK_TXRX_STOP_DONE) 368 fjes_hw_set_irqmask(hw, 369 REG_ICTL_MASK_TXRX_STOP_DONE, true); 370 371 if (icr & REG_ICTL_MASK_INFO_UPDATE) { 372 fjes_update_zone_irq(adapter, icr & REG_IS_MASK_EPID); 373 hw->ep_shm_info[icr & REG_IS_MASK_EPID].ep_stats 374 .recv_intr_zoneupdate += 1; 375 } 376 377 ret = IRQ_HANDLED; 378 } else { 379 ret = IRQ_NONE; 380 } 381 382 return ret; 383 } 384 385 static int fjes_request_irq(struct fjes_adapter *adapter) 386 { 387 struct net_device *netdev = adapter->netdev; 388 int result = -1; 389 390 adapter->interrupt_watch_enable = true; 391 if (!delayed_work_pending(&adapter->interrupt_watch_task)) { 392 queue_delayed_work(adapter->control_wq, 393 &adapter->interrupt_watch_task, 394 FJES_IRQ_WATCH_DELAY); 395 } 396 397 if (!adapter->irq_registered) { 398 result = request_irq(adapter->hw.hw_res.irq, fjes_intr, 399 IRQF_SHARED, netdev->name, adapter); 400 if (result) 401 adapter->irq_registered = false; 402 else 403 adapter->irq_registered = true; 404 } 405 406 return result; 407 } 408 409 static void fjes_free_irq(struct fjes_adapter *adapter) 410 { 411 struct fjes_hw *hw = &adapter->hw; 412 413 adapter->interrupt_watch_enable = false; 414 cancel_delayed_work_sync(&adapter->interrupt_watch_task); 415 416 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_ALL, true); 417 418 if (adapter->irq_registered) { 419 free_irq(adapter->hw.hw_res.irq, adapter); 420 adapter->irq_registered = false; 421 } 422 } 423 424 static void fjes_free_resources(struct fjes_adapter *adapter) 425 { 426 struct net_device *netdev = adapter->netdev; 427 struct fjes_device_command_param param; 428 struct ep_share_mem_info *buf_pair; 429 struct fjes_hw *hw = &adapter->hw; 430 bool reset_flag = false; 431 unsigned long flags; 432 int result; 433 int epidx; 434 435 for (epidx = 0; epidx < hw->max_epid; epidx++) { 436 if (epidx == hw->my_epid) 437 continue; 438 439 mutex_lock(&hw->hw_info.lock); 440 result = fjes_hw_unregister_buff_addr(hw, epidx); 441 mutex_unlock(&hw->hw_info.lock); 442 443 hw->ep_shm_info[epidx].ep_stats.com_unregist_buf_exec += 1; 444 445 if (result) 446 reset_flag = true; 447 448 buf_pair = &hw->ep_shm_info[epidx]; 449 450 spin_lock_irqsave(&hw->rx_status_lock, flags); 451 fjes_hw_setup_epbuf(&buf_pair->tx, 452 netdev->dev_addr, netdev->mtu); 453 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 454 455 clear_bit(epidx, &hw->txrx_stop_req_bit); 456 } 457 458 if (reset_flag || adapter->force_reset) { 459 result = fjes_hw_reset(hw); 460 461 adapter->force_reset = false; 462 463 if (result) 464 adapter->open_guard = true; 465 466 hw->hw_info.buffer_share_bit = 0; 467 468 memset((void *)¶m, 0, sizeof(param)); 469 470 param.req_len = hw->hw_info.req_buf_size; 471 param.req_start = __pa(hw->hw_info.req_buf); 472 param.res_len = hw->hw_info.res_buf_size; 473 param.res_start = __pa(hw->hw_info.res_buf); 474 param.share_start = __pa(hw->hw_info.share->ep_status); 475 476 fjes_hw_init_command_registers(hw, ¶m); 477 } 478 } 479 480 /* fjes_open - Called when a network interface is made active */ 481 static int fjes_open(struct net_device *netdev) 482 { 483 struct fjes_adapter *adapter = netdev_priv(netdev); 484 struct fjes_hw *hw = &adapter->hw; 485 int result; 486 487 if (adapter->open_guard) 488 return -ENXIO; 489 490 result = fjes_setup_resources(adapter); 491 if (result) 492 goto err_setup_res; 493 494 hw->txrx_stop_req_bit = 0; 495 hw->epstop_req_bit = 0; 496 497 napi_enable(&adapter->napi); 498 499 fjes_hw_capture_interrupt_status(hw); 500 501 result = fjes_request_irq(adapter); 502 if (result) 503 goto err_req_irq; 504 505 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_ALL, false); 506 507 netif_tx_start_all_queues(netdev); 508 netif_carrier_on(netdev); 509 510 return 0; 511 512 err_req_irq: 513 fjes_free_irq(adapter); 514 napi_disable(&adapter->napi); 515 516 err_setup_res: 517 fjes_free_resources(adapter); 518 return result; 519 } 520 521 /* fjes_close - Disables a network interface */ 522 static int fjes_close(struct net_device *netdev) 523 { 524 struct fjes_adapter *adapter = netdev_priv(netdev); 525 struct fjes_hw *hw = &adapter->hw; 526 unsigned long flags; 527 int epidx; 528 529 netif_tx_stop_all_queues(netdev); 530 netif_carrier_off(netdev); 531 532 fjes_hw_raise_epstop(hw); 533 534 napi_disable(&adapter->napi); 535 536 spin_lock_irqsave(&hw->rx_status_lock, flags); 537 for (epidx = 0; epidx < hw->max_epid; epidx++) { 538 if (epidx == hw->my_epid) 539 continue; 540 541 if (fjes_hw_get_partner_ep_status(hw, epidx) == 542 EP_PARTNER_SHARED) 543 adapter->hw.ep_shm_info[epidx] 544 .tx.info->v1i.rx_status &= 545 ~FJES_RX_POLL_WORK; 546 } 547 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 548 549 fjes_free_irq(adapter); 550 551 cancel_delayed_work_sync(&adapter->interrupt_watch_task); 552 cancel_work_sync(&adapter->unshare_watch_task); 553 adapter->unshare_watch_bitmask = 0; 554 cancel_work_sync(&adapter->raise_intr_rxdata_task); 555 cancel_work_sync(&adapter->tx_stall_task); 556 557 cancel_work_sync(&hw->update_zone_task); 558 cancel_work_sync(&hw->epstop_task); 559 560 fjes_hw_wait_epstop(hw); 561 562 fjes_free_resources(adapter); 563 564 return 0; 565 } 566 567 static int fjes_tx_send(struct fjes_adapter *adapter, int dest, 568 void *data, size_t len) 569 { 570 int retval; 571 572 retval = fjes_hw_epbuf_tx_pkt_send(&adapter->hw.ep_shm_info[dest].tx, 573 data, len); 574 if (retval) 575 return retval; 576 577 adapter->hw.ep_shm_info[dest].tx.info->v1i.tx_status = 578 FJES_TX_DELAY_SEND_PENDING; 579 if (!work_pending(&adapter->raise_intr_rxdata_task)) 580 queue_work(adapter->txrx_wq, 581 &adapter->raise_intr_rxdata_task); 582 583 retval = 0; 584 return retval; 585 } 586 587 static netdev_tx_t 588 fjes_xmit_frame(struct sk_buff *skb, struct net_device *netdev) 589 { 590 struct fjes_adapter *adapter = netdev_priv(netdev); 591 struct fjes_hw *hw = &adapter->hw; 592 593 int max_epid, my_epid, dest_epid; 594 enum ep_partner_status pstatus; 595 struct netdev_queue *cur_queue; 596 char shortpkt[VLAN_ETH_HLEN]; 597 bool is_multi, vlan; 598 struct ethhdr *eth; 599 u16 queue_no = 0; 600 u16 vlan_id = 0; 601 netdev_tx_t ret; 602 char *data; 603 int len; 604 605 ret = NETDEV_TX_OK; 606 is_multi = false; 607 cur_queue = netdev_get_tx_queue(netdev, queue_no); 608 609 eth = (struct ethhdr *)skb->data; 610 my_epid = hw->my_epid; 611 612 vlan = (vlan_get_tag(skb, &vlan_id) == 0) ? true : false; 613 614 data = skb->data; 615 len = skb->len; 616 617 if (is_multicast_ether_addr(eth->h_dest)) { 618 dest_epid = 0; 619 max_epid = hw->max_epid; 620 is_multi = true; 621 } else if (is_local_ether_addr(eth->h_dest)) { 622 dest_epid = eth->h_dest[ETH_ALEN - 1]; 623 max_epid = dest_epid + 1; 624 625 if ((eth->h_dest[0] == 0x02) && 626 (0x00 == (eth->h_dest[1] | eth->h_dest[2] | 627 eth->h_dest[3] | eth->h_dest[4])) && 628 (dest_epid < hw->max_epid)) { 629 ; 630 } else { 631 dest_epid = 0; 632 max_epid = 0; 633 ret = NETDEV_TX_OK; 634 635 adapter->stats64.tx_packets += 1; 636 hw->ep_shm_info[my_epid].net_stats.tx_packets += 1; 637 adapter->stats64.tx_bytes += len; 638 hw->ep_shm_info[my_epid].net_stats.tx_bytes += len; 639 } 640 } else { 641 dest_epid = 0; 642 max_epid = 0; 643 ret = NETDEV_TX_OK; 644 645 adapter->stats64.tx_packets += 1; 646 hw->ep_shm_info[my_epid].net_stats.tx_packets += 1; 647 adapter->stats64.tx_bytes += len; 648 hw->ep_shm_info[my_epid].net_stats.tx_bytes += len; 649 } 650 651 for (; dest_epid < max_epid; dest_epid++) { 652 if (my_epid == dest_epid) 653 continue; 654 655 pstatus = fjes_hw_get_partner_ep_status(hw, dest_epid); 656 if (pstatus != EP_PARTNER_SHARED) { 657 if (!is_multi) 658 hw->ep_shm_info[dest_epid].ep_stats 659 .tx_dropped_not_shared += 1; 660 ret = NETDEV_TX_OK; 661 } else if (!fjes_hw_check_epbuf_version( 662 &adapter->hw.ep_shm_info[dest_epid].rx, 0)) { 663 /* version is NOT 0 */ 664 adapter->stats64.tx_carrier_errors += 1; 665 hw->ep_shm_info[dest_epid].net_stats 666 .tx_carrier_errors += 1; 667 hw->ep_shm_info[dest_epid].ep_stats 668 .tx_dropped_ver_mismatch += 1; 669 670 ret = NETDEV_TX_OK; 671 } else if (!fjes_hw_check_mtu( 672 &adapter->hw.ep_shm_info[dest_epid].rx, 673 netdev->mtu)) { 674 adapter->stats64.tx_dropped += 1; 675 hw->ep_shm_info[dest_epid].net_stats.tx_dropped += 1; 676 adapter->stats64.tx_errors += 1; 677 hw->ep_shm_info[dest_epid].net_stats.tx_errors += 1; 678 hw->ep_shm_info[dest_epid].ep_stats 679 .tx_dropped_buf_size_mismatch += 1; 680 681 ret = NETDEV_TX_OK; 682 } else if (vlan && 683 !fjes_hw_check_vlan_id( 684 &adapter->hw.ep_shm_info[dest_epid].rx, 685 vlan_id)) { 686 hw->ep_shm_info[dest_epid].ep_stats 687 .tx_dropped_vlanid_mismatch += 1; 688 ret = NETDEV_TX_OK; 689 } else { 690 if (len < VLAN_ETH_HLEN) { 691 memset(shortpkt, 0, VLAN_ETH_HLEN); 692 memcpy(shortpkt, skb->data, skb->len); 693 len = VLAN_ETH_HLEN; 694 data = shortpkt; 695 } 696 697 if (adapter->tx_retry_count == 0) { 698 adapter->tx_start_jiffies = jiffies; 699 adapter->tx_retry_count = 1; 700 } else { 701 adapter->tx_retry_count++; 702 } 703 704 if (fjes_tx_send(adapter, dest_epid, data, len)) { 705 if (is_multi) { 706 ret = NETDEV_TX_OK; 707 } else if ( 708 ((long)jiffies - 709 (long)adapter->tx_start_jiffies) >= 710 FJES_TX_RETRY_TIMEOUT) { 711 adapter->stats64.tx_fifo_errors += 1; 712 hw->ep_shm_info[dest_epid].net_stats 713 .tx_fifo_errors += 1; 714 adapter->stats64.tx_errors += 1; 715 hw->ep_shm_info[dest_epid].net_stats 716 .tx_errors += 1; 717 718 ret = NETDEV_TX_OK; 719 } else { 720 netif_trans_update(netdev); 721 hw->ep_shm_info[dest_epid].ep_stats 722 .tx_buffer_full += 1; 723 netif_tx_stop_queue(cur_queue); 724 725 if (!work_pending(&adapter->tx_stall_task)) 726 queue_work(adapter->txrx_wq, 727 &adapter->tx_stall_task); 728 729 ret = NETDEV_TX_BUSY; 730 } 731 } else { 732 if (!is_multi) { 733 adapter->stats64.tx_packets += 1; 734 hw->ep_shm_info[dest_epid].net_stats 735 .tx_packets += 1; 736 adapter->stats64.tx_bytes += len; 737 hw->ep_shm_info[dest_epid].net_stats 738 .tx_bytes += len; 739 } 740 741 adapter->tx_retry_count = 0; 742 ret = NETDEV_TX_OK; 743 } 744 } 745 } 746 747 if (ret == NETDEV_TX_OK) { 748 dev_kfree_skb(skb); 749 if (is_multi) { 750 adapter->stats64.tx_packets += 1; 751 hw->ep_shm_info[my_epid].net_stats.tx_packets += 1; 752 adapter->stats64.tx_bytes += 1; 753 hw->ep_shm_info[my_epid].net_stats.tx_bytes += len; 754 } 755 } 756 757 return ret; 758 } 759 760 static void 761 fjes_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) 762 { 763 struct fjes_adapter *adapter = netdev_priv(netdev); 764 765 memcpy(stats, &adapter->stats64, sizeof(struct rtnl_link_stats64)); 766 } 767 768 static int fjes_change_mtu(struct net_device *netdev, int new_mtu) 769 { 770 struct fjes_adapter *adapter = netdev_priv(netdev); 771 bool running = netif_running(netdev); 772 struct fjes_hw *hw = &adapter->hw; 773 unsigned long flags; 774 int ret = -EINVAL; 775 int idx, epidx; 776 777 for (idx = 0; fjes_support_mtu[idx] != 0; idx++) { 778 if (new_mtu <= fjes_support_mtu[idx]) { 779 new_mtu = fjes_support_mtu[idx]; 780 if (new_mtu == netdev->mtu) 781 return 0; 782 783 ret = 0; 784 break; 785 } 786 } 787 788 if (ret) 789 return ret; 790 791 if (running) { 792 spin_lock_irqsave(&hw->rx_status_lock, flags); 793 for (epidx = 0; epidx < hw->max_epid; epidx++) { 794 if (epidx == hw->my_epid) 795 continue; 796 hw->ep_shm_info[epidx].tx.info->v1i.rx_status &= 797 ~FJES_RX_MTU_CHANGING_DONE; 798 } 799 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 800 801 netif_tx_stop_all_queues(netdev); 802 netif_carrier_off(netdev); 803 cancel_work_sync(&adapter->tx_stall_task); 804 napi_disable(&adapter->napi); 805 806 msleep(1000); 807 808 netif_tx_stop_all_queues(netdev); 809 } 810 811 WRITE_ONCE(netdev->mtu, new_mtu); 812 813 if (running) { 814 for (epidx = 0; epidx < hw->max_epid; epidx++) { 815 if (epidx == hw->my_epid) 816 continue; 817 818 spin_lock_irqsave(&hw->rx_status_lock, flags); 819 fjes_hw_setup_epbuf(&hw->ep_shm_info[epidx].tx, 820 netdev->dev_addr, 821 netdev->mtu); 822 823 hw->ep_shm_info[epidx].tx.info->v1i.rx_status |= 824 FJES_RX_MTU_CHANGING_DONE; 825 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 826 } 827 828 netif_tx_wake_all_queues(netdev); 829 netif_carrier_on(netdev); 830 napi_enable(&adapter->napi); 831 napi_schedule(&adapter->napi); 832 } 833 834 return ret; 835 } 836 837 static void fjes_tx_retry(struct net_device *netdev, unsigned int txqueue) 838 { 839 struct netdev_queue *queue = netdev_get_tx_queue(netdev, 0); 840 841 netif_tx_wake_queue(queue); 842 } 843 844 static int fjes_vlan_rx_add_vid(struct net_device *netdev, 845 __be16 proto, u16 vid) 846 { 847 struct fjes_adapter *adapter = netdev_priv(netdev); 848 bool ret = true; 849 int epid; 850 851 for (epid = 0; epid < adapter->hw.max_epid; epid++) { 852 if (epid == adapter->hw.my_epid) 853 continue; 854 855 if (!fjes_hw_check_vlan_id( 856 &adapter->hw.ep_shm_info[epid].tx, vid)) 857 ret = fjes_hw_set_vlan_id( 858 &adapter->hw.ep_shm_info[epid].tx, vid); 859 } 860 861 return ret ? 0 : -ENOSPC; 862 } 863 864 static int fjes_vlan_rx_kill_vid(struct net_device *netdev, 865 __be16 proto, u16 vid) 866 { 867 struct fjes_adapter *adapter = netdev_priv(netdev); 868 int epid; 869 870 for (epid = 0; epid < adapter->hw.max_epid; epid++) { 871 if (epid == adapter->hw.my_epid) 872 continue; 873 874 fjes_hw_del_vlan_id(&adapter->hw.ep_shm_info[epid].tx, vid); 875 } 876 877 return 0; 878 } 879 880 static const struct net_device_ops fjes_netdev_ops = { 881 .ndo_open = fjes_open, 882 .ndo_stop = fjes_close, 883 .ndo_start_xmit = fjes_xmit_frame, 884 .ndo_get_stats64 = fjes_get_stats64, 885 .ndo_change_mtu = fjes_change_mtu, 886 .ndo_tx_timeout = fjes_tx_retry, 887 .ndo_vlan_rx_add_vid = fjes_vlan_rx_add_vid, 888 .ndo_vlan_rx_kill_vid = fjes_vlan_rx_kill_vid, 889 }; 890 891 /* fjes_netdev_setup - netdevice initialization routine */ 892 static void fjes_netdev_setup(struct net_device *netdev) 893 { 894 ether_setup(netdev); 895 896 netdev->watchdog_timeo = FJES_TX_RETRY_INTERVAL; 897 netdev->netdev_ops = &fjes_netdev_ops; 898 fjes_set_ethtool_ops(netdev); 899 netdev->mtu = fjes_support_mtu[3]; 900 netdev->min_mtu = fjes_support_mtu[0]; 901 netdev->max_mtu = fjes_support_mtu[3]; 902 netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER; 903 } 904 905 static int fjes_rxframe_search_exist(struct fjes_adapter *adapter, 906 int start_epid) 907 { 908 struct fjes_hw *hw = &adapter->hw; 909 enum ep_partner_status pstatus; 910 int max_epid, cur_epid; 911 int i; 912 913 max_epid = hw->max_epid; 914 start_epid = (start_epid + 1 + max_epid) % max_epid; 915 916 for (i = 0; i < max_epid; i++) { 917 cur_epid = (start_epid + i) % max_epid; 918 if (cur_epid == hw->my_epid) 919 continue; 920 921 pstatus = fjes_hw_get_partner_ep_status(hw, cur_epid); 922 if (pstatus == EP_PARTNER_SHARED) { 923 if (!fjes_hw_epbuf_rx_is_empty( 924 &hw->ep_shm_info[cur_epid].rx)) 925 return cur_epid; 926 } 927 } 928 return -1; 929 } 930 931 static void *fjes_rxframe_get(struct fjes_adapter *adapter, size_t *psize, 932 int *cur_epid) 933 { 934 void *frame; 935 936 *cur_epid = fjes_rxframe_search_exist(adapter, *cur_epid); 937 if (*cur_epid < 0) 938 return NULL; 939 940 frame = 941 fjes_hw_epbuf_rx_curpkt_get_addr( 942 &adapter->hw.ep_shm_info[*cur_epid].rx, psize); 943 944 return frame; 945 } 946 947 static void fjes_rxframe_release(struct fjes_adapter *adapter, int cur_epid) 948 { 949 fjes_hw_epbuf_rx_curpkt_drop(&adapter->hw.ep_shm_info[cur_epid].rx); 950 } 951 952 static int fjes_poll(struct napi_struct *napi, int budget) 953 { 954 struct fjes_adapter *adapter = 955 container_of(napi, struct fjes_adapter, napi); 956 struct net_device *netdev = napi->dev; 957 struct fjes_hw *hw = &adapter->hw; 958 struct sk_buff *skb; 959 int work_done = 0; 960 int cur_epid = 0; 961 int epidx; 962 size_t frame_len; 963 void *frame; 964 965 spin_lock(&hw->rx_status_lock); 966 for (epidx = 0; epidx < hw->max_epid; epidx++) { 967 if (epidx == hw->my_epid) 968 continue; 969 970 if (fjes_hw_get_partner_ep_status(hw, epidx) == 971 EP_PARTNER_SHARED) 972 adapter->hw.ep_shm_info[epidx] 973 .tx.info->v1i.rx_status |= FJES_RX_POLL_WORK; 974 } 975 spin_unlock(&hw->rx_status_lock); 976 977 while (work_done < budget) { 978 prefetch(&adapter->hw); 979 frame = fjes_rxframe_get(adapter, &frame_len, &cur_epid); 980 981 if (frame) { 982 skb = napi_alloc_skb(napi, frame_len); 983 if (!skb) { 984 adapter->stats64.rx_dropped += 1; 985 hw->ep_shm_info[cur_epid].net_stats 986 .rx_dropped += 1; 987 adapter->stats64.rx_errors += 1; 988 hw->ep_shm_info[cur_epid].net_stats 989 .rx_errors += 1; 990 } else { 991 skb_put_data(skb, frame, frame_len); 992 skb->protocol = eth_type_trans(skb, netdev); 993 skb->ip_summed = CHECKSUM_UNNECESSARY; 994 995 netif_receive_skb(skb); 996 997 work_done++; 998 999 adapter->stats64.rx_packets += 1; 1000 hw->ep_shm_info[cur_epid].net_stats 1001 .rx_packets += 1; 1002 adapter->stats64.rx_bytes += frame_len; 1003 hw->ep_shm_info[cur_epid].net_stats 1004 .rx_bytes += frame_len; 1005 1006 if (is_multicast_ether_addr( 1007 ((struct ethhdr *)frame)->h_dest)) { 1008 adapter->stats64.multicast += 1; 1009 hw->ep_shm_info[cur_epid].net_stats 1010 .multicast += 1; 1011 } 1012 } 1013 1014 fjes_rxframe_release(adapter, cur_epid); 1015 adapter->unset_rx_last = true; 1016 } else { 1017 break; 1018 } 1019 } 1020 1021 if (work_done < budget) { 1022 napi_complete_done(napi, work_done); 1023 1024 if (adapter->unset_rx_last) { 1025 adapter->rx_last_jiffies = jiffies; 1026 adapter->unset_rx_last = false; 1027 } 1028 1029 if (((long)jiffies - (long)adapter->rx_last_jiffies) < 3) { 1030 napi_schedule(napi); 1031 } else { 1032 spin_lock(&hw->rx_status_lock); 1033 for (epidx = 0; epidx < hw->max_epid; epidx++) { 1034 if (epidx == hw->my_epid) 1035 continue; 1036 if (fjes_hw_get_partner_ep_status(hw, epidx) == 1037 EP_PARTNER_SHARED) 1038 adapter->hw.ep_shm_info[epidx].tx 1039 .info->v1i.rx_status &= 1040 ~FJES_RX_POLL_WORK; 1041 } 1042 spin_unlock(&hw->rx_status_lock); 1043 1044 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_RX_DATA, false); 1045 } 1046 } 1047 1048 return work_done; 1049 } 1050 1051 static int fjes_sw_init(struct fjes_adapter *adapter) 1052 { 1053 struct net_device *netdev = adapter->netdev; 1054 1055 netif_napi_add(netdev, &adapter->napi, fjes_poll); 1056 1057 return 0; 1058 } 1059 1060 static void fjes_force_close_task(struct work_struct *work) 1061 { 1062 struct fjes_adapter *adapter = container_of(work, 1063 struct fjes_adapter, force_close_task); 1064 struct net_device *netdev = adapter->netdev; 1065 1066 rtnl_lock(); 1067 dev_close(netdev); 1068 rtnl_unlock(); 1069 } 1070 1071 static void fjes_tx_stall_task(struct work_struct *work) 1072 { 1073 struct fjes_adapter *adapter = container_of(work, 1074 struct fjes_adapter, tx_stall_task); 1075 struct net_device *netdev = adapter->netdev; 1076 struct fjes_hw *hw = &adapter->hw; 1077 int all_queue_available, sendable; 1078 enum ep_partner_status pstatus; 1079 int max_epid, my_epid, epid; 1080 union ep_buffer_info *info; 1081 int i; 1082 1083 if (((long)jiffies - 1084 dev_trans_start(netdev)) > FJES_TX_TX_STALL_TIMEOUT) { 1085 netif_wake_queue(netdev); 1086 return; 1087 } 1088 1089 my_epid = hw->my_epid; 1090 max_epid = hw->max_epid; 1091 1092 for (i = 0; i < 5; i++) { 1093 all_queue_available = 1; 1094 1095 for (epid = 0; epid < max_epid; epid++) { 1096 if (my_epid == epid) 1097 continue; 1098 1099 pstatus = fjes_hw_get_partner_ep_status(hw, epid); 1100 sendable = (pstatus == EP_PARTNER_SHARED); 1101 if (!sendable) 1102 continue; 1103 1104 info = adapter->hw.ep_shm_info[epid].tx.info; 1105 1106 if (!(info->v1i.rx_status & FJES_RX_MTU_CHANGING_DONE)) 1107 return; 1108 1109 if (EP_RING_FULL(info->v1i.head, info->v1i.tail, 1110 info->v1i.count_max)) { 1111 all_queue_available = 0; 1112 break; 1113 } 1114 } 1115 1116 if (all_queue_available) { 1117 netif_wake_queue(netdev); 1118 return; 1119 } 1120 } 1121 1122 usleep_range(50, 100); 1123 1124 queue_work(adapter->txrx_wq, &adapter->tx_stall_task); 1125 } 1126 1127 static void fjes_raise_intr_rxdata_task(struct work_struct *work) 1128 { 1129 struct fjes_adapter *adapter = container_of(work, 1130 struct fjes_adapter, raise_intr_rxdata_task); 1131 struct fjes_hw *hw = &adapter->hw; 1132 enum ep_partner_status pstatus; 1133 int max_epid, my_epid, epid; 1134 1135 my_epid = hw->my_epid; 1136 max_epid = hw->max_epid; 1137 1138 for (epid = 0; epid < max_epid; epid++) 1139 hw->ep_shm_info[epid].tx_status_work = 0; 1140 1141 for (epid = 0; epid < max_epid; epid++) { 1142 if (epid == my_epid) 1143 continue; 1144 1145 pstatus = fjes_hw_get_partner_ep_status(hw, epid); 1146 if (pstatus == EP_PARTNER_SHARED) { 1147 hw->ep_shm_info[epid].tx_status_work = 1148 hw->ep_shm_info[epid].tx.info->v1i.tx_status; 1149 1150 if (hw->ep_shm_info[epid].tx_status_work == 1151 FJES_TX_DELAY_SEND_PENDING) { 1152 hw->ep_shm_info[epid].tx.info->v1i.tx_status = 1153 FJES_TX_DELAY_SEND_NONE; 1154 } 1155 } 1156 } 1157 1158 for (epid = 0; epid < max_epid; epid++) { 1159 if (epid == my_epid) 1160 continue; 1161 1162 pstatus = fjes_hw_get_partner_ep_status(hw, epid); 1163 if ((hw->ep_shm_info[epid].tx_status_work == 1164 FJES_TX_DELAY_SEND_PENDING) && 1165 (pstatus == EP_PARTNER_SHARED) && 1166 !(hw->ep_shm_info[epid].rx.info->v1i.rx_status & 1167 FJES_RX_POLL_WORK)) { 1168 fjes_hw_raise_interrupt(hw, epid, 1169 REG_ICTL_MASK_RX_DATA); 1170 hw->ep_shm_info[epid].ep_stats.send_intr_rx += 1; 1171 } 1172 } 1173 1174 usleep_range(500, 1000); 1175 } 1176 1177 static void fjes_watch_unshare_task(struct work_struct *work) 1178 { 1179 struct fjes_adapter *adapter = 1180 container_of(work, struct fjes_adapter, unshare_watch_task); 1181 1182 struct net_device *netdev = adapter->netdev; 1183 struct fjes_hw *hw = &adapter->hw; 1184 1185 int unshare_watch, unshare_reserve; 1186 int max_epid, my_epid, epidx; 1187 int stop_req, stop_req_done; 1188 ulong unshare_watch_bitmask; 1189 unsigned long flags; 1190 int wait_time = 0; 1191 int is_shared; 1192 int ret; 1193 1194 my_epid = hw->my_epid; 1195 max_epid = hw->max_epid; 1196 1197 unshare_watch_bitmask = adapter->unshare_watch_bitmask; 1198 adapter->unshare_watch_bitmask = 0; 1199 1200 while ((unshare_watch_bitmask || hw->txrx_stop_req_bit) && 1201 (wait_time < 3000)) { 1202 for (epidx = 0; epidx < max_epid; epidx++) { 1203 if (epidx == my_epid) 1204 continue; 1205 1206 is_shared = fjes_hw_epid_is_shared(hw->hw_info.share, 1207 epidx); 1208 1209 stop_req = test_bit(epidx, &hw->txrx_stop_req_bit); 1210 1211 stop_req_done = hw->ep_shm_info[epidx].rx.info->v1i.rx_status & 1212 FJES_RX_STOP_REQ_DONE; 1213 1214 unshare_watch = test_bit(epidx, &unshare_watch_bitmask); 1215 1216 unshare_reserve = test_bit(epidx, 1217 &hw->hw_info.buffer_unshare_reserve_bit); 1218 1219 if ((!stop_req || 1220 (is_shared && (!is_shared || !stop_req_done))) && 1221 (is_shared || !unshare_watch || !unshare_reserve)) 1222 continue; 1223 1224 mutex_lock(&hw->hw_info.lock); 1225 ret = fjes_hw_unregister_buff_addr(hw, epidx); 1226 switch (ret) { 1227 case 0: 1228 break; 1229 case -ENOMSG: 1230 case -EBUSY: 1231 default: 1232 if (!work_pending( 1233 &adapter->force_close_task)) { 1234 adapter->force_reset = true; 1235 schedule_work( 1236 &adapter->force_close_task); 1237 } 1238 break; 1239 } 1240 mutex_unlock(&hw->hw_info.lock); 1241 hw->ep_shm_info[epidx].ep_stats 1242 .com_unregist_buf_exec += 1; 1243 1244 spin_lock_irqsave(&hw->rx_status_lock, flags); 1245 fjes_hw_setup_epbuf(&hw->ep_shm_info[epidx].tx, 1246 netdev->dev_addr, netdev->mtu); 1247 spin_unlock_irqrestore(&hw->rx_status_lock, flags); 1248 1249 clear_bit(epidx, &hw->txrx_stop_req_bit); 1250 clear_bit(epidx, &unshare_watch_bitmask); 1251 clear_bit(epidx, 1252 &hw->hw_info.buffer_unshare_reserve_bit); 1253 } 1254 1255 msleep(100); 1256 wait_time += 100; 1257 } 1258 1259 if (hw->hw_info.buffer_unshare_reserve_bit) { 1260 for (epidx = 0; epidx < max_epid; epidx++) { 1261 if (epidx == my_epid) 1262 continue; 1263 1264 if (test_bit(epidx, 1265 &hw->hw_info.buffer_unshare_reserve_bit)) { 1266 mutex_lock(&hw->hw_info.lock); 1267 1268 ret = fjes_hw_unregister_buff_addr(hw, epidx); 1269 switch (ret) { 1270 case 0: 1271 break; 1272 case -ENOMSG: 1273 case -EBUSY: 1274 default: 1275 if (!work_pending( 1276 &adapter->force_close_task)) { 1277 adapter->force_reset = true; 1278 schedule_work( 1279 &adapter->force_close_task); 1280 } 1281 break; 1282 } 1283 mutex_unlock(&hw->hw_info.lock); 1284 1285 hw->ep_shm_info[epidx].ep_stats 1286 .com_unregist_buf_exec += 1; 1287 1288 spin_lock_irqsave(&hw->rx_status_lock, flags); 1289 fjes_hw_setup_epbuf( 1290 &hw->ep_shm_info[epidx].tx, 1291 netdev->dev_addr, netdev->mtu); 1292 spin_unlock_irqrestore(&hw->rx_status_lock, 1293 flags); 1294 1295 clear_bit(epidx, &hw->txrx_stop_req_bit); 1296 clear_bit(epidx, &unshare_watch_bitmask); 1297 clear_bit(epidx, &hw->hw_info.buffer_unshare_reserve_bit); 1298 } 1299 1300 if (test_bit(epidx, &unshare_watch_bitmask)) { 1301 spin_lock_irqsave(&hw->rx_status_lock, flags); 1302 hw->ep_shm_info[epidx].tx.info->v1i.rx_status &= 1303 ~FJES_RX_STOP_REQ_DONE; 1304 spin_unlock_irqrestore(&hw->rx_status_lock, 1305 flags); 1306 } 1307 } 1308 } 1309 } 1310 1311 static void fjes_irq_watch_task(struct work_struct *work) 1312 { 1313 struct fjes_adapter *adapter = container_of(to_delayed_work(work), 1314 struct fjes_adapter, interrupt_watch_task); 1315 1316 local_irq_disable(); 1317 fjes_intr(adapter->hw.hw_res.irq, adapter); 1318 local_irq_enable(); 1319 1320 if (fjes_rxframe_search_exist(adapter, 0) >= 0) 1321 napi_schedule(&adapter->napi); 1322 1323 if (adapter->interrupt_watch_enable) { 1324 if (!delayed_work_pending(&adapter->interrupt_watch_task)) 1325 queue_delayed_work(adapter->control_wq, 1326 &adapter->interrupt_watch_task, 1327 FJES_IRQ_WATCH_DELAY); 1328 } 1329 } 1330 1331 /* fjes_probe - Device Initialization Routine */ 1332 static int fjes_probe(struct platform_device *plat_dev) 1333 { 1334 struct fjes_adapter *adapter; 1335 struct net_device *netdev; 1336 struct resource *res; 1337 struct fjes_hw *hw; 1338 u8 addr[ETH_ALEN]; 1339 int err; 1340 1341 err = -ENOMEM; 1342 netdev = alloc_netdev_mq(sizeof(struct fjes_adapter), "es%d", 1343 NET_NAME_UNKNOWN, fjes_netdev_setup, 1344 FJES_MAX_QUEUES); 1345 1346 if (!netdev) 1347 goto err_out; 1348 1349 SET_NETDEV_DEV(netdev, &plat_dev->dev); 1350 1351 dev_set_drvdata(&plat_dev->dev, netdev); 1352 adapter = netdev_priv(netdev); 1353 adapter->netdev = netdev; 1354 adapter->plat_dev = plat_dev; 1355 hw = &adapter->hw; 1356 hw->back = adapter; 1357 1358 /* setup the private structure */ 1359 err = fjes_sw_init(adapter); 1360 if (err) 1361 goto err_free_netdev; 1362 1363 INIT_WORK(&adapter->force_close_task, fjes_force_close_task); 1364 adapter->force_reset = false; 1365 adapter->open_guard = false; 1366 1367 adapter->txrx_wq = alloc_workqueue(DRV_NAME "/txrx", WQ_MEM_RECLAIM, 0); 1368 if (unlikely(!adapter->txrx_wq)) { 1369 err = -ENOMEM; 1370 goto err_free_netdev; 1371 } 1372 1373 adapter->control_wq = alloc_workqueue(DRV_NAME "/control", 1374 WQ_MEM_RECLAIM, 0); 1375 if (unlikely(!adapter->control_wq)) { 1376 err = -ENOMEM; 1377 goto err_free_txrx_wq; 1378 } 1379 1380 INIT_WORK(&adapter->tx_stall_task, fjes_tx_stall_task); 1381 INIT_WORK(&adapter->raise_intr_rxdata_task, 1382 fjes_raise_intr_rxdata_task); 1383 INIT_WORK(&adapter->unshare_watch_task, fjes_watch_unshare_task); 1384 adapter->unshare_watch_bitmask = 0; 1385 1386 INIT_DELAYED_WORK(&adapter->interrupt_watch_task, fjes_irq_watch_task); 1387 adapter->interrupt_watch_enable = false; 1388 1389 res = platform_get_resource(plat_dev, IORESOURCE_MEM, 0); 1390 if (!res) { 1391 err = -EINVAL; 1392 goto err_free_control_wq; 1393 } 1394 hw->hw_res.start = res->start; 1395 hw->hw_res.size = resource_size(res); 1396 hw->hw_res.irq = platform_get_irq(plat_dev, 0); 1397 if (hw->hw_res.irq < 0) { 1398 err = hw->hw_res.irq; 1399 goto err_free_control_wq; 1400 } 1401 1402 err = fjes_hw_init(&adapter->hw); 1403 if (err) 1404 goto err_free_control_wq; 1405 1406 /* setup MAC address (02:00:00:00:00:[epid])*/ 1407 addr[0] = 2; 1408 addr[1] = 0; 1409 addr[2] = 0; 1410 addr[3] = 0; 1411 addr[4] = 0; 1412 addr[5] = hw->my_epid; /* EPID */ 1413 eth_hw_addr_set(netdev, addr); 1414 1415 err = register_netdev(netdev); 1416 if (err) 1417 goto err_hw_exit; 1418 1419 netif_carrier_off(netdev); 1420 1421 fjes_dbg_adapter_init(adapter); 1422 1423 return 0; 1424 1425 err_hw_exit: 1426 fjes_hw_exit(&adapter->hw); 1427 err_free_control_wq: 1428 destroy_workqueue(adapter->control_wq); 1429 err_free_txrx_wq: 1430 destroy_workqueue(adapter->txrx_wq); 1431 err_free_netdev: 1432 free_netdev(netdev); 1433 err_out: 1434 return err; 1435 } 1436 1437 /* fjes_remove - Device Removal Routine */ 1438 static void fjes_remove(struct platform_device *plat_dev) 1439 { 1440 struct net_device *netdev = dev_get_drvdata(&plat_dev->dev); 1441 struct fjes_adapter *adapter = netdev_priv(netdev); 1442 struct fjes_hw *hw = &adapter->hw; 1443 1444 fjes_dbg_adapter_exit(adapter); 1445 1446 cancel_delayed_work_sync(&adapter->interrupt_watch_task); 1447 cancel_work_sync(&adapter->unshare_watch_task); 1448 cancel_work_sync(&adapter->raise_intr_rxdata_task); 1449 cancel_work_sync(&adapter->tx_stall_task); 1450 if (adapter->control_wq) 1451 destroy_workqueue(adapter->control_wq); 1452 if (adapter->txrx_wq) 1453 destroy_workqueue(adapter->txrx_wq); 1454 1455 unregister_netdev(netdev); 1456 1457 fjes_hw_exit(hw); 1458 1459 netif_napi_del(&adapter->napi); 1460 1461 free_netdev(netdev); 1462 } 1463 1464 static struct platform_driver fjes_driver = { 1465 .driver = { 1466 .name = DRV_NAME, 1467 }, 1468 .probe = fjes_probe, 1469 .remove = fjes_remove, 1470 }; 1471 1472 static acpi_status 1473 acpi_find_extended_socket_device(acpi_handle obj_handle, u32 level, 1474 void *context, void **return_value) 1475 { 1476 struct acpi_device *device; 1477 bool *found = context; 1478 1479 device = acpi_fetch_acpi_dev(obj_handle); 1480 if (!device) 1481 return AE_OK; 1482 1483 if (strcmp(acpi_device_hid(device), ACPI_MOTHERBOARD_RESOURCE_HID)) 1484 return AE_OK; 1485 1486 if (!is_extended_socket_device(device)) 1487 return AE_OK; 1488 1489 if (acpi_check_extended_socket_status(device)) 1490 return AE_OK; 1491 1492 *found = true; 1493 return AE_CTRL_TERMINATE; 1494 } 1495 1496 /* fjes_init_module - Driver Registration Routine */ 1497 static int __init fjes_init_module(void) 1498 { 1499 bool found = false; 1500 int result; 1501 1502 acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, 1503 acpi_find_extended_socket_device, NULL, &found, 1504 NULL); 1505 1506 if (!found) 1507 return -ENODEV; 1508 1509 pr_info("%s - version %s - %s\n", 1510 fjes_driver_string, fjes_driver_version, fjes_copyright); 1511 1512 fjes_dbg_init(); 1513 1514 result = platform_driver_register(&fjes_driver); 1515 if (result < 0) { 1516 fjes_dbg_exit(); 1517 return result; 1518 } 1519 1520 result = acpi_bus_register_driver(&fjes_acpi_driver); 1521 if (result < 0) 1522 goto fail_acpi_driver; 1523 1524 return 0; 1525 1526 fail_acpi_driver: 1527 platform_driver_unregister(&fjes_driver); 1528 fjes_dbg_exit(); 1529 return result; 1530 } 1531 1532 module_init(fjes_init_module); 1533 1534 /* fjes_exit_module - Driver Exit Cleanup Routine */ 1535 static void __exit fjes_exit_module(void) 1536 { 1537 acpi_bus_unregister_driver(&fjes_acpi_driver); 1538 platform_driver_unregister(&fjes_driver); 1539 fjes_dbg_exit(); 1540 } 1541 1542 module_exit(fjes_exit_module); 1543