fjes_main.c

   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"
  19char fjes_driver_name[] = DRV_NAME;
  20char fjes_driver_version[] = DRV_VERSION;
  21static const char fjes_driver_string[] =
  22		"FUJITSU Extended Socket Network Device Driver";
  23static const char fjes_copyright[] =
  24		"Copyright (c) 2015 FUJITSU LIMITED";
  25
  26MODULE_AUTHOR("Taku Izumi <izumi.taku@jp.fujitsu.com>");
  27MODULE_DESCRIPTION("FUJITSU Extended Socket Network Device Driver");
  28MODULE_LICENSE("GPL");
  29MODULE_VERSION(DRV_VERSION);
  30
  31#define ACPI_MOTHERBOARD_RESOURCE_HID "PNP0C02"
  32
  33static const struct acpi_device_id fjes_acpi_ids[] = {
  34	{ACPI_MOTHERBOARD_RESOURCE_HID, 0},
  35	{"", 0},
  36};
  37MODULE_DEVICE_TABLE(acpi, fjes_acpi_ids);
  38
  39static 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
  66static 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
  84static acpi_status
  85fjes_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
 114static struct resource fjes_resource[] = {
 115	DEFINE_RES_MEM(0, 1),
 116	DEFINE_RES_IRQ(0)
 117};
 118
 119static 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
 146static 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
 154static 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
 164static 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
 242static 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
 252static 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
 288static 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
 330static 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
 339static 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
 385static 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
 409static 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
 424static 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 *)&param, 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, &param);
 477	}
 478}
 479
 480/* fjes_open - Called when a network interface is made active */
 481static 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
 512err_req_irq:
 513	fjes_free_irq(adapter);
 514	napi_disable(&adapter->napi);
 515
 516err_setup_res:
 517	fjes_free_resources(adapter);
 518	return result;
 519}
 520
 521/* fjes_close - Disables a network interface */
 522static 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
 567static 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
 587static netdev_tx_t
 588fjes_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
 760static void
 761fjes_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
 768static 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
 837static 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
 844static 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
 864static 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
 880static 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 */
 892static 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
 905static 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
 931static 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
 947static 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
 952static 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
1051static 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
1060static 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
1071static 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
1127static 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
1177static 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
1311static 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 */
1332static 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",
1368					   WQ_MEM_RECLAIM | WQ_PERCPU, 0);
1369	if (unlikely(!adapter->txrx_wq)) {
1370		err = -ENOMEM;
1371		goto err_free_netdev;
1372	}
1373
1374	adapter->control_wq = alloc_workqueue(DRV_NAME "/control",
1375					      WQ_MEM_RECLAIM | WQ_PERCPU, 0);
1376	if (unlikely(!adapter->control_wq)) {
1377		err = -ENOMEM;
1378		goto err_free_txrx_wq;
1379	}
1380
1381	INIT_WORK(&adapter->tx_stall_task, fjes_tx_stall_task);
1382	INIT_WORK(&adapter->raise_intr_rxdata_task,
1383		  fjes_raise_intr_rxdata_task);
1384	INIT_WORK(&adapter->unshare_watch_task, fjes_watch_unshare_task);
1385	adapter->unshare_watch_bitmask = 0;
1386
1387	INIT_DELAYED_WORK(&adapter->interrupt_watch_task, fjes_irq_watch_task);
1388	adapter->interrupt_watch_enable = false;
1389
1390	res = platform_get_resource(plat_dev, IORESOURCE_MEM, 0);
1391	if (!res) {
1392		err = -EINVAL;
1393		goto err_free_control_wq;
1394	}
1395	hw->hw_res.start = res->start;
1396	hw->hw_res.size = resource_size(res);
1397	hw->hw_res.irq = platform_get_irq(plat_dev, 0);
1398	if (hw->hw_res.irq < 0) {
1399		err = hw->hw_res.irq;
1400		goto err_free_control_wq;
1401	}
1402
1403	err = fjes_hw_init(&adapter->hw);
1404	if (err)
1405		goto err_free_control_wq;
1406
1407	/* setup MAC address (02:00:00:00:00:[epid])*/
1408	addr[0] = 2;
1409	addr[1] = 0;
1410	addr[2] = 0;
1411	addr[3] = 0;
1412	addr[4] = 0;
1413	addr[5] = hw->my_epid; /* EPID */
1414	eth_hw_addr_set(netdev, addr);
1415
1416	err = register_netdev(netdev);
1417	if (err)
1418		goto err_hw_exit;
1419
1420	netif_carrier_off(netdev);
1421
1422	fjes_dbg_adapter_init(adapter);
1423
1424	return 0;
1425
1426err_hw_exit:
1427	fjes_hw_exit(&adapter->hw);
1428err_free_control_wq:
1429	destroy_workqueue(adapter->control_wq);
1430err_free_txrx_wq:
1431	destroy_workqueue(adapter->txrx_wq);
1432err_free_netdev:
1433	free_netdev(netdev);
1434err_out:
1435	return err;
1436}
1437
1438/* fjes_remove - Device Removal Routine */
1439static void fjes_remove(struct platform_device *plat_dev)
1440{
1441	struct net_device *netdev = dev_get_drvdata(&plat_dev->dev);
1442	struct fjes_adapter *adapter = netdev_priv(netdev);
1443	struct fjes_hw *hw = &adapter->hw;
1444
1445	fjes_dbg_adapter_exit(adapter);
1446
1447	cancel_delayed_work_sync(&adapter->interrupt_watch_task);
1448	cancel_work_sync(&adapter->unshare_watch_task);
1449	cancel_work_sync(&adapter->raise_intr_rxdata_task);
1450	cancel_work_sync(&adapter->tx_stall_task);
1451	if (adapter->control_wq)
1452		destroy_workqueue(adapter->control_wq);
1453	if (adapter->txrx_wq)
1454		destroy_workqueue(adapter->txrx_wq);
1455
1456	unregister_netdev(netdev);
1457
1458	fjes_hw_exit(hw);
1459
1460	netif_napi_del(&adapter->napi);
1461
1462	free_netdev(netdev);
1463}
1464
1465static struct platform_driver fjes_driver = {
1466	.driver = {
1467		.name = DRV_NAME,
1468	},
1469	.probe = fjes_probe,
1470	.remove = fjes_remove,
1471};
1472
1473static acpi_status
1474acpi_find_extended_socket_device(acpi_handle obj_handle, u32 level,
1475				 void *context, void **return_value)
1476{
1477	struct acpi_device *device;
1478	bool *found = context;
1479
1480	device = acpi_fetch_acpi_dev(obj_handle);
1481	if (!device)
1482		return AE_OK;
1483
1484	if (strcmp(acpi_device_hid(device), ACPI_MOTHERBOARD_RESOURCE_HID))
1485		return AE_OK;
1486
1487	if (!is_extended_socket_device(device))
1488		return AE_OK;
1489
1490	if (acpi_check_extended_socket_status(device))
1491		return AE_OK;
1492
1493	*found = true;
1494	return AE_CTRL_TERMINATE;
1495}
1496
1497/* fjes_init_module - Driver Registration Routine */
1498static int __init fjes_init_module(void)
1499{
1500	bool found = false;
1501	int result;
1502
1503	acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
1504			    acpi_find_extended_socket_device, NULL, &found,
1505			    NULL);
1506
1507	if (!found)
1508		return -ENODEV;
1509
1510	pr_info("%s - version %s - %s\n",
1511		fjes_driver_string, fjes_driver_version, fjes_copyright);
1512
1513	fjes_dbg_init();
1514
1515	result = platform_driver_register(&fjes_driver);
1516	if (result < 0) {
1517		fjes_dbg_exit();
1518		return result;
1519	}
1520
1521	result = acpi_bus_register_driver(&fjes_acpi_driver);
1522	if (result < 0)
1523		goto fail_acpi_driver;
1524
1525	return 0;
1526
1527fail_acpi_driver:
1528	platform_driver_unregister(&fjes_driver);
1529	fjes_dbg_exit();
1530	return result;
1531}
1532
1533module_init(fjes_init_module);
1534
1535/* fjes_exit_module - Driver Exit Cleanup Routine */
1536static void __exit fjes_exit_module(void)
1537{
1538	acpi_bus_unregister_driver(&fjes_acpi_driver);
1539	platform_driver_unregister(&fjes_driver);
1540	fjes_dbg_exit();
1541}
1542
1543module_exit(fjes_exit_module);