?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dt-bindings: mtd: ingenic: Use standard ecc-engine property
[linux/fpc-iii.git] / drivers / net / fjes / fjes_hw.c
blob9c652c04375bf562632fcda5729809186fd22e99
1 /*
2 * FUJITSU Extended Socket Network Device driver
3 * Copyright (c) 2015 FUJITSU LIMITED
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, see <http://www.gnu.org/licenses/>.
16 *
17 * The full GNU General Public License is included in this distribution in
18 * the file called "COPYING".
19 *
20 */
21
22 #include "fjes_hw.h"
23 #include "fjes.h"
24 #include "fjes_trace.h"
25
26 static void fjes_hw_update_zone_task(struct work_struct *);
27 static void fjes_hw_epstop_task(struct work_struct *);
28
29 /* supported MTU list */
30 const u32 fjes_support_mtu[] = {
31 FJES_MTU_DEFINE(8 * 1024),
32 FJES_MTU_DEFINE(16 * 1024),
33 FJES_MTU_DEFINE(32 * 1024),
34 FJES_MTU_DEFINE(64 * 1024),
35 0
36 };
37
38 u32 fjes_hw_rd32(struct fjes_hw *hw, u32 reg)
39 {
40 u8 *base = hw->base;
41 u32 value = 0;
42
43 value = readl(&base[reg]);
44
45 return value;
46 }
47
48 static u8 *fjes_hw_iomap(struct fjes_hw *hw)
49 {
50 u8 *base;
51
52 if (!request_mem_region(hw->hw_res.start, hw->hw_res.size,
53 fjes_driver_name)) {
54 pr_err("request_mem_region failed\n");
55 return NULL;
56 }
57
58 base = (u8 *)ioremap_nocache(hw->hw_res.start, hw->hw_res.size);
59
60 return base;
61 }
62
63 static void fjes_hw_iounmap(struct fjes_hw *hw)
64 {
65 iounmap(hw->base);
66 release_mem_region(hw->hw_res.start, hw->hw_res.size);
67 }
68
69 int fjes_hw_reset(struct fjes_hw *hw)
70 {
71 union REG_DCTL dctl;
72 int timeout;
73
74 dctl.reg = 0;
75 dctl.bits.reset = 1;
76 wr32(XSCT_DCTL, dctl.reg);
77
78 timeout = FJES_DEVICE_RESET_TIMEOUT * 1000;
79 dctl.reg = rd32(XSCT_DCTL);
80 while ((dctl.bits.reset == 1) && (timeout > 0)) {
81 msleep(1000);
82 dctl.reg = rd32(XSCT_DCTL);
83 timeout -= 1000;
84 }
85
86 return timeout > 0 ? 0 : -EIO;
87 }
88
89 static int fjes_hw_get_max_epid(struct fjes_hw *hw)
90 {
91 union REG_MAX_EP info;
92
93 info.reg = rd32(XSCT_MAX_EP);
94
95 return info.bits.maxep;
96 }
97
98 static int fjes_hw_get_my_epid(struct fjes_hw *hw)
99 {
100 union REG_OWNER_EPID info;
101
102 info.reg = rd32(XSCT_OWNER_EPID);
103
104 return info.bits.epid;
105 }
106
107 static int fjes_hw_alloc_shared_status_region(struct fjes_hw *hw)
108 {
109 size_t size;
110
111 size = sizeof(struct fjes_device_shared_info) +
112 (sizeof(u8) * hw->max_epid);
113 hw->hw_info.share = kzalloc(size, GFP_KERNEL);
114 if (!hw->hw_info.share)
115 return -ENOMEM;
116
117 hw->hw_info.share->epnum = hw->max_epid;
118
119 return 0;
120 }
121
122 static void fjes_hw_free_shared_status_region(struct fjes_hw *hw)
123 {
124 kfree(hw->hw_info.share);
125 hw->hw_info.share = NULL;
126 }
127
128 static int fjes_hw_alloc_epbuf(struct epbuf_handler *epbh)
129 {
130 void *mem;
131
132 mem = vzalloc(EP_BUFFER_SIZE);
133 if (!mem)
134 return -ENOMEM;
135
136 epbh->buffer = mem;
137 epbh->size = EP_BUFFER_SIZE;
138
139 epbh->info = (union ep_buffer_info *)mem;
140 epbh->ring = (u8 *)(mem + sizeof(union ep_buffer_info));
141
142 return 0;
143 }
144
145 static void fjes_hw_free_epbuf(struct epbuf_handler *epbh)
146 {
147 vfree(epbh->buffer);
148 epbh->buffer = NULL;
149 epbh->size = 0;
150
151 epbh->info = NULL;
152 epbh->ring = NULL;
153 }
154
155 void fjes_hw_setup_epbuf(struct epbuf_handler *epbh, u8 *mac_addr, u32 mtu)
156 {
157 union ep_buffer_info *info = epbh->info;
158 u16 vlan_id[EP_BUFFER_SUPPORT_VLAN_MAX];
159 int i;
160
161 for (i = 0; i < EP_BUFFER_SUPPORT_VLAN_MAX; i++)
162 vlan_id[i] = info->v1i.vlan_id[i];
163
164 memset(info, 0, sizeof(union ep_buffer_info));
165
166 info->v1i.version = 0; /* version 0 */
167
168 for (i = 0; i < ETH_ALEN; i++)
169 info->v1i.mac_addr[i] = mac_addr[i];
170
171 info->v1i.head = 0;
172 info->v1i.tail = 1;
173
174 info->v1i.info_size = sizeof(union ep_buffer_info);
175 info->v1i.buffer_size = epbh->size - info->v1i.info_size;
176
177 info->v1i.frame_max = FJES_MTU_TO_FRAME_SIZE(mtu);
178 info->v1i.count_max =
179 EP_RING_NUM(info->v1i.buffer_size, info->v1i.frame_max);
180
181 for (i = 0; i < EP_BUFFER_SUPPORT_VLAN_MAX; i++)
182 info->v1i.vlan_id[i] = vlan_id[i];
183
184 info->v1i.rx_status |= FJES_RX_MTU_CHANGING_DONE;
185 }
186
187 void
188 fjes_hw_init_command_registers(struct fjes_hw *hw,
189 struct fjes_device_command_param *param)
190 {
191 /* Request Buffer length */
192 wr32(XSCT_REQBL, (__le32)(param->req_len));
193 /* Response Buffer Length */
194 wr32(XSCT_RESPBL, (__le32)(param->res_len));
195
196 /* Request Buffer Address */
197 wr32(XSCT_REQBAL,
198 (__le32)(param->req_start & GENMASK_ULL(31, 0)));
199 wr32(XSCT_REQBAH,
200 (__le32)((param->req_start & GENMASK_ULL(63, 32)) >> 32));
201
202 /* Response Buffer Address */
203 wr32(XSCT_RESPBAL,
204 (__le32)(param->res_start & GENMASK_ULL(31, 0)));
205 wr32(XSCT_RESPBAH,
206 (__le32)((param->res_start & GENMASK_ULL(63, 32)) >> 32));
207
208 /* Share status address */
209 wr32(XSCT_SHSTSAL,
210 (__le32)(param->share_start & GENMASK_ULL(31, 0)));
211 wr32(XSCT_SHSTSAH,
212 (__le32)((param->share_start & GENMASK_ULL(63, 32)) >> 32));
213 }
214
215 static int fjes_hw_setup(struct fjes_hw *hw)
216 {
217 u8 mac[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
218 struct fjes_device_command_param param;
219 struct ep_share_mem_info *buf_pair;
220 unsigned long flags;
221 size_t mem_size;
222 int result;
223 int epidx;
224 void *buf;
225
226 hw->hw_info.max_epid = &hw->max_epid;
227 hw->hw_info.my_epid = &hw->my_epid;
228
229 buf = kcalloc(hw->max_epid, sizeof(struct ep_share_mem_info),
230 GFP_KERNEL);
231 if (!buf)
232 return -ENOMEM;
233
234 hw->ep_shm_info = (struct ep_share_mem_info *)buf;
235
236 mem_size = FJES_DEV_REQ_BUF_SIZE(hw->max_epid);
237 hw->hw_info.req_buf = kzalloc(mem_size, GFP_KERNEL);
238 if (!(hw->hw_info.req_buf))
239 return -ENOMEM;
240
241 hw->hw_info.req_buf_size = mem_size;
242
243 mem_size = FJES_DEV_RES_BUF_SIZE(hw->max_epid);
244 hw->hw_info.res_buf = kzalloc(mem_size, GFP_KERNEL);
245 if (!(hw->hw_info.res_buf))
246 return -ENOMEM;
247
248 hw->hw_info.res_buf_size = mem_size;
249
250 result = fjes_hw_alloc_shared_status_region(hw);
251 if (result)
252 return result;
253
254 hw->hw_info.buffer_share_bit = 0;
255 hw->hw_info.buffer_unshare_reserve_bit = 0;
256
257 for (epidx = 0; epidx < hw->max_epid; epidx++) {
258 if (epidx != hw->my_epid) {
259 buf_pair = &hw->ep_shm_info[epidx];
260
261 result = fjes_hw_alloc_epbuf(&buf_pair->tx);
262 if (result)
263 return result;
264
265 result = fjes_hw_alloc_epbuf(&buf_pair->rx);
266 if (result)
267 return result;
268
269 spin_lock_irqsave(&hw->rx_status_lock, flags);
270 fjes_hw_setup_epbuf(&buf_pair->tx, mac,
271 fjes_support_mtu[0]);
272 fjes_hw_setup_epbuf(&buf_pair->rx, mac,
273 fjes_support_mtu[0]);
274 spin_unlock_irqrestore(&hw->rx_status_lock, flags);
275 }
276 }
277
278 memset(&param, 0, sizeof(param));
279
280 param.req_len = hw->hw_info.req_buf_size;
281 param.req_start = __pa(hw->hw_info.req_buf);
282 param.res_len = hw->hw_info.res_buf_size;
283 param.res_start = __pa(hw->hw_info.res_buf);
284
285 param.share_start = __pa(hw->hw_info.share->ep_status);
286
287 fjes_hw_init_command_registers(hw, &param);
288
289 return 0;
290 }
291
292 static void fjes_hw_cleanup(struct fjes_hw *hw)
293 {
294 int epidx;
295
296 if (!hw->ep_shm_info)
297 return;
298
299 fjes_hw_free_shared_status_region(hw);
300
301 kfree(hw->hw_info.req_buf);
302 hw->hw_info.req_buf = NULL;
303
304 kfree(hw->hw_info.res_buf);
305 hw->hw_info.res_buf = NULL;
306
307 for (epidx = 0; epidx < hw->max_epid ; epidx++) {
308 if (epidx == hw->my_epid)
309 continue;
310 fjes_hw_free_epbuf(&hw->ep_shm_info[epidx].tx);
311 fjes_hw_free_epbuf(&hw->ep_shm_info[epidx].rx);
312 }
313
314 kfree(hw->ep_shm_info);
315 hw->ep_shm_info = NULL;
316 }
317
318 int fjes_hw_init(struct fjes_hw *hw)
319 {
320 int ret;
321
322 hw->base = fjes_hw_iomap(hw);
323 if (!hw->base)
324 return -EIO;
325
326 ret = fjes_hw_reset(hw);
327 if (ret)
328 return ret;
329
330 fjes_hw_set_irqmask(hw, REG_ICTL_MASK_ALL, true);
331
332 INIT_WORK(&hw->update_zone_task, fjes_hw_update_zone_task);
333 INIT_WORK(&hw->epstop_task, fjes_hw_epstop_task);
334
335 mutex_init(&hw->hw_info.lock);
336 spin_lock_init(&hw->rx_status_lock);
337
338 hw->max_epid = fjes_hw_get_max_epid(hw);
339 hw->my_epid = fjes_hw_get_my_epid(hw);
340
341 if ((hw->max_epid == 0) || (hw->my_epid >= hw->max_epid))
342 return -ENXIO;
343
344 ret = fjes_hw_setup(hw);
345
346 hw->hw_info.trace = vzalloc(FJES_DEBUG_BUFFER_SIZE);
347 hw->hw_info.trace_size = FJES_DEBUG_BUFFER_SIZE;
348
349 return ret;
350 }
351
352 void fjes_hw_exit(struct fjes_hw *hw)
353 {
354 int ret;
355
356 if (hw->base) {
357
358 if (hw->debug_mode) {
359 /* disable debug mode */
360 mutex_lock(&hw->hw_info.lock);
361 fjes_hw_stop_debug(hw);
362 mutex_unlock(&hw->hw_info.lock);
363 }
364 vfree(hw->hw_info.trace);
365 hw->hw_info.trace = NULL;
366 hw->hw_info.trace_size = 0;
367 hw->debug_mode = 0;
368
369 ret = fjes_hw_reset(hw);
370 if (ret)
371 pr_err("%s: reset error", __func__);
372
373 fjes_hw_iounmap(hw);
374 hw->base = NULL;
375 }
376
377 fjes_hw_cleanup(hw);
378
379 cancel_work_sync(&hw->update_zone_task);
380 cancel_work_sync(&hw->epstop_task);
381 }
382
383 static enum fjes_dev_command_response_e
384 fjes_hw_issue_request_command(struct fjes_hw *hw,
385 enum fjes_dev_command_request_type type)
386 {
387 enum fjes_dev_command_response_e ret = FJES_CMD_STATUS_UNKNOWN;
388 union REG_CR cr;
389 union REG_CS cs;
390 int timeout = FJES_COMMAND_REQ_TIMEOUT * 1000;
391
392 cr.reg = 0;
393 cr.bits.req_start = 1;
394 cr.bits.req_code = type;
395 wr32(XSCT_CR, cr.reg);
396 cr.reg = rd32(XSCT_CR);
397
398 if (cr.bits.error == 0) {
399 timeout = FJES_COMMAND_REQ_TIMEOUT * 1000;
400 cs.reg = rd32(XSCT_CS);
401
402 while ((cs.bits.complete != 1) && timeout > 0) {
403 msleep(1000);
404 cs.reg = rd32(XSCT_CS);
405 timeout -= 1000;
406 }
407
408 if (cs.bits.complete == 1)
409 ret = FJES_CMD_STATUS_NORMAL;
410 else if (timeout <= 0)
411 ret = FJES_CMD_STATUS_TIMEOUT;
412
413 } else {
414 switch (cr.bits.err_info) {
415 case FJES_CMD_REQ_ERR_INFO_PARAM:
416 ret = FJES_CMD_STATUS_ERROR_PARAM;
417 break;
418 case FJES_CMD_REQ_ERR_INFO_STATUS:
419 ret = FJES_CMD_STATUS_ERROR_STATUS;
420 break;
421 default:
422 ret = FJES_CMD_STATUS_UNKNOWN;
423 break;
424 }
425 }
426
427 trace_fjes_hw_issue_request_command(&cr, &cs, timeout, ret);
428
429 return ret;
430 }
431
432 int fjes_hw_request_info(struct fjes_hw *hw)
433 {
434 union fjes_device_command_req *req_buf = hw->hw_info.req_buf;
435 union fjes_device_command_res *res_buf = hw->hw_info.res_buf;
436 enum fjes_dev_command_response_e ret;
437 int result;
438
439 memset(req_buf, 0, hw->hw_info.req_buf_size);
440 memset(res_buf, 0, hw->hw_info.res_buf_size);
441
442 req_buf->info.length = FJES_DEV_COMMAND_INFO_REQ_LEN;
443
444 res_buf->info.length = 0;
445 res_buf->info.code = 0;
446
447 ret = fjes_hw_issue_request_command(hw, FJES_CMD_REQ_INFO);
448 trace_fjes_hw_request_info(hw, res_buf);
449
450 result = 0;
451
452 if (FJES_DEV_COMMAND_INFO_RES_LEN((*hw->hw_info.max_epid)) !=
453 res_buf->info.length) {
454 trace_fjes_hw_request_info_err("Invalid res_buf");
455 result = -ENOMSG;
456 } else if (ret == FJES_CMD_STATUS_NORMAL) {
457 switch (res_buf->info.code) {
458 case FJES_CMD_REQ_RES_CODE_NORMAL:
459 result = 0;
460 break;
461 default:
462 result = -EPERM;
463 break;
464 }
465 } else {
466 switch (ret) {
467 case FJES_CMD_STATUS_UNKNOWN:
468 result = -EPERM;
469 break;
470 case FJES_CMD_STATUS_TIMEOUT:
471 trace_fjes_hw_request_info_err("Timeout");
472 result = -EBUSY;
473 break;
474 case FJES_CMD_STATUS_ERROR_PARAM:
475 result = -EPERM;
476 break;
477 case FJES_CMD_STATUS_ERROR_STATUS:
478 result = -EPERM;
479 break;
480 default:
481 result = -EPERM;
482 break;
483 }
484 }
485
486 return result;
487 }
488
489 int fjes_hw_register_buff_addr(struct fjes_hw *hw, int dest_epid,
490 struct ep_share_mem_info *buf_pair)
491 {
492 union fjes_device_command_req *req_buf = hw->hw_info.req_buf;
493 union fjes_device_command_res *res_buf = hw->hw_info.res_buf;
494 enum fjes_dev_command_response_e ret;
495 int page_count;
496 int timeout;
497 int i, idx;
498 void *addr;
499 int result;
500
501 if (test_bit(dest_epid, &hw->hw_info.buffer_share_bit))
502 return 0;
503
504 memset(req_buf, 0, hw->hw_info.req_buf_size);
505 memset(res_buf, 0, hw->hw_info.res_buf_size);
506
507 req_buf->share_buffer.length = FJES_DEV_COMMAND_SHARE_BUFFER_REQ_LEN(
508 buf_pair->tx.size,
509 buf_pair->rx.size);
510 req_buf->share_buffer.epid = dest_epid;
511
512 idx = 0;
513 req_buf->share_buffer.buffer[idx++] = buf_pair->tx.size;
514 page_count = buf_pair->tx.size / EP_BUFFER_INFO_SIZE;
515 for (i = 0; i < page_count; i++) {
516 addr = ((u8 *)(buf_pair->tx.buffer)) +
517 (i * EP_BUFFER_INFO_SIZE);
518 req_buf->share_buffer.buffer[idx++] =
519 (__le64)(page_to_phys(vmalloc_to_page(addr)) +
520 offset_in_page(addr));
521 }
522
523 req_buf->share_buffer.buffer[idx++] = buf_pair->rx.size;
524 page_count = buf_pair->rx.size / EP_BUFFER_INFO_SIZE;
525 for (i = 0; i < page_count; i++) {
526 addr = ((u8 *)(buf_pair->rx.buffer)) +
527 (i * EP_BUFFER_INFO_SIZE);
528 req_buf->share_buffer.buffer[idx++] =
529 (__le64)(page_to_phys(vmalloc_to_page(addr)) +
530 offset_in_page(addr));
531 }
532
533 res_buf->share_buffer.length = 0;
534 res_buf->share_buffer.code = 0;
535
536 trace_fjes_hw_register_buff_addr_req(req_buf, buf_pair);
537
538 ret = fjes_hw_issue_request_command(hw, FJES_CMD_REQ_SHARE_BUFFER);
539
540 timeout = FJES_COMMAND_REQ_BUFF_TIMEOUT * 1000;
541 while ((ret == FJES_CMD_STATUS_NORMAL) &&
542 (res_buf->share_buffer.length ==
543 FJES_DEV_COMMAND_SHARE_BUFFER_RES_LEN) &&
544 (res_buf->share_buffer.code == FJES_CMD_REQ_RES_CODE_BUSY) &&
545 (timeout > 0)) {
546 msleep(200 + hw->my_epid * 20);
547 timeout -= (200 + hw->my_epid * 20);
548
549 res_buf->share_buffer.length = 0;
550 res_buf->share_buffer.code = 0;
551
552 ret = fjes_hw_issue_request_command(
553 hw, FJES_CMD_REQ_SHARE_BUFFER);
554 }
555
556 result = 0;
557
558 trace_fjes_hw_register_buff_addr(res_buf, timeout);
559
560 if (res_buf->share_buffer.length !=
561 FJES_DEV_COMMAND_SHARE_BUFFER_RES_LEN) {
562 trace_fjes_hw_register_buff_addr_err("Invalid res_buf");
563 result = -ENOMSG;
564 } else if (ret == FJES_CMD_STATUS_NORMAL) {
565 switch (res_buf->share_buffer.code) {
566 case FJES_CMD_REQ_RES_CODE_NORMAL:
567 result = 0;
568 set_bit(dest_epid, &hw->hw_info.buffer_share_bit);
569 break;
570 case FJES_CMD_REQ_RES_CODE_BUSY:
571 trace_fjes_hw_register_buff_addr_err("Busy Timeout");
572 result = -EBUSY;
573 break;
574 default:
575 result = -EPERM;
576 break;
577 }
578 } else {
579 switch (ret) {
580 case FJES_CMD_STATUS_UNKNOWN:
581 result = -EPERM;
582 break;
583 case FJES_CMD_STATUS_TIMEOUT:
584 trace_fjes_hw_register_buff_addr_err("Timeout");
585 result = -EBUSY;
586 break;
587 case FJES_CMD_STATUS_ERROR_PARAM:
588 case FJES_CMD_STATUS_ERROR_STATUS:
589 default:
590 result = -EPERM;
591 break;
592 }
593 }
594
595 return result;
596 }
597
598 int fjes_hw_unregister_buff_addr(struct fjes_hw *hw, int dest_epid)
599 {
600 union fjes_device_command_req *req_buf = hw->hw_info.req_buf;
601 union fjes_device_command_res *res_buf = hw->hw_info.res_buf;
602 struct fjes_device_shared_info *share = hw->hw_info.share;
603 enum fjes_dev_command_response_e ret;
604 int timeout;
605 int result;
606
607 if (!hw->base)
608 return -EPERM;
609
610 if (!req_buf || !res_buf || !share)
611 return -EPERM;
612
613 if (!test_bit(dest_epid, &hw->hw_info.buffer_share_bit))
614 return 0;
615
616 memset(req_buf, 0, hw->hw_info.req_buf_size);
617 memset(res_buf, 0, hw->hw_info.res_buf_size);
618
619 req_buf->unshare_buffer.length =
620 FJES_DEV_COMMAND_UNSHARE_BUFFER_REQ_LEN;
621 req_buf->unshare_buffer.epid = dest_epid;
622
623 res_buf->unshare_buffer.length = 0;
624 res_buf->unshare_buffer.code = 0;
625
626 trace_fjes_hw_unregister_buff_addr_req(req_buf);
627 ret = fjes_hw_issue_request_command(hw, FJES_CMD_REQ_UNSHARE_BUFFER);
628
629 timeout = FJES_COMMAND_REQ_BUFF_TIMEOUT * 1000;
630 while ((ret == FJES_CMD_STATUS_NORMAL) &&
631 (res_buf->unshare_buffer.length ==
632 FJES_DEV_COMMAND_UNSHARE_BUFFER_RES_LEN) &&
633 (res_buf->unshare_buffer.code ==
634 FJES_CMD_REQ_RES_CODE_BUSY) &&
635 (timeout > 0)) {
636 msleep(200 + hw->my_epid * 20);
637 timeout -= (200 + hw->my_epid * 20);
638
639 res_buf->unshare_buffer.length = 0;
640 res_buf->unshare_buffer.code = 0;
641
642 ret =
643 fjes_hw_issue_request_command(hw, FJES_CMD_REQ_UNSHARE_BUFFER);
644 }
645
646 result = 0;
647
648 trace_fjes_hw_unregister_buff_addr(res_buf, timeout);
649
650 if (res_buf->unshare_buffer.length !=
651 FJES_DEV_COMMAND_UNSHARE_BUFFER_RES_LEN) {
652 trace_fjes_hw_unregister_buff_addr_err("Invalid res_buf");
653 result = -ENOMSG;
654 } else if (ret == FJES_CMD_STATUS_NORMAL) {
655 switch (res_buf->unshare_buffer.code) {
656 case FJES_CMD_REQ_RES_CODE_NORMAL:
657 result = 0;
658 clear_bit(dest_epid, &hw->hw_info.buffer_share_bit);
659 break;
660 case FJES_CMD_REQ_RES_CODE_BUSY:
661 trace_fjes_hw_unregister_buff_addr_err("Busy Timeout");
662 result = -EBUSY;
663 break;
664 default:
665 result = -EPERM;
666 break;
667 }
668 } else {
669 switch (ret) {
670 case FJES_CMD_STATUS_UNKNOWN:
671 result = -EPERM;
672 break;
673 case FJES_CMD_STATUS_TIMEOUT:
674 trace_fjes_hw_unregister_buff_addr_err("Timeout");
675 result = -EBUSY;
676 break;
677 case FJES_CMD_STATUS_ERROR_PARAM:
678 case FJES_CMD_STATUS_ERROR_STATUS:
679 default:
680 result = -EPERM;
681 break;
682 }
683 }
684
685 return result;
686 }
687
688 int fjes_hw_raise_interrupt(struct fjes_hw *hw, int dest_epid,
689 enum REG_ICTL_MASK mask)
690 {
691 u32 ig = mask | dest_epid;
692
693 wr32(XSCT_IG, cpu_to_le32(ig));
694
695 return 0;
696 }
697
698 u32 fjes_hw_capture_interrupt_status(struct fjes_hw *hw)
699 {
700 u32 cur_is;
701
702 cur_is = rd32(XSCT_IS);
703
704 return cur_is;
705 }
706
707 void fjes_hw_set_irqmask(struct fjes_hw *hw,
708 enum REG_ICTL_MASK intr_mask, bool mask)
709 {
710 if (mask)
711 wr32(XSCT_IMS, intr_mask);
712 else
713 wr32(XSCT_IMC, intr_mask);
714 }
715
716 bool fjes_hw_epid_is_same_zone(struct fjes_hw *hw, int epid)
717 {
718 if (epid >= hw->max_epid)
719 return false;
720
721 if ((hw->ep_shm_info[epid].es_status !=
722 FJES_ZONING_STATUS_ENABLE) ||
723 (hw->ep_shm_info[hw->my_epid].zone ==
724 FJES_ZONING_ZONE_TYPE_NONE))
725 return false;
726 else
727 return (hw->ep_shm_info[epid].zone ==
728 hw->ep_shm_info[hw->my_epid].zone);
729 }
730
731 int fjes_hw_epid_is_shared(struct fjes_device_shared_info *share,
732 int dest_epid)
733 {
734 int value = false;
735
736 if (dest_epid < share->epnum)
737 value = share->ep_status[dest_epid];
738
739 return value;
740 }
741
742 static bool fjes_hw_epid_is_stop_requested(struct fjes_hw *hw, int src_epid)
743 {
744 return test_bit(src_epid, &hw->txrx_stop_req_bit);
745 }
746
747 static bool fjes_hw_epid_is_stop_process_done(struct fjes_hw *hw, int src_epid)
748 {
749 return (hw->ep_shm_info[src_epid].tx.info->v1i.rx_status &
750 FJES_RX_STOP_REQ_DONE);
751 }
752
753 enum ep_partner_status
754 fjes_hw_get_partner_ep_status(struct fjes_hw *hw, int epid)
755 {
756 enum ep_partner_status status;
757
758 if (fjes_hw_epid_is_shared(hw->hw_info.share, epid)) {
759 if (fjes_hw_epid_is_stop_requested(hw, epid)) {
760 status = EP_PARTNER_WAITING;
761 } else {
762 if (fjes_hw_epid_is_stop_process_done(hw, epid))
763 status = EP_PARTNER_COMPLETE;
764 else
765 status = EP_PARTNER_SHARED;
766 }
767 } else {
768 status = EP_PARTNER_UNSHARE;
769 }
770
771 return status;
772 }
773
774 void fjes_hw_raise_epstop(struct fjes_hw *hw)
775 {
776 enum ep_partner_status status;
777 unsigned long flags;
778 int epidx;
779
780 for (epidx = 0; epidx < hw->max_epid; epidx++) {
781 if (epidx == hw->my_epid)
782 continue;
783
784 status = fjes_hw_get_partner_ep_status(hw, epidx);
785 switch (status) {
786 case EP_PARTNER_SHARED:
787 fjes_hw_raise_interrupt(hw, epidx,
788 REG_ICTL_MASK_TXRX_STOP_REQ);
789 hw->ep_shm_info[epidx].ep_stats.send_intr_unshare += 1;
790 break;
791 default:
792 break;
793 }
794
795 set_bit(epidx, &hw->hw_info.buffer_unshare_reserve_bit);
796 set_bit(epidx, &hw->txrx_stop_req_bit);
797
798 spin_lock_irqsave(&hw->rx_status_lock, flags);
799 hw->ep_shm_info[epidx].tx.info->v1i.rx_status |=
800 FJES_RX_STOP_REQ_REQUEST;
801 spin_unlock_irqrestore(&hw->rx_status_lock, flags);
802 }
803 }
804
805 int fjes_hw_wait_epstop(struct fjes_hw *hw)
806 {
807 enum ep_partner_status status;
808 union ep_buffer_info *info;
809 int wait_time = 0;
810 int epidx;
811
812 while (hw->hw_info.buffer_unshare_reserve_bit &&
813 (wait_time < FJES_COMMAND_EPSTOP_WAIT_TIMEOUT * 1000)) {
814 for (epidx = 0; epidx < hw->max_epid; epidx++) {
815 if (epidx == hw->my_epid)
816 continue;
817 status = fjes_hw_epid_is_shared(hw->hw_info.share,
818 epidx);
819 info = hw->ep_shm_info[epidx].rx.info;
820 if ((!status ||
821 (info->v1i.rx_status &
822 FJES_RX_STOP_REQ_DONE)) &&
823 test_bit(epidx,
824 &hw->hw_info.buffer_unshare_reserve_bit)) {
825 clear_bit(epidx,
826 &hw->hw_info.buffer_unshare_reserve_bit);
827 }
828 }
829
830 msleep(100);
831 wait_time += 100;
832 }
833
834 for (epidx = 0; epidx < hw->max_epid; epidx++) {
835 if (epidx == hw->my_epid)
836 continue;
837 if (test_bit(epidx, &hw->hw_info.buffer_unshare_reserve_bit))
838 clear_bit(epidx,
839 &hw->hw_info.buffer_unshare_reserve_bit);
840 }
841
842 return (wait_time < FJES_COMMAND_EPSTOP_WAIT_TIMEOUT * 1000)
843 ? 0 : -EBUSY;
844 }
845
846 bool fjes_hw_check_epbuf_version(struct epbuf_handler *epbh, u32 version)
847 {
848 union ep_buffer_info *info = epbh->info;
849
850 return (info->common.version == version);
851 }
852
853 bool fjes_hw_check_mtu(struct epbuf_handler *epbh, u32 mtu)
854 {
855 union ep_buffer_info *info = epbh->info;
856
857 return ((info->v1i.frame_max == FJES_MTU_TO_FRAME_SIZE(mtu)) &&
858 info->v1i.rx_status & FJES_RX_MTU_CHANGING_DONE);
859 }
860
861 bool fjes_hw_check_vlan_id(struct epbuf_handler *epbh, u16 vlan_id)
862 {
863 union ep_buffer_info *info = epbh->info;
864 bool ret = false;
865 int i;
866
867 if (vlan_id == 0) {
868 ret = true;
869 } else {
870 for (i = 0; i < EP_BUFFER_SUPPORT_VLAN_MAX; i++) {
871 if (vlan_id == info->v1i.vlan_id[i]) {
872 ret = true;
873 break;
874 }
875 }
876 }
877 return ret;
878 }
879
880 bool fjes_hw_set_vlan_id(struct epbuf_handler *epbh, u16 vlan_id)
881 {
882 union ep_buffer_info *info = epbh->info;
883 int i;
884
885 for (i = 0; i < EP_BUFFER_SUPPORT_VLAN_MAX; i++) {
886 if (info->v1i.vlan_id[i] == 0) {
887 info->v1i.vlan_id[i] = vlan_id;
888 return true;
889 }
890 }
891 return false;
892 }
893
894 void fjes_hw_del_vlan_id(struct epbuf_handler *epbh, u16 vlan_id)
895 {
896 union ep_buffer_info *info = epbh->info;
897 int i;
898
899 if (0 != vlan_id) {
900 for (i = 0; i < EP_BUFFER_SUPPORT_VLAN_MAX; i++) {
901 if (vlan_id == info->v1i.vlan_id[i])
902 info->v1i.vlan_id[i] = 0;
903 }
904 }
905 }
906
907 bool fjes_hw_epbuf_rx_is_empty(struct epbuf_handler *epbh)
908 {
909 union ep_buffer_info *info = epbh->info;
910
911 if (!(info->v1i.rx_status & FJES_RX_MTU_CHANGING_DONE))
912 return true;
913
914 if (info->v1i.count_max == 0)
915 return true;
916
917 return EP_RING_EMPTY(info->v1i.head, info->v1i.tail,
918 info->v1i.count_max);
919 }
920
921 void *fjes_hw_epbuf_rx_curpkt_get_addr(struct epbuf_handler *epbh,
922 size_t *psize)
923 {
924 union ep_buffer_info *info = epbh->info;
925 struct esmem_frame *ring_frame;
926 void *frame;
927
928 ring_frame = (struct esmem_frame *)&(epbh->ring[EP_RING_INDEX
929 (info->v1i.head,
930 info->v1i.count_max) *
931 info->v1i.frame_max]);
932
933 *psize = (size_t)ring_frame->frame_size;
934
935 frame = ring_frame->frame_data;
936
937 return frame;
938 }
939
940 void fjes_hw_epbuf_rx_curpkt_drop(struct epbuf_handler *epbh)
941 {
942 union ep_buffer_info *info = epbh->info;
943
944 if (fjes_hw_epbuf_rx_is_empty(epbh))
945 return;
946
947 EP_RING_INDEX_INC(epbh->info->v1i.head, info->v1i.count_max);
948 }
949
950 int fjes_hw_epbuf_tx_pkt_send(struct epbuf_handler *epbh,
951 void *frame, size_t size)
952 {
953 union ep_buffer_info *info = epbh->info;
954 struct esmem_frame *ring_frame;
955
956 if (EP_RING_FULL(info->v1i.head, info->v1i.tail, info->v1i.count_max))
957 return -ENOBUFS;
958
959 ring_frame = (struct esmem_frame *)&(epbh->ring[EP_RING_INDEX
960 (info->v1i.tail - 1,
961 info->v1i.count_max) *
962 info->v1i.frame_max]);
963
964 ring_frame->frame_size = size;
965 memcpy((void *)(ring_frame->frame_data), (void *)frame, size);
966
967 EP_RING_INDEX_INC(epbh->info->v1i.tail, info->v1i.count_max);
968
969 return 0;
970 }
971
972 static void fjes_hw_update_zone_task(struct work_struct *work)
973 {
974 struct fjes_hw *hw = container_of(work,
975 struct fjes_hw, update_zone_task);
976
977 struct my_s {u8 es_status; u8 zone; } *info;
978 union fjes_device_command_res *res_buf;
979 enum ep_partner_status pstatus;
980
981 struct fjes_adapter *adapter;
982 struct net_device *netdev;
983 unsigned long flags;
984
985 ulong unshare_bit = 0;
986 ulong share_bit = 0;
987 ulong irq_bit = 0;
988
989 int epidx;
990 int ret;
991
992 adapter = (struct fjes_adapter *)hw->back;
993 netdev = adapter->netdev;
994 res_buf = hw->hw_info.res_buf;
995 info = (struct my_s *)&res_buf->info.info;
996
997 mutex_lock(&hw->hw_info.lock);
998
999 ret = fjes_hw_request_info(hw);
1000 switch (ret) {
1001 case -ENOMSG:
1002 case -EBUSY:
1003 default:
1004 if (!work_pending(&adapter->force_close_task)) {
1005 adapter->force_reset = true;
1006 schedule_work(&adapter->force_close_task);
1007 }
1008 break;
1009
1010 case 0:
1011
1012 for (epidx = 0; epidx < hw->max_epid; epidx++) {
1013 if (epidx == hw->my_epid) {
1014 hw->ep_shm_info[epidx].es_status =
1015 info[epidx].es_status;
1016 hw->ep_shm_info[epidx].zone =
1017 info[epidx].zone;
1018 continue;
1019 }
1020
1021 pstatus = fjes_hw_get_partner_ep_status(hw, epidx);
1022 switch (pstatus) {
1023 case EP_PARTNER_UNSHARE:
1024 default:
1025 if ((info[epidx].zone !=
1026 FJES_ZONING_ZONE_TYPE_NONE) &&
1027 (info[epidx].es_status ==
1028 FJES_ZONING_STATUS_ENABLE) &&
1029 (info[epidx].zone ==
1030 info[hw->my_epid].zone))
1031 set_bit(epidx, &share_bit);
1032 else
1033 set_bit(epidx, &unshare_bit);
1034 break;
1035
1036 case EP_PARTNER_COMPLETE:
1037 case EP_PARTNER_WAITING:
1038 if ((info[epidx].zone ==
1039 FJES_ZONING_ZONE_TYPE_NONE) ||
1040 (info[epidx].es_status !=
1041 FJES_ZONING_STATUS_ENABLE) ||
1042 (info[epidx].zone !=
1043 info[hw->my_epid].zone)) {
1044 set_bit(epidx,
1045 &adapter->unshare_watch_bitmask);
1046 set_bit(epidx,
1047 &hw->hw_info.buffer_unshare_reserve_bit);
1048 }
1049 break;
1050
1051 case EP_PARTNER_SHARED:
1052 if ((info[epidx].zone ==
1053 FJES_ZONING_ZONE_TYPE_NONE) ||
1054 (info[epidx].es_status !=
1055 FJES_ZONING_STATUS_ENABLE) ||
1056 (info[epidx].zone !=
1057 info[hw->my_epid].zone))
1058 set_bit(epidx, &irq_bit);
1059 break;
1060 }
1061
1062 hw->ep_shm_info[epidx].es_status =
1063 info[epidx].es_status;
1064 hw->ep_shm_info[epidx].zone = info[epidx].zone;
1065 }
1066 break;
1067 }
1068
1069 mutex_unlock(&hw->hw_info.lock);
1070
1071 for (epidx = 0; epidx < hw->max_epid; epidx++) {
1072 if (epidx == hw->my_epid)
1073 continue;
1074
1075 if (test_bit(epidx, &share_bit)) {
1076 spin_lock_irqsave(&hw->rx_status_lock, flags);
1077 fjes_hw_setup_epbuf(&hw->ep_shm_info[epidx].tx,
1078 netdev->dev_addr, netdev->mtu);
1079 spin_unlock_irqrestore(&hw->rx_status_lock, flags);
1080
1081 mutex_lock(&hw->hw_info.lock);
1082
1083 ret = fjes_hw_register_buff_addr(
1084 hw, epidx, &hw->ep_shm_info[epidx]);
1085
1086 switch (ret) {
1087 case 0:
1088 break;
1089 case -ENOMSG:
1090 case -EBUSY:
1091 default:
1092 if (!work_pending(&adapter->force_close_task)) {
1093 adapter->force_reset = true;
1094 schedule_work(
1095 &adapter->force_close_task);
1096 }
1097 break;
1098 }
1099 mutex_unlock(&hw->hw_info.lock);
1100
1101 hw->ep_shm_info[epidx].ep_stats
1102 .com_regist_buf_exec += 1;
1103 }
1104
1105 if (test_bit(epidx, &unshare_bit)) {
1106 mutex_lock(&hw->hw_info.lock);
1107
1108 ret = fjes_hw_unregister_buff_addr(hw, epidx);
1109
1110 switch (ret) {
1111 case 0:
1112 break;
1113 case -ENOMSG:
1114 case -EBUSY:
1115 default:
1116 if (!work_pending(&adapter->force_close_task)) {
1117 adapter->force_reset = true;
1118 schedule_work(
1119 &adapter->force_close_task);
1120 }
1121 break;
1122 }
1123
1124 mutex_unlock(&hw->hw_info.lock);
1125
1126 hw->ep_shm_info[epidx].ep_stats
1127 .com_unregist_buf_exec += 1;
1128
1129 if (ret == 0) {
1130 spin_lock_irqsave(&hw->rx_status_lock, flags);
1131 fjes_hw_setup_epbuf(
1132 &hw->ep_shm_info[epidx].tx,
1133 netdev->dev_addr, netdev->mtu);
1134 spin_unlock_irqrestore(&hw->rx_status_lock,
1135 flags);
1136 }
1137 }
1138
1139 if (test_bit(epidx, &irq_bit)) {
1140 fjes_hw_raise_interrupt(hw, epidx,
1141 REG_ICTL_MASK_TXRX_STOP_REQ);
1142
1143 hw->ep_shm_info[epidx].ep_stats.send_intr_unshare += 1;
1144
1145 set_bit(epidx, &hw->txrx_stop_req_bit);
1146 spin_lock_irqsave(&hw->rx_status_lock, flags);
1147 hw->ep_shm_info[epidx].tx.
1148 info->v1i.rx_status |=
1149 FJES_RX_STOP_REQ_REQUEST;
1150 spin_unlock_irqrestore(&hw->rx_status_lock, flags);
1151 set_bit(epidx, &hw->hw_info.buffer_unshare_reserve_bit);
1152 }
1153 }
1154
1155 if (irq_bit || adapter->unshare_watch_bitmask) {
1156 if (!work_pending(&adapter->unshare_watch_task))
1157 queue_work(adapter->control_wq,
1158 &adapter->unshare_watch_task);
1159 }
1160 }
1161
1162 static void fjes_hw_epstop_task(struct work_struct *work)
1163 {
1164 struct fjes_hw *hw = container_of(work, struct fjes_hw, epstop_task);
1165 struct fjes_adapter *adapter = (struct fjes_adapter *)hw->back;
1166 unsigned long flags;
1167
1168 ulong remain_bit;
1169 int epid_bit;
1170
1171 while ((remain_bit = hw->epstop_req_bit)) {
1172 for (epid_bit = 0; remain_bit; remain_bit >>= 1, epid_bit++) {
1173 if (remain_bit & 1) {
1174 spin_lock_irqsave(&hw->rx_status_lock, flags);
1175 hw->ep_shm_info[epid_bit].
1176 tx.info->v1i.rx_status |=
1177 FJES_RX_STOP_REQ_DONE;
1178 spin_unlock_irqrestore(&hw->rx_status_lock,
1179 flags);
1180
1181 clear_bit(epid_bit, &hw->epstop_req_bit);
1182 set_bit(epid_bit,
1183 &adapter->unshare_watch_bitmask);
1184
1185 if (!work_pending(&adapter->unshare_watch_task))
1186 queue_work(
1187 adapter->control_wq,
1188 &adapter->unshare_watch_task);
1189 }
1190 }
1191 }
1192 }
1193
1194 int fjes_hw_start_debug(struct fjes_hw *hw)
1195 {
1196 union fjes_device_command_req *req_buf = hw->hw_info.req_buf;
1197 union fjes_device_command_res *res_buf = hw->hw_info.res_buf;
1198 enum fjes_dev_command_response_e ret;
1199 int page_count;
1200 int result = 0;
1201 void *addr;
1202 int i;
1203
1204 if (!hw->hw_info.trace)
1205 return -EPERM;
1206 memset(hw->hw_info.trace, 0, FJES_DEBUG_BUFFER_SIZE);
1207
1208 memset(req_buf, 0, hw->hw_info.req_buf_size);
1209 memset(res_buf, 0, hw->hw_info.res_buf_size);
1210
1211 req_buf->start_trace.length =
1212 FJES_DEV_COMMAND_START_DBG_REQ_LEN(hw->hw_info.trace_size);
1213 req_buf->start_trace.mode = hw->debug_mode;
1214 req_buf->start_trace.buffer_len = hw->hw_info.trace_size;
1215 page_count = hw->hw_info.trace_size / FJES_DEBUG_PAGE_SIZE;
1216 for (i = 0; i < page_count; i++) {
1217 addr = ((u8 *)hw->hw_info.trace) + i * FJES_DEBUG_PAGE_SIZE;
1218 req_buf->start_trace.buffer[i] =
1219 (__le64)(page_to_phys(vmalloc_to_page(addr)) +
1220 offset_in_page(addr));
1221 }
1222
1223 res_buf->start_trace.length = 0;
1224 res_buf->start_trace.code = 0;
1225
1226 trace_fjes_hw_start_debug_req(req_buf);
1227 ret = fjes_hw_issue_request_command(hw, FJES_CMD_REQ_START_DEBUG);
1228 trace_fjes_hw_start_debug(res_buf);
1229
1230 if (res_buf->start_trace.length !=
1231 FJES_DEV_COMMAND_START_DBG_RES_LEN) {
1232 result = -ENOMSG;
1233 trace_fjes_hw_start_debug_err("Invalid res_buf");
1234 } else if (ret == FJES_CMD_STATUS_NORMAL) {
1235 switch (res_buf->start_trace.code) {
1236 case FJES_CMD_REQ_RES_CODE_NORMAL:
1237 result = 0;
1238 break;
1239 default:
1240 result = -EPERM;
1241 break;
1242 }
1243 } else {
1244 switch (ret) {
1245 case FJES_CMD_STATUS_UNKNOWN:
1246 result = -EPERM;
1247 break;
1248 case FJES_CMD_STATUS_TIMEOUT:
1249 trace_fjes_hw_start_debug_err("Busy Timeout");
1250 result = -EBUSY;
1251 break;
1252 case FJES_CMD_STATUS_ERROR_PARAM:
1253 case FJES_CMD_STATUS_ERROR_STATUS:
1254 default:
1255 result = -EPERM;
1256 break;
1257 }
1258 }
1259
1260 return result;
1261 }
1262
1263 int fjes_hw_stop_debug(struct fjes_hw *hw)
1264 {
1265 union fjes_device_command_req *req_buf = hw->hw_info.req_buf;
1266 union fjes_device_command_res *res_buf = hw->hw_info.res_buf;
1267 enum fjes_dev_command_response_e ret;
1268 int result = 0;
1269
1270 if (!hw->hw_info.trace)
1271 return -EPERM;
1272
1273 memset(req_buf, 0, hw->hw_info.req_buf_size);
1274 memset(res_buf, 0, hw->hw_info.res_buf_size);
1275 req_buf->stop_trace.length = FJES_DEV_COMMAND_STOP_DBG_REQ_LEN;
1276
1277 res_buf->stop_trace.length = 0;
1278 res_buf->stop_trace.code = 0;
1279
1280 ret = fjes_hw_issue_request_command(hw, FJES_CMD_REQ_STOP_DEBUG);
1281 trace_fjes_hw_stop_debug(res_buf);
1282
1283 if (res_buf->stop_trace.length != FJES_DEV_COMMAND_STOP_DBG_RES_LEN) {
1284 trace_fjes_hw_stop_debug_err("Invalid res_buf");
1285 result = -ENOMSG;
1286 } else if (ret == FJES_CMD_STATUS_NORMAL) {
1287 switch (res_buf->stop_trace.code) {
1288 case FJES_CMD_REQ_RES_CODE_NORMAL:
1289 result = 0;
1290 hw->debug_mode = 0;
1291 break;
1292 default:
1293 result = -EPERM;
1294 break;
1295 }
1296 } else {
1297 switch (ret) {
1298 case FJES_CMD_STATUS_UNKNOWN:
1299 result = -EPERM;
1300 break;
1301 case FJES_CMD_STATUS_TIMEOUT:
1302 result = -EBUSY;
1303 trace_fjes_hw_stop_debug_err("Busy Timeout");
1304 break;
1305 case FJES_CMD_STATUS_ERROR_PARAM:
1306 case FJES_CMD_STATUS_ERROR_STATUS:
1307 default:
1308 result = -EPERM;
1309 break;
1310 }
1311 }
1312
1313 return result;
1314 }
Linux with added FPC-III support