1 // SPDX-License-Identifier: GPL-2.0-only
3 * FUJITSU Extended Socket Network Device driver
4 * Copyright (c) 2015 FUJITSU LIMITED
9 #include "fjes_trace.h"
11 static void fjes_hw_update_zone_task(struct work_struct *);
12 static void fjes_hw_epstop_task(struct work_struct *);
14 /* supported MTU list */
15 const u32 fjes_support_mtu[] = {
16 FJES_MTU_DEFINE(8 * 1024),
17 FJES_MTU_DEFINE(16 * 1024),
18 FJES_MTU_DEFINE(32 * 1024),
19 FJES_MTU_DEFINE(64 * 1024),
23 u32 fjes_hw_rd32(struct fjes_hw *hw, u32 reg)
28 value = readl(&base[reg]);
33 static u8 *fjes_hw_iomap(struct fjes_hw *hw)
37 if (!request_mem_region(hw->hw_res.start, hw->hw_res.size,
39 pr_err("request_mem_region failed\n");
43 base = (u8 *)ioremap(hw->hw_res.start, hw->hw_res.size);
48 static void fjes_hw_iounmap(struct fjes_hw *hw)
51 release_mem_region(hw->hw_res.start, hw->hw_res.size);
54 int fjes_hw_reset(struct fjes_hw *hw)
61 wr32(XSCT_DCTL, dctl.reg);
63 timeout = FJES_DEVICE_RESET_TIMEOUT * 1000;
64 dctl.reg = rd32(XSCT_DCTL);
65 while ((dctl.bits.reset == 1) && (timeout > 0)) {
67 dctl.reg = rd32(XSCT_DCTL);
71 return timeout > 0 ? 0 : -EIO;
74 static int fjes_hw_get_max_epid(struct fjes_hw *hw)
76 union REG_MAX_EP info;
78 info.reg = rd32(XSCT_MAX_EP);
80 return info.bits.maxep;
83 static int fjes_hw_get_my_epid(struct fjes_hw *hw)
85 union REG_OWNER_EPID info;
87 info.reg = rd32(XSCT_OWNER_EPID);
89 return info.bits.epid;
92 static int fjes_hw_alloc_shared_status_region(struct fjes_hw *hw)
96 size = sizeof(struct fjes_device_shared_info) +
97 (sizeof(u8) * hw->max_epid);
98 hw->hw_info.share = kzalloc(size, GFP_KERNEL);
99 if (!hw->hw_info.share)
102 hw->hw_info.share->epnum = hw->max_epid;
107 static void fjes_hw_free_shared_status_region(struct fjes_hw *hw)
109 kfree(hw->hw_info.share);
110 hw->hw_info.share = NULL;
113 static int fjes_hw_alloc_epbuf(struct epbuf_handler *epbh)
117 mem = vzalloc(EP_BUFFER_SIZE);
122 epbh->size = EP_BUFFER_SIZE;
124 epbh->info = (union ep_buffer_info *)mem;
125 epbh->ring = (u8 *)(mem + sizeof(union ep_buffer_info));
130 static void fjes_hw_free_epbuf(struct epbuf_handler *epbh)
140 void fjes_hw_setup_epbuf(struct epbuf_handler *epbh, u8 *mac_addr, u32 mtu)
142 union ep_buffer_info *info = epbh->info;
143 u16 vlan_id[EP_BUFFER_SUPPORT_VLAN_MAX];
146 for (i = 0; i < EP_BUFFER_SUPPORT_VLAN_MAX; i++)
147 vlan_id[i] = info->v1i.vlan_id[i];
149 memset(info, 0, sizeof(union ep_buffer_info));
151 info->v1i.version = 0; /* version 0 */
153 for (i = 0; i < ETH_ALEN; i++)
154 info->v1i.mac_addr[i] = mac_addr[i];
159 info->v1i.info_size = sizeof(union ep_buffer_info);
160 info->v1i.buffer_size = epbh->size - info->v1i.info_size;
162 info->v1i.frame_max = FJES_MTU_TO_FRAME_SIZE(mtu);
163 info->v1i.count_max =
164 EP_RING_NUM(info->v1i.buffer_size, info->v1i.frame_max);
166 for (i = 0; i < EP_BUFFER_SUPPORT_VLAN_MAX; i++)
167 info->v1i.vlan_id[i] = vlan_id[i];
169 info->v1i.rx_status |= FJES_RX_MTU_CHANGING_DONE;
173 fjes_hw_init_command_registers(struct fjes_hw *hw,
174 struct fjes_device_command_param *param)
176 /* Request Buffer length */
177 wr32(XSCT_REQBL, (__le32)(param->req_len));
178 /* Response Buffer Length */
179 wr32(XSCT_RESPBL, (__le32)(param->res_len));
181 /* Request Buffer Address */
183 (__le32)(param->req_start & GENMASK_ULL(31, 0)));
185 (__le32)((param->req_start & GENMASK_ULL(63, 32)) >> 32));
187 /* Response Buffer Address */
189 (__le32)(param->res_start & GENMASK_ULL(31, 0)));
191 (__le32)((param->res_start & GENMASK_ULL(63, 32)) >> 32));
193 /* Share status address */
195 (__le32)(param->share_start & GENMASK_ULL(31, 0)));
197 (__le32)((param->share_start & GENMASK_ULL(63, 32)) >> 32));
200 static int fjes_hw_setup(struct fjes_hw *hw)
202 u8 mac[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
203 struct fjes_device_command_param param;
204 struct ep_share_mem_info *buf_pair;
211 hw->hw_info.max_epid = &hw->max_epid;
212 hw->hw_info.my_epid = &hw->my_epid;
214 buf = kcalloc(hw->max_epid, sizeof(struct ep_share_mem_info),
219 hw->ep_shm_info = (struct ep_share_mem_info *)buf;
221 mem_size = FJES_DEV_REQ_BUF_SIZE(hw->max_epid);
222 hw->hw_info.req_buf = kzalloc(mem_size, GFP_KERNEL);
223 if (!(hw->hw_info.req_buf)) {
228 hw->hw_info.req_buf_size = mem_size;
230 mem_size = FJES_DEV_RES_BUF_SIZE(hw->max_epid);
231 hw->hw_info.res_buf = kzalloc(mem_size, GFP_KERNEL);
232 if (!(hw->hw_info.res_buf)) {
237 hw->hw_info.res_buf_size = mem_size;
239 result = fjes_hw_alloc_shared_status_region(hw);
243 hw->hw_info.buffer_share_bit = 0;
244 hw->hw_info.buffer_unshare_reserve_bit = 0;
246 for (epidx = 0; epidx < hw->max_epid; epidx++) {
247 if (epidx != hw->my_epid) {
248 buf_pair = &hw->ep_shm_info[epidx];
250 result = fjes_hw_alloc_epbuf(&buf_pair->tx);
254 result = fjes_hw_alloc_epbuf(&buf_pair->rx);
258 spin_lock_irqsave(&hw->rx_status_lock, flags);
259 fjes_hw_setup_epbuf(&buf_pair->tx, mac,
260 fjes_support_mtu[0]);
261 fjes_hw_setup_epbuf(&buf_pair->rx, mac,
262 fjes_support_mtu[0]);
263 spin_unlock_irqrestore(&hw->rx_status_lock, flags);
267 memset(¶m, 0, sizeof(param));
269 param.req_len = hw->hw_info.req_buf_size;
270 param.req_start = __pa(hw->hw_info.req_buf);
271 param.res_len = hw->hw_info.res_buf_size;
272 param.res_start = __pa(hw->hw_info.res_buf);
274 param.share_start = __pa(hw->hw_info.share->ep_status);
276 fjes_hw_init_command_registers(hw, ¶m);
281 for (epidx = 0; epidx < hw->max_epid ; epidx++) {
282 if (epidx == hw->my_epid)
284 fjes_hw_free_epbuf(&hw->ep_shm_info[epidx].tx);
285 fjes_hw_free_epbuf(&hw->ep_shm_info[epidx].rx);
287 fjes_hw_free_shared_status_region(hw);
289 kfree(hw->hw_info.res_buf);
290 hw->hw_info.res_buf = NULL;
292 kfree(hw->hw_info.req_buf);
293 hw->hw_info.req_buf = NULL;
295 kfree(hw->ep_shm_info);
296 hw->ep_shm_info = NULL;
300 static void fjes_hw_cleanup(struct fjes_hw *hw)
304 if (!hw->ep_shm_info)
307 fjes_hw_free_shared_status_region(hw);
309 kfree(hw->hw_info.req_buf);
310 hw->hw_info.req_buf = NULL;
312 kfree(hw->hw_info.res_buf);
313 hw->hw_info.res_buf = NULL;
315 for (epidx = 0; epidx < hw->max_epid ; epidx++) {
316 if (epidx == hw->my_epid)
318 fjes_hw_free_epbuf(&hw->ep_shm_info[epidx].tx);
319 fjes_hw_free_epbuf(&hw->ep_shm_info[epidx].rx);
322 kfree(hw->ep_shm_info);
323 hw->ep_shm_info = NULL;
326 int fjes_hw_init(struct fjes_hw *hw)
330 hw->base = fjes_hw_iomap(hw);
334 ret = fjes_hw_reset(hw);
338 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_ALL, true);
340 INIT_WORK(&hw->update_zone_task, fjes_hw_update_zone_task);
341 INIT_WORK(&hw->epstop_task, fjes_hw_epstop_task);
343 mutex_init(&hw->hw_info.lock);
344 spin_lock_init(&hw->rx_status_lock);
346 hw->max_epid = fjes_hw_get_max_epid(hw);
347 hw->my_epid = fjes_hw_get_my_epid(hw);
349 if ((hw->max_epid == 0) || (hw->my_epid >= hw->max_epid))
352 ret = fjes_hw_setup(hw);
354 hw->hw_info.trace = vzalloc(FJES_DEBUG_BUFFER_SIZE);
355 hw->hw_info.trace_size = FJES_DEBUG_BUFFER_SIZE;
360 void fjes_hw_exit(struct fjes_hw *hw)
366 if (hw->debug_mode) {
367 /* disable debug mode */
368 mutex_lock(&hw->hw_info.lock);
369 fjes_hw_stop_debug(hw);
370 mutex_unlock(&hw->hw_info.lock);
372 vfree(hw->hw_info.trace);
373 hw->hw_info.trace = NULL;
374 hw->hw_info.trace_size = 0;
377 ret = fjes_hw_reset(hw);
379 pr_err("%s: reset error", __func__);
387 cancel_work_sync(&hw->update_zone_task);
388 cancel_work_sync(&hw->epstop_task);
391 static enum fjes_dev_command_response_e
392 fjes_hw_issue_request_command(struct fjes_hw *hw,
393 enum fjes_dev_command_request_type type)
395 enum fjes_dev_command_response_e ret = FJES_CMD_STATUS_UNKNOWN;
398 int timeout = FJES_COMMAND_REQ_TIMEOUT * 1000;
401 cr.bits.req_start = 1;
402 cr.bits.req_code = type;
403 wr32(XSCT_CR, cr.reg);
404 cr.reg = rd32(XSCT_CR);
406 if (cr.bits.error == 0) {
407 timeout = FJES_COMMAND_REQ_TIMEOUT * 1000;
408 cs.reg = rd32(XSCT_CS);
410 while ((cs.bits.complete != 1) && timeout > 0) {
412 cs.reg = rd32(XSCT_CS);
416 if (cs.bits.complete == 1)
417 ret = FJES_CMD_STATUS_NORMAL;
418 else if (timeout <= 0)
419 ret = FJES_CMD_STATUS_TIMEOUT;
422 switch (cr.bits.err_info) {
423 case FJES_CMD_REQ_ERR_INFO_PARAM:
424 ret = FJES_CMD_STATUS_ERROR_PARAM;
426 case FJES_CMD_REQ_ERR_INFO_STATUS:
427 ret = FJES_CMD_STATUS_ERROR_STATUS;
430 ret = FJES_CMD_STATUS_UNKNOWN;
435 trace_fjes_hw_issue_request_command(&cr, &cs, timeout, ret);
440 int fjes_hw_request_info(struct fjes_hw *hw)
442 union fjes_device_command_req *req_buf = hw->hw_info.req_buf;
443 union fjes_device_command_res *res_buf = hw->hw_info.res_buf;
444 enum fjes_dev_command_response_e ret;
447 memset(req_buf, 0, hw->hw_info.req_buf_size);
448 memset(res_buf, 0, hw->hw_info.res_buf_size);
450 req_buf->info.length = FJES_DEV_COMMAND_INFO_REQ_LEN;
452 res_buf->info.length = 0;
453 res_buf->info.code = 0;
455 ret = fjes_hw_issue_request_command(hw, FJES_CMD_REQ_INFO);
456 trace_fjes_hw_request_info(hw, res_buf);
460 if (FJES_DEV_COMMAND_INFO_RES_LEN((*hw->hw_info.max_epid)) !=
461 res_buf->info.length) {
462 trace_fjes_hw_request_info_err("Invalid res_buf");
464 } else if (ret == FJES_CMD_STATUS_NORMAL) {
465 switch (res_buf->info.code) {
466 case FJES_CMD_REQ_RES_CODE_NORMAL:
475 case FJES_CMD_STATUS_UNKNOWN:
478 case FJES_CMD_STATUS_TIMEOUT:
479 trace_fjes_hw_request_info_err("Timeout");
482 case FJES_CMD_STATUS_ERROR_PARAM:
485 case FJES_CMD_STATUS_ERROR_STATUS:
497 int fjes_hw_register_buff_addr(struct fjes_hw *hw, int dest_epid,
498 struct ep_share_mem_info *buf_pair)
500 union fjes_device_command_req *req_buf = hw->hw_info.req_buf;
501 union fjes_device_command_res *res_buf = hw->hw_info.res_buf;
502 enum fjes_dev_command_response_e ret;
509 if (test_bit(dest_epid, &hw->hw_info.buffer_share_bit))
512 memset(req_buf, 0, hw->hw_info.req_buf_size);
513 memset(res_buf, 0, hw->hw_info.res_buf_size);
515 req_buf->share_buffer.length = FJES_DEV_COMMAND_SHARE_BUFFER_REQ_LEN(
518 req_buf->share_buffer.epid = dest_epid;
521 req_buf->share_buffer.buffer[idx++] = buf_pair->tx.size;
522 page_count = buf_pair->tx.size / EP_BUFFER_INFO_SIZE;
523 for (i = 0; i < page_count; i++) {
524 addr = ((u8 *)(buf_pair->tx.buffer)) +
525 (i * EP_BUFFER_INFO_SIZE);
526 req_buf->share_buffer.buffer[idx++] =
527 (__le64)(page_to_phys(vmalloc_to_page(addr)) +
528 offset_in_page(addr));
531 req_buf->share_buffer.buffer[idx++] = buf_pair->rx.size;
532 page_count = buf_pair->rx.size / EP_BUFFER_INFO_SIZE;
533 for (i = 0; i < page_count; i++) {
534 addr = ((u8 *)(buf_pair->rx.buffer)) +
535 (i * EP_BUFFER_INFO_SIZE);
536 req_buf->share_buffer.buffer[idx++] =
537 (__le64)(page_to_phys(vmalloc_to_page(addr)) +
538 offset_in_page(addr));
541 res_buf->share_buffer.length = 0;
542 res_buf->share_buffer.code = 0;
544 trace_fjes_hw_register_buff_addr_req(req_buf, buf_pair);
546 ret = fjes_hw_issue_request_command(hw, FJES_CMD_REQ_SHARE_BUFFER);
548 timeout = FJES_COMMAND_REQ_BUFF_TIMEOUT * 1000;
549 while ((ret == FJES_CMD_STATUS_NORMAL) &&
550 (res_buf->share_buffer.length ==
551 FJES_DEV_COMMAND_SHARE_BUFFER_RES_LEN) &&
552 (res_buf->share_buffer.code == FJES_CMD_REQ_RES_CODE_BUSY) &&
554 msleep(200 + hw->my_epid * 20);
555 timeout -= (200 + hw->my_epid * 20);
557 res_buf->share_buffer.length = 0;
558 res_buf->share_buffer.code = 0;
560 ret = fjes_hw_issue_request_command(
561 hw, FJES_CMD_REQ_SHARE_BUFFER);
566 trace_fjes_hw_register_buff_addr(res_buf, timeout);
568 if (res_buf->share_buffer.length !=
569 FJES_DEV_COMMAND_SHARE_BUFFER_RES_LEN) {
570 trace_fjes_hw_register_buff_addr_err("Invalid res_buf");
572 } else if (ret == FJES_CMD_STATUS_NORMAL) {
573 switch (res_buf->share_buffer.code) {
574 case FJES_CMD_REQ_RES_CODE_NORMAL:
576 set_bit(dest_epid, &hw->hw_info.buffer_share_bit);
578 case FJES_CMD_REQ_RES_CODE_BUSY:
579 trace_fjes_hw_register_buff_addr_err("Busy Timeout");
588 case FJES_CMD_STATUS_UNKNOWN:
591 case FJES_CMD_STATUS_TIMEOUT:
592 trace_fjes_hw_register_buff_addr_err("Timeout");
595 case FJES_CMD_STATUS_ERROR_PARAM:
596 case FJES_CMD_STATUS_ERROR_STATUS:
606 int fjes_hw_unregister_buff_addr(struct fjes_hw *hw, int dest_epid)
608 union fjes_device_command_req *req_buf = hw->hw_info.req_buf;
609 union fjes_device_command_res *res_buf = hw->hw_info.res_buf;
610 struct fjes_device_shared_info *share = hw->hw_info.share;
611 enum fjes_dev_command_response_e ret;
618 if (!req_buf || !res_buf || !share)
621 if (!test_bit(dest_epid, &hw->hw_info.buffer_share_bit))
624 memset(req_buf, 0, hw->hw_info.req_buf_size);
625 memset(res_buf, 0, hw->hw_info.res_buf_size);
627 req_buf->unshare_buffer.length =
628 FJES_DEV_COMMAND_UNSHARE_BUFFER_REQ_LEN;
629 req_buf->unshare_buffer.epid = dest_epid;
631 res_buf->unshare_buffer.length = 0;
632 res_buf->unshare_buffer.code = 0;
634 trace_fjes_hw_unregister_buff_addr_req(req_buf);
635 ret = fjes_hw_issue_request_command(hw, FJES_CMD_REQ_UNSHARE_BUFFER);
637 timeout = FJES_COMMAND_REQ_BUFF_TIMEOUT * 1000;
638 while ((ret == FJES_CMD_STATUS_NORMAL) &&
639 (res_buf->unshare_buffer.length ==
640 FJES_DEV_COMMAND_UNSHARE_BUFFER_RES_LEN) &&
641 (res_buf->unshare_buffer.code ==
642 FJES_CMD_REQ_RES_CODE_BUSY) &&
644 msleep(200 + hw->my_epid * 20);
645 timeout -= (200 + hw->my_epid * 20);
647 res_buf->unshare_buffer.length = 0;
648 res_buf->unshare_buffer.code = 0;
651 fjes_hw_issue_request_command(hw, FJES_CMD_REQ_UNSHARE_BUFFER);
656 trace_fjes_hw_unregister_buff_addr(res_buf, timeout);
658 if (res_buf->unshare_buffer.length !=
659 FJES_DEV_COMMAND_UNSHARE_BUFFER_RES_LEN) {
660 trace_fjes_hw_unregister_buff_addr_err("Invalid res_buf");
662 } else if (ret == FJES_CMD_STATUS_NORMAL) {
663 switch (res_buf->unshare_buffer.code) {
664 case FJES_CMD_REQ_RES_CODE_NORMAL:
666 clear_bit(dest_epid, &hw->hw_info.buffer_share_bit);
668 case FJES_CMD_REQ_RES_CODE_BUSY:
669 trace_fjes_hw_unregister_buff_addr_err("Busy Timeout");
678 case FJES_CMD_STATUS_UNKNOWN:
681 case FJES_CMD_STATUS_TIMEOUT:
682 trace_fjes_hw_unregister_buff_addr_err("Timeout");
685 case FJES_CMD_STATUS_ERROR_PARAM:
686 case FJES_CMD_STATUS_ERROR_STATUS:
696 int fjes_hw_raise_interrupt(struct fjes_hw *hw, int dest_epid,
697 enum REG_ICTL_MASK mask)
699 u32 ig = mask | dest_epid;
701 wr32(XSCT_IG, cpu_to_le32(ig));
706 u32 fjes_hw_capture_interrupt_status(struct fjes_hw *hw)
710 cur_is = rd32(XSCT_IS);
715 void fjes_hw_set_irqmask(struct fjes_hw *hw,
716 enum REG_ICTL_MASK intr_mask, bool mask)
719 wr32(XSCT_IMS, intr_mask);
721 wr32(XSCT_IMC, intr_mask);
724 bool fjes_hw_epid_is_same_zone(struct fjes_hw *hw, int epid)
726 if (epid >= hw->max_epid)
729 if ((hw->ep_shm_info[epid].es_status !=
730 FJES_ZONING_STATUS_ENABLE) ||
731 (hw->ep_shm_info[hw->my_epid].zone ==
732 FJES_ZONING_ZONE_TYPE_NONE))
735 return (hw->ep_shm_info[epid].zone ==
736 hw->ep_shm_info[hw->my_epid].zone);
739 int fjes_hw_epid_is_shared(struct fjes_device_shared_info *share,
744 if (dest_epid < share->epnum)
745 value = share->ep_status[dest_epid];
750 static bool fjes_hw_epid_is_stop_requested(struct fjes_hw *hw, int src_epid)
752 return test_bit(src_epid, &hw->txrx_stop_req_bit);
755 static bool fjes_hw_epid_is_stop_process_done(struct fjes_hw *hw, int src_epid)
757 return (hw->ep_shm_info[src_epid].tx.info->v1i.rx_status &
758 FJES_RX_STOP_REQ_DONE);
761 enum ep_partner_status
762 fjes_hw_get_partner_ep_status(struct fjes_hw *hw, int epid)
764 enum ep_partner_status status;
766 if (fjes_hw_epid_is_shared(hw->hw_info.share, epid)) {
767 if (fjes_hw_epid_is_stop_requested(hw, epid)) {
768 status = EP_PARTNER_WAITING;
770 if (fjes_hw_epid_is_stop_process_done(hw, epid))
771 status = EP_PARTNER_COMPLETE;
773 status = EP_PARTNER_SHARED;
776 status = EP_PARTNER_UNSHARE;
782 void fjes_hw_raise_epstop(struct fjes_hw *hw)
784 enum ep_partner_status status;
788 for (epidx = 0; epidx < hw->max_epid; epidx++) {
789 if (epidx == hw->my_epid)
792 status = fjes_hw_get_partner_ep_status(hw, epidx);
794 case EP_PARTNER_SHARED:
795 fjes_hw_raise_interrupt(hw, epidx,
796 REG_ICTL_MASK_TXRX_STOP_REQ);
797 hw->ep_shm_info[epidx].ep_stats.send_intr_unshare += 1;
803 set_bit(epidx, &hw->hw_info.buffer_unshare_reserve_bit);
804 set_bit(epidx, &hw->txrx_stop_req_bit);
806 spin_lock_irqsave(&hw->rx_status_lock, flags);
807 hw->ep_shm_info[epidx].tx.info->v1i.rx_status |=
808 FJES_RX_STOP_REQ_REQUEST;
809 spin_unlock_irqrestore(&hw->rx_status_lock, flags);
813 int fjes_hw_wait_epstop(struct fjes_hw *hw)
815 enum ep_partner_status status;
816 union ep_buffer_info *info;
820 while (hw->hw_info.buffer_unshare_reserve_bit &&
821 (wait_time < FJES_COMMAND_EPSTOP_WAIT_TIMEOUT * 1000)) {
822 for (epidx = 0; epidx < hw->max_epid; epidx++) {
823 if (epidx == hw->my_epid)
825 status = fjes_hw_epid_is_shared(hw->hw_info.share,
827 info = hw->ep_shm_info[epidx].rx.info;
829 (info->v1i.rx_status &
830 FJES_RX_STOP_REQ_DONE)) &&
832 &hw->hw_info.buffer_unshare_reserve_bit)) {
834 &hw->hw_info.buffer_unshare_reserve_bit);
842 for (epidx = 0; epidx < hw->max_epid; epidx++) {
843 if (epidx == hw->my_epid)
845 if (test_bit(epidx, &hw->hw_info.buffer_unshare_reserve_bit))
847 &hw->hw_info.buffer_unshare_reserve_bit);
850 return (wait_time < FJES_COMMAND_EPSTOP_WAIT_TIMEOUT * 1000)
854 bool fjes_hw_check_epbuf_version(struct epbuf_handler *epbh, u32 version)
856 union ep_buffer_info *info = epbh->info;
858 return (info->common.version == version);
861 bool fjes_hw_check_mtu(struct epbuf_handler *epbh, u32 mtu)
863 union ep_buffer_info *info = epbh->info;
865 return ((info->v1i.frame_max == FJES_MTU_TO_FRAME_SIZE(mtu)) &&
866 info->v1i.rx_status & FJES_RX_MTU_CHANGING_DONE);
869 bool fjes_hw_check_vlan_id(struct epbuf_handler *epbh, u16 vlan_id)
871 union ep_buffer_info *info = epbh->info;
878 for (i = 0; i < EP_BUFFER_SUPPORT_VLAN_MAX; i++) {
879 if (vlan_id == info->v1i.vlan_id[i]) {
888 bool fjes_hw_set_vlan_id(struct epbuf_handler *epbh, u16 vlan_id)
890 union ep_buffer_info *info = epbh->info;
893 for (i = 0; i < EP_BUFFER_SUPPORT_VLAN_MAX; i++) {
894 if (info->v1i.vlan_id[i] == 0) {
895 info->v1i.vlan_id[i] = vlan_id;
902 void fjes_hw_del_vlan_id(struct epbuf_handler *epbh, u16 vlan_id)
904 union ep_buffer_info *info = epbh->info;
908 for (i = 0; i < EP_BUFFER_SUPPORT_VLAN_MAX; i++) {
909 if (vlan_id == info->v1i.vlan_id[i])
910 info->v1i.vlan_id[i] = 0;
915 bool fjes_hw_epbuf_rx_is_empty(struct epbuf_handler *epbh)
917 union ep_buffer_info *info = epbh->info;
919 if (!(info->v1i.rx_status & FJES_RX_MTU_CHANGING_DONE))
922 if (info->v1i.count_max == 0)
925 return EP_RING_EMPTY(info->v1i.head, info->v1i.tail,
926 info->v1i.count_max);
929 void *fjes_hw_epbuf_rx_curpkt_get_addr(struct epbuf_handler *epbh,
932 union ep_buffer_info *info = epbh->info;
933 struct esmem_frame *ring_frame;
936 ring_frame = (struct esmem_frame *)&(epbh->ring[EP_RING_INDEX
938 info->v1i.count_max) *
939 info->v1i.frame_max]);
941 *psize = (size_t)ring_frame->frame_size;
943 frame = ring_frame->frame_data;
948 void fjes_hw_epbuf_rx_curpkt_drop(struct epbuf_handler *epbh)
950 union ep_buffer_info *info = epbh->info;
952 if (fjes_hw_epbuf_rx_is_empty(epbh))
955 EP_RING_INDEX_INC(epbh->info->v1i.head, info->v1i.count_max);
958 int fjes_hw_epbuf_tx_pkt_send(struct epbuf_handler *epbh,
959 void *frame, size_t size)
961 union ep_buffer_info *info = epbh->info;
962 struct esmem_frame *ring_frame;
964 if (EP_RING_FULL(info->v1i.head, info->v1i.tail, info->v1i.count_max))
967 ring_frame = (struct esmem_frame *)&(epbh->ring[EP_RING_INDEX
969 info->v1i.count_max) *
970 info->v1i.frame_max]);
972 ring_frame->frame_size = size;
973 memcpy((void *)(ring_frame->frame_data), (void *)frame, size);
975 EP_RING_INDEX_INC(epbh->info->v1i.tail, info->v1i.count_max);
980 static void fjes_hw_update_zone_task(struct work_struct *work)
982 struct fjes_hw *hw = container_of(work,
983 struct fjes_hw, update_zone_task);
985 struct my_s {u8 es_status; u8 zone; } *info;
986 union fjes_device_command_res *res_buf;
987 enum ep_partner_status pstatus;
989 struct fjes_adapter *adapter;
990 struct net_device *netdev;
993 ulong unshare_bit = 0;
1000 adapter = (struct fjes_adapter *)hw->back;
1001 netdev = adapter->netdev;
1002 res_buf = hw->hw_info.res_buf;
1003 info = (struct my_s *)&res_buf->info.info;
1005 mutex_lock(&hw->hw_info.lock);
1007 ret = fjes_hw_request_info(hw);
1012 if (!work_pending(&adapter->force_close_task)) {
1013 adapter->force_reset = true;
1014 schedule_work(&adapter->force_close_task);
1020 for (epidx = 0; epidx < hw->max_epid; epidx++) {
1021 if (epidx == hw->my_epid) {
1022 hw->ep_shm_info[epidx].es_status =
1023 info[epidx].es_status;
1024 hw->ep_shm_info[epidx].zone =
1029 pstatus = fjes_hw_get_partner_ep_status(hw, epidx);
1031 case EP_PARTNER_UNSHARE:
1033 if ((info[epidx].zone !=
1034 FJES_ZONING_ZONE_TYPE_NONE) &&
1035 (info[epidx].es_status ==
1036 FJES_ZONING_STATUS_ENABLE) &&
1037 (info[epidx].zone ==
1038 info[hw->my_epid].zone))
1039 set_bit(epidx, &share_bit);
1041 set_bit(epidx, &unshare_bit);
1044 case EP_PARTNER_COMPLETE:
1045 case EP_PARTNER_WAITING:
1046 if ((info[epidx].zone ==
1047 FJES_ZONING_ZONE_TYPE_NONE) ||
1048 (info[epidx].es_status !=
1049 FJES_ZONING_STATUS_ENABLE) ||
1050 (info[epidx].zone !=
1051 info[hw->my_epid].zone)) {
1053 &adapter->unshare_watch_bitmask);
1055 &hw->hw_info.buffer_unshare_reserve_bit);
1059 case EP_PARTNER_SHARED:
1060 if ((info[epidx].zone ==
1061 FJES_ZONING_ZONE_TYPE_NONE) ||
1062 (info[epidx].es_status !=
1063 FJES_ZONING_STATUS_ENABLE) ||
1064 (info[epidx].zone !=
1065 info[hw->my_epid].zone))
1066 set_bit(epidx, &irq_bit);
1070 hw->ep_shm_info[epidx].es_status =
1071 info[epidx].es_status;
1072 hw->ep_shm_info[epidx].zone = info[epidx].zone;
1077 mutex_unlock(&hw->hw_info.lock);
1079 for (epidx = 0; epidx < hw->max_epid; epidx++) {
1080 if (epidx == hw->my_epid)
1083 if (test_bit(epidx, &share_bit)) {
1084 spin_lock_irqsave(&hw->rx_status_lock, flags);
1085 fjes_hw_setup_epbuf(&hw->ep_shm_info[epidx].tx,
1086 netdev->dev_addr, netdev->mtu);
1087 spin_unlock_irqrestore(&hw->rx_status_lock, flags);
1089 mutex_lock(&hw->hw_info.lock);
1091 ret = fjes_hw_register_buff_addr(
1092 hw, epidx, &hw->ep_shm_info[epidx]);
1100 if (!work_pending(&adapter->force_close_task)) {
1101 adapter->force_reset = true;
1103 &adapter->force_close_task);
1107 mutex_unlock(&hw->hw_info.lock);
1109 hw->ep_shm_info[epidx].ep_stats
1110 .com_regist_buf_exec += 1;
1113 if (test_bit(epidx, &unshare_bit)) {
1114 mutex_lock(&hw->hw_info.lock);
1116 ret = fjes_hw_unregister_buff_addr(hw, epidx);
1124 if (!work_pending(&adapter->force_close_task)) {
1125 adapter->force_reset = true;
1127 &adapter->force_close_task);
1132 mutex_unlock(&hw->hw_info.lock);
1134 hw->ep_shm_info[epidx].ep_stats
1135 .com_unregist_buf_exec += 1;
1138 spin_lock_irqsave(&hw->rx_status_lock, flags);
1139 fjes_hw_setup_epbuf(
1140 &hw->ep_shm_info[epidx].tx,
1141 netdev->dev_addr, netdev->mtu);
1142 spin_unlock_irqrestore(&hw->rx_status_lock,
1147 if (test_bit(epidx, &irq_bit)) {
1148 fjes_hw_raise_interrupt(hw, epidx,
1149 REG_ICTL_MASK_TXRX_STOP_REQ);
1151 hw->ep_shm_info[epidx].ep_stats.send_intr_unshare += 1;
1153 set_bit(epidx, &hw->txrx_stop_req_bit);
1154 spin_lock_irqsave(&hw->rx_status_lock, flags);
1155 hw->ep_shm_info[epidx].tx.
1156 info->v1i.rx_status |=
1157 FJES_RX_STOP_REQ_REQUEST;
1158 spin_unlock_irqrestore(&hw->rx_status_lock, flags);
1159 set_bit(epidx, &hw->hw_info.buffer_unshare_reserve_bit);
1163 if (irq_bit || adapter->unshare_watch_bitmask) {
1164 if (!work_pending(&adapter->unshare_watch_task))
1165 queue_work(adapter->control_wq,
1166 &adapter->unshare_watch_task);
1170 static void fjes_hw_epstop_task(struct work_struct *work)
1172 struct fjes_hw *hw = container_of(work, struct fjes_hw, epstop_task);
1173 struct fjes_adapter *adapter = (struct fjes_adapter *)hw->back;
1174 unsigned long flags;
1179 while ((remain_bit = hw->epstop_req_bit)) {
1180 for (epid_bit = 0; remain_bit; remain_bit >>= 1, epid_bit++) {
1181 if (remain_bit & 1) {
1182 spin_lock_irqsave(&hw->rx_status_lock, flags);
1183 hw->ep_shm_info[epid_bit].
1184 tx.info->v1i.rx_status |=
1185 FJES_RX_STOP_REQ_DONE;
1186 spin_unlock_irqrestore(&hw->rx_status_lock,
1189 clear_bit(epid_bit, &hw->epstop_req_bit);
1191 &adapter->unshare_watch_bitmask);
1193 if (!work_pending(&adapter->unshare_watch_task))
1195 adapter->control_wq,
1196 &adapter->unshare_watch_task);
1202 int fjes_hw_start_debug(struct fjes_hw *hw)
1204 union fjes_device_command_req *req_buf = hw->hw_info.req_buf;
1205 union fjes_device_command_res *res_buf = hw->hw_info.res_buf;
1206 enum fjes_dev_command_response_e ret;
1212 if (!hw->hw_info.trace)
1214 memset(hw->hw_info.trace, 0, FJES_DEBUG_BUFFER_SIZE);
1216 memset(req_buf, 0, hw->hw_info.req_buf_size);
1217 memset(res_buf, 0, hw->hw_info.res_buf_size);
1219 req_buf->start_trace.length =
1220 FJES_DEV_COMMAND_START_DBG_REQ_LEN(hw->hw_info.trace_size);
1221 req_buf->start_trace.mode = hw->debug_mode;
1222 req_buf->start_trace.buffer_len = hw->hw_info.trace_size;
1223 page_count = hw->hw_info.trace_size / FJES_DEBUG_PAGE_SIZE;
1224 for (i = 0; i < page_count; i++) {
1225 addr = ((u8 *)hw->hw_info.trace) + i * FJES_DEBUG_PAGE_SIZE;
1226 req_buf->start_trace.buffer[i] =
1227 (__le64)(page_to_phys(vmalloc_to_page(addr)) +
1228 offset_in_page(addr));
1231 res_buf->start_trace.length = 0;
1232 res_buf->start_trace.code = 0;
1234 trace_fjes_hw_start_debug_req(req_buf);
1235 ret = fjes_hw_issue_request_command(hw, FJES_CMD_REQ_START_DEBUG);
1236 trace_fjes_hw_start_debug(res_buf);
1238 if (res_buf->start_trace.length !=
1239 FJES_DEV_COMMAND_START_DBG_RES_LEN) {
1241 trace_fjes_hw_start_debug_err("Invalid res_buf");
1242 } else if (ret == FJES_CMD_STATUS_NORMAL) {
1243 switch (res_buf->start_trace.code) {
1244 case FJES_CMD_REQ_RES_CODE_NORMAL:
1253 case FJES_CMD_STATUS_UNKNOWN:
1256 case FJES_CMD_STATUS_TIMEOUT:
1257 trace_fjes_hw_start_debug_err("Busy Timeout");
1260 case FJES_CMD_STATUS_ERROR_PARAM:
1261 case FJES_CMD_STATUS_ERROR_STATUS:
1271 int fjes_hw_stop_debug(struct fjes_hw *hw)
1273 union fjes_device_command_req *req_buf = hw->hw_info.req_buf;
1274 union fjes_device_command_res *res_buf = hw->hw_info.res_buf;
1275 enum fjes_dev_command_response_e ret;
1278 if (!hw->hw_info.trace)
1281 memset(req_buf, 0, hw->hw_info.req_buf_size);
1282 memset(res_buf, 0, hw->hw_info.res_buf_size);
1283 req_buf->stop_trace.length = FJES_DEV_COMMAND_STOP_DBG_REQ_LEN;
1285 res_buf->stop_trace.length = 0;
1286 res_buf->stop_trace.code = 0;
1288 ret = fjes_hw_issue_request_command(hw, FJES_CMD_REQ_STOP_DEBUG);
1289 trace_fjes_hw_stop_debug(res_buf);
1291 if (res_buf->stop_trace.length != FJES_DEV_COMMAND_STOP_DBG_RES_LEN) {
1292 trace_fjes_hw_stop_debug_err("Invalid res_buf");
1294 } else if (ret == FJES_CMD_STATUS_NORMAL) {
1295 switch (res_buf->stop_trace.code) {
1296 case FJES_CMD_REQ_RES_CODE_NORMAL:
1306 case FJES_CMD_STATUS_UNKNOWN:
1309 case FJES_CMD_STATUS_TIMEOUT:
1311 trace_fjes_hw_stop_debug_err("Busy Timeout");
1313 case FJES_CMD_STATUS_ERROR_PARAM:
1314 case FJES_CMD_STATUS_ERROR_STATUS: