projects / openwrt / openwrt.git / blob
? search:


e0e734d61edac3845d7c01e194c75528532962fc
[openwrt/openwrt.git] / target / linux / mediatek / files-5.10 / drivers / net / phy / rtk / rtl8367c / rtl8367c_asicdrv_igmp.c
1 /*
2 * Copyright (C) 2013 Realtek Semiconductor Corp.
3 * All Rights Reserved.
4 *
5 * Unless you and Realtek execute a separate written software license
6 * agreement governing use of this software, this software is licensed
7 * to you under the terms of the GNU General Public License version 2,
8 * available at https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
9 *
10 * $Revision: 76306 $
11 * $Date: 2017-03-08 15:13:58 +0800 (週三, 08 三月 2017) $
12 *
13 * Purpose : RTL8367C switch high-level API for RTL8367C
14 * Feature : IGMP related functions
15 *
16 */
17 #include <rtl8367c_asicdrv_igmp.h>
18 /* Function Name:
19 * rtl8367c_setAsicIgmp
20 * Description:
21 * Set IGMP/MLD state
22 * Input:
23 * enabled - 1: enabled, 0: disabled
24 * Output:
25 * None
26 * Return:
27 * RT_ERR_OK - Success
28 * RT_ERR_SMI - SMI access error
29 * Note:
30 * None
31 */
32 ret_t rtl8367c_setAsicIgmp(rtk_uint32 enabled)
33 {
34 ret_t retVal;
35
36 /* Enable/Disable H/W IGMP/MLD */
37 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_EN_OFFSET, enabled);
38
39 return retVal;
40 }
41 /* Function Name:
42 * rtl8367c_getAsicIgmp
43 * Description:
44 * Get IGMP/MLD state
45 * Input:
46 * enabled - 1: enabled, 0: disabled
47 * Output:
48 * None
49 * Return:
50 * RT_ERR_OK - Success
51 * RT_ERR_SMI - SMI access error
52 * Note:
53 * None
54 */
55 ret_t rtl8367c_getAsicIgmp(rtk_uint32 *ptr_enabled)
56 {
57 ret_t retVal;
58
59 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_EN_OFFSET, ptr_enabled);
60 return retVal;
61 }
62 /* Function Name:
63 * rtl8367c_setAsicIpMulticastVlanLeaky
64 * Description:
65 * Set IP multicast VLAN Leaky function
66 * Input:
67 * port - Physical port number (0~7)
68 * enabled - 1: enabled, 0: disabled
69 * Output:
70 * None
71 * Return:
72 * RT_ERR_OK - Success
73 * RT_ERR_SMI - SMI access error
74 * RT_ERR_PORT_ID - Invalid port number
75 * Note:
76 * When enabling this function,
77 * if the lookup result(forwarding portmap) of IP Multicast packet is over VLAN boundary,
78 * the packet can be forwarded across VLAN
79 */
80 ret_t rtl8367c_setAsicIpMulticastVlanLeaky(rtk_uint32 port, rtk_uint32 enabled)
81 {
82 ret_t retVal;
83
84 if(port > RTL8367C_PORTIDMAX)
85 return RT_ERR_PORT_ID;
86
87 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IPMCAST_VLAN_LEAKY, port, enabled);
88
89 return retVal;
90 }
91 /* Function Name:
92 * rtl8367c_getAsicIpMulticastVlanLeaky
93 * Description:
94 * Get IP multicast VLAN Leaky function
95 * Input:
96 * port - Physical port number (0~7)
97 * enabled - 1: enabled, 0: disabled
98 * Output:
99 * None
100 * Return:
101 * RT_ERR_OK - Success
102 * RT_ERR_SMI - SMI access error
103 * RT_ERR_PORT_ID - Invalid port number
104 * Note:
105 * None
106 */
107 ret_t rtl8367c_getAsicIpMulticastVlanLeaky(rtk_uint32 port, rtk_uint32 *ptr_enabled)
108 {
109 ret_t retVal;
110
111 if(port > RTL8367C_PORTIDMAX)
112 return RT_ERR_PORT_ID;
113
114 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IPMCAST_VLAN_LEAKY, port, ptr_enabled);
115
116 return retVal;
117 }
118
119 /* Function Name:
120 * rtl8367c_setAsicIGMPTableFullOP
121 * Description:
122 * Set Table Full operation
123 * Input:
124 * operation - The operation should be taken when the IGMP table is full.
125 * Output:
126 * None
127 * Return:
128 * RT_ERR_OK - Success
129 * RT_ERR_SMI - SMI access error
130 * RT_ERR_OUT_OF_RANGE - input parameter is out of range
131 * Note:
132 * None
133 */
134 ret_t rtl8367c_setAsicIGMPTableFullOP(rtk_uint32 operation)
135 {
136 ret_t retVal;
137
138 if(operation >= TABLE_FULL_OP_END)
139 return RT_ERR_OUT_OF_RANGE;
140
141 /* Table full Operation */
142 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG1, RTL8367C_TABLE_FULL_OP_MASK, operation);
143 if(retVal != RT_ERR_OK)
144 return retVal;
145
146 return RT_ERR_OK;
147 }
148
149 /* Function Name:
150 * rtl8367c_getAsicIGMPTableFullOP
151 * Description:
152 * Get Table Full operation
153 * Input:
154 * None
155 * Output:
156 * poperation - The operation should be taken when the IGMP table is full.
157 * Return:
158 * RT_ERR_OK - Success
159 * RT_ERR_SMI - SMI access error
160 * Note:
161 * None
162 */
163 ret_t rtl8367c_getAsicIGMPTableFullOP(rtk_uint32 *poperation)
164 {
165 ret_t retVal;
166 rtk_uint32 value;
167
168 /* Table full Operation */
169 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG1, RTL8367C_TABLE_FULL_OP_MASK, &value);
170 if(retVal != RT_ERR_OK)
171 return retVal;
172
173 *poperation = value;
174
175 return RT_ERR_OK;
176 }
177
178 /* Function Name:
179 * rtl8367c_setAsicIGMPCRCErrOP
180 * Description:
181 * Set the operation when ASIC receive a Checksum error packet
182 * Input:
183 * operation -The operation when ASIC receive a Checksum error packet
184 * Output:
185 * None
186 * Return:
187 * RT_ERR_OK - Success
188 * RT_ERR_SMI - SMI access error
189 * RT_ERR_OUT_OF_RANGE - input parameter is out of range
190 * Note:
191 * None
192 */
193 ret_t rtl8367c_setAsicIGMPCRCErrOP(rtk_uint32 operation)
194 {
195 ret_t retVal;
196
197 if(operation >= CRC_ERR_OP_END)
198 return RT_ERR_OUT_OF_RANGE;
199
200 /* CRC Error Operation */
201 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_CKS_ERR_OP_MASK, operation);
202 if(retVal != RT_ERR_OK)
203 return retVal;
204
205 return RT_ERR_OK;
206 }
207
208 /* Function Name:
209 * rtl8367c_getAsicIGMPCRCErrOP
210 * Description:
211 * Get the operation when ASIC receive a Checksum error packet
212 * Input:
213 * None
214 * Output:
215 * poperation - The operation of Checksum error packet
216 * Return:
217 * RT_ERR_OK - Success
218 * RT_ERR_SMI - SMI access error
219 * Note:
220 * None
221 */
222 ret_t rtl8367c_getAsicIGMPCRCErrOP(rtk_uint32 *poperation)
223 {
224 ret_t retVal;
225 rtk_uint32 value;
226
227 /* CRC Error Operation */
228 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_CKS_ERR_OP_MASK, &value);
229 if(retVal != RT_ERR_OK)
230 return retVal;
231
232 *poperation = value;
233
234 return RT_ERR_OK;
235 }
236
237 /* Function Name:
238 * rtl8367c_setAsicIGMPFastLeaveEn
239 * Description:
240 * Enable/Disable Fast Leave
241 * Input:
242 * enabled - 1:enable Fast Leave; 0:disable Fast Leave
243 * Output:
244 * None
245 * Return:
246 * RT_ERR_OK - Success
247 * RT_ERR_SMI - SMI access error
248 * Note:
249 * None
250 */
251 ret_t rtl8367c_setAsicIGMPFastLeaveEn(rtk_uint32 enabled)
252 {
253 ret_t retVal;
254
255 /* Fast Leave */
256 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_FAST_LEAVE_EN_MASK, (enabled >= 1) ? 1 : 0);
257 if(retVal != RT_ERR_OK)
258 return retVal;
259
260 return RT_ERR_OK;
261 }
262
263 /* Function Name:
264 * rtl8367c_getAsicIGMPFastLeaveEn
265 * Description:
266 * Get Fast Leave state
267 * Input:
268 * None
269 * Output:
270 * penabled - 1:enable Fast Leave; 0:disable Fast Leave
271 * Return:
272 * RT_ERR_OK - Success
273 * RT_ERR_SMI - SMI access error
274 * Note:
275 * None
276 */
277 ret_t rtl8367c_getAsicIGMPFastLeaveEn(rtk_uint32 *penabled)
278 {
279 ret_t retVal;
280 rtk_uint32 value;
281
282 /* Fast Leave */
283 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_FAST_LEAVE_EN_MASK, &value);
284 if(retVal != RT_ERR_OK)
285 return retVal;
286
287 *penabled = value;
288
289 return RT_ERR_OK;
290 }
291
292 /* Function Name:
293 * rtl8367c_setAsicIGMPLeaveTimer
294 * Description:
295 * Set the Leave timer of IGMP/MLD
296 * Input:
297 * leave_timer - Leave timer
298 * Output:
299 * None
300 * Return:
301 * RT_ERR_OK - Success
302 * RT_ERR_SMI - SMI access error
303 * RT_ERR_OUT_OF_RANGE - input parameter is out of range
304 * Note:
305 * None
306 */
307 ret_t rtl8367c_setAsicIGMPLeaveTimer(rtk_uint32 leave_timer)
308 {
309 ret_t retVal;
310
311 if(leave_timer > RTL8367C_MAX_LEAVE_TIMER)
312 return RT_ERR_OUT_OF_RANGE;
313
314 /* Leave timer */
315 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_LEAVE_TIMER_MASK, leave_timer);
316 if(retVal != RT_ERR_OK)
317 return retVal;
318
319 return RT_ERR_OK;
320 }
321
322 /* Function Name:
323 * rtl8367c_getAsicIGMPLeaveTimer
324 * Description:
325 * Get the Leave timer of IGMP/MLD
326 * Input:
327 * None
328 * Output:
329 * pleave_timer - Leave timer
330 * Return:
331 * RT_ERR_OK - Success
332 * RT_ERR_SMI - SMI access error
333 * Note:
334 * None
335 */
336 ret_t rtl8367c_getAsicIGMPLeaveTimer(rtk_uint32 *pleave_timer)
337 {
338 ret_t retVal;
339 rtk_uint32 value;
340
341 /* Leave timer */
342 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_LEAVE_TIMER_MASK, &value);
343 if(retVal != RT_ERR_OK)
344 return retVal;
345
346 *pleave_timer = value;
347
348 return RT_ERR_OK;
349 }
350
351 /* Function Name:
352 * rtl8367c_setAsicIGMPQueryInterval
353 * Description:
354 * Set Query Interval of IGMP/MLD
355 * Input:
356 * interval - Query Interval
357 * Output:
358 * None
359 * Return:
360 * RT_ERR_OK - Success
361 * RT_ERR_SMI - SMI access error
362 * RT_ERR_OUT_OF_RANGE - input parameter is out of range
363 * Note:
364 * None
365 */
366 ret_t rtl8367c_setAsicIGMPQueryInterval(rtk_uint32 interval)
367 {
368 ret_t retVal;
369
370 if(interval > RTL8367C_MAX_QUERY_INT)
371 return RT_ERR_OUT_OF_RANGE;
372
373 /* Query Interval */
374 retVal = rtl8367c_setAsicReg(RTL8367C_REG_IGMP_MLD_CFG2, interval);
375 if(retVal != RT_ERR_OK)
376 return retVal;
377
378 return RT_ERR_OK;
379 }
380
381 /* Function Name:
382 * rtl8367c_getAsicIGMPQueryInterval
383 * Description:
384 * Get Query Interval of IGMP/MLD
385 * Input:
386 * None
387 * Output:
388 * pinterval - Query Interval
389 * Return:
390 * RT_ERR_OK - Success
391 * RT_ERR_SMI - SMI access error
392 * Note:
393 * None
394 */
395 ret_t rtl8367c_getAsicIGMPQueryInterval(rtk_uint32 *pinterval)
396 {
397 ret_t retVal;
398 rtk_uint32 value;
399
400 /* Query Interval */
401 retVal = rtl8367c_getAsicReg(RTL8367C_REG_IGMP_MLD_CFG2, &value);
402 if(retVal != RT_ERR_OK)
403 return retVal;
404
405 *pinterval = value;
406
407 return RT_ERR_OK;
408 }
409
410 /* Function Name:
411 * rtl8367c_setAsicIGMPRobVar
412 * Description:
413 * Set Robustness Variable of IGMP/MLD
414 * Input:
415 * rob_var - Robustness Variable
416 * Output:
417 * None
418 * Return:
419 * RT_ERR_OK - Success
420 * RT_ERR_SMI - SMI access error
421 * RT_ERR_OUT_OF_RANGE - input parameter is out of range
422 * Note:
423 * None
424 */
425 ret_t rtl8367c_setAsicIGMPRobVar(rtk_uint32 rob_var)
426 {
427 ret_t retVal;
428
429 if(rob_var > RTL8367C_MAX_ROB_VAR)
430 return RT_ERR_OUT_OF_RANGE;
431
432 /* Bourstness variable */
433 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_ROBURSTNESS_VAR_MASK, rob_var);
434 if(retVal != RT_ERR_OK)
435 return retVal;
436
437 return RT_ERR_OK;
438 }
439
440 /* Function Name:
441 * rtl8367c_getAsicIGMPRobVar
442 * Description:
443 * Get Robustness Variable of IGMP/MLD
444 * Input:
445 * none
446 * Output:
447 * prob_var - Robustness Variable
448 * Return:
449 * RT_ERR_OK - Success
450 * RT_ERR_SMI - SMI access error
451 * Note:
452 * None
453 */
454 ret_t rtl8367c_getAsicIGMPRobVar(rtk_uint32 *prob_var)
455 {
456 ret_t retVal;
457 rtk_uint32 value;
458
459 /* Bourstness variable */
460 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_ROBURSTNESS_VAR_MASK, &value);
461 if(retVal != RT_ERR_OK)
462 return retVal;
463
464 *prob_var = value;
465
466 return RT_ERR_OK;
467 }
468
469 /* Function Name:
470 * rtl8367c_setAsicIGMPStaticRouterPort
471 * Description:
472 * Set IGMP static router port mask
473 * Input:
474 * pmsk - Static portmask
475 * Output:
476 * None
477 * Return:
478 * RT_ERR_OK - Success
479 * RT_ERR_SMI - SMI access error
480 * RT_ERR_PORT_MASK - Invalid port mask
481 * Note:
482 * None
483 */
484 ret_t rtl8367c_setAsicIGMPStaticRouterPort(rtk_uint32 pmsk)
485 {
486 if(pmsk > RTL8367C_PORTMASK)
487 return RT_ERR_PORT_MASK;
488
489 return rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_STATIC_ROUTER_PORT, RTL8367C_IGMP_STATIC_ROUTER_PORT_MASK, pmsk);
490 }
491
492 /* Function Name:
493 * rtl8367c_getAsicIGMPStaticRouterPort
494 * Description:
495 * Get IGMP static router port mask
496 * Input:
497 * pmsk - Static portmask
498 * Output:
499 * None
500 * Return:
501 * RT_ERR_OK - Success
502 * RT_ERR_SMI - SMI access error
503 * Note:
504 * None
505 */
506 ret_t rtl8367c_getAsicIGMPStaticRouterPort(rtk_uint32 *pmsk)
507 {
508 return rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_STATIC_ROUTER_PORT, RTL8367C_IGMP_STATIC_ROUTER_PORT_MASK, pmsk);
509 }
510
511 /* Function Name:
512 * rtl8367c_setAsicIGMPAllowDynamicRouterPort
513 * Description:
514 * Set IGMP dynamic router port allow mask
515 * Input:
516 * pmsk - Allow dynamic router port mask
517 * Output:
518 * None
519 * Return:
520 * RT_ERR_OK - Success
521 * RT_ERR_SMI - SMI access error
522 * RT_ERR_PORT_MASK - Invalid port mask
523 * Note:
524 * None
525 */
526 ret_t rtl8367c_setAsicIGMPAllowDynamicRouterPort(rtk_uint32 pmsk)
527 {
528 return rtl8367c_setAsicReg(RTL8367C_REG_IGMP_MLD_CFG4, pmsk);
529 }
530
531 /* Function Name:
532 * rtl8367c_getAsicIGMPAllowDynamicRouterPort
533 * Description:
534 * Get IGMP dynamic router port allow mask
535 * Input:
536 * None.
537 * Output:
538 * pPmsk - Allow dynamic router port mask
539 * Return:
540 * RT_ERR_OK - Success
541 * RT_ERR_SMI - SMI access error
542 * RT_ERR_PORT_MASK - Invalid port mask
543 * Note:
544 * None
545 */
546 ret_t rtl8367c_getAsicIGMPAllowDynamicRouterPort(rtk_uint32 *pPmsk)
547 {
548 return rtl8367c_getAsicReg(RTL8367C_REG_IGMP_MLD_CFG4, pPmsk);
549 }
550
551 /* Function Name:
552 * rtl8367c_getAsicIGMPdynamicRouterPort1
553 * Description:
554 * Get 1st dynamic router port and timer
555 * Input:
556 * port - Physical port number (0~7)
557 * timer - router port timer
558 * Output:
559 * None
560 * Return:
561 * RT_ERR_OK - Success
562 * RT_ERR_SMI - SMI access error
563 * Note:
564 * None
565 */
566 ret_t rtl8367c_getAsicIGMPdynamicRouterPort1(rtk_uint32 *port, rtk_uint32 *timer)
567 {
568 ret_t retVal;
569
570 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_DYNAMIC_ROUTER_PORT, RTL8367C_D_ROUTER_PORT_1_MASK, port);
571 if(retVal != RT_ERR_OK)
572 return retVal;
573
574 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_DYNAMIC_ROUTER_PORT, RTL8367C_D_ROUTER_PORT_TMR_1_MASK, timer);
575 if(retVal != RT_ERR_OK)
576 return retVal;
577
578 return RT_ERR_OK;
579 }
580
581 /* Function Name:
582 * rtl8367c_getAsicIGMPdynamicRouterPort2
583 * Description:
584 * Get 2nd dynamic router port and timer
585 * Input:
586 * port - Physical port number (0~7)
587 * timer - router port timer
588 * Output:
589 * None
590 * Return:
591 * RT_ERR_OK - Success
592 * RT_ERR_SMI - SMI access error
593 * Note:
594 * None
595 */
596 ret_t rtl8367c_getAsicIGMPdynamicRouterPort2(rtk_uint32 *port, rtk_uint32 *timer)
597 {
598 ret_t retVal;
599
600 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_DYNAMIC_ROUTER_PORT, RTL8367C_D_ROUTER_PORT_2_MASK, port);
601 if(retVal != RT_ERR_OK)
602 return retVal;
603
604 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_DYNAMIC_ROUTER_PORT, RTL8367C_D_ROUTER_PORT_TMR_2_MASK, timer);
605 if(retVal != RT_ERR_OK)
606 return retVal;
607
608 return RT_ERR_OK;
609 }
610
611 /* Function Name:
612 * rtl8367c_setAsicIGMPSuppression
613 * Description:
614 * Set the suppression function
615 * Input:
616 * report_supp_enabled - Report suppression, 1:Enable, 0:disable
617 * leave_supp_enabled - Leave suppression, 1:Enable, 0:disable
618 * Output:
619 * None
620 * Return:
621 * RT_ERR_OK - Success
622 * RT_ERR_SMI - SMI access error
623 * Note:
624 * None
625 */
626 ret_t rtl8367c_setAsicIGMPSuppression(rtk_uint32 report_supp_enabled, rtk_uint32 leave_supp_enabled)
627 {
628 ret_t retVal;
629
630 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_REPORT_SUPPRESSION_MASK, report_supp_enabled);
631 if(retVal != RT_ERR_OK)
632 return retVal;
633
634 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_LEAVE_SUPPRESSION_MASK, leave_supp_enabled);
635 if(retVal != RT_ERR_OK)
636 return retVal;
637
638 return RT_ERR_OK;
639 }
640
641 /* Function Name:
642 * rtl8367c_getAsicIGMPSuppression
643 * Description:
644 * Get the suppression function
645 * Input:
646 * report_supp_enabled - Report suppression, 1:Enable, 0:disable
647 * leave_supp_enabled - Leave suppression, 1:Enable, 0:disable
648 * Output:
649 * None
650 * Return:
651 * RT_ERR_OK - Success
652 * RT_ERR_SMI - SMI access error
653 * Note:
654 * None
655 */
656 ret_t rtl8367c_getAsicIGMPSuppression(rtk_uint32 *report_supp_enabled, rtk_uint32 *leave_supp_enabled)
657 {
658 ret_t retVal;
659
660 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_REPORT_SUPPRESSION_MASK, report_supp_enabled);
661 if(retVal != RT_ERR_OK)
662 return retVal;
663
664 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_LEAVE_SUPPRESSION_MASK, leave_supp_enabled);
665 if(retVal != RT_ERR_OK)
666 return retVal;
667
668 return RT_ERR_OK;
669 }
670
671 /* Function Name:
672 * rtl8367c_setAsicIGMPQueryRX
673 * Description:
674 * Set port-based Query packet RX allowance
675 * Input:
676 * port - port number
677 * allow_query - allowance of Query packet RX, 1:Allow, 0:Drop
678 * Output:
679 * None
680 * Return:
681 * RT_ERR_OK - Success
682 * RT_ERR_PORT_ID - Error PORT ID
683 * RT_ERR_SMI - SMI access error
684 * Note:
685 * None
686 */
687 ret_t rtl8367c_setAsicIGMPQueryRX(rtk_uint32 port, rtk_uint32 allow_query)
688 {
689 ret_t retVal;
690
691 if(port > RTL8367C_PORTIDMAX)
692 return RT_ERR_PORT_ID;
693
694 /* Allow Query */
695 if (port < 8)
696 {
697 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_QUERY_MASK, allow_query);
698 if(retVal != RT_ERR_OK)
699 return retVal;
700 }
701 else
702 {
703 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_QUERY_MASK, allow_query);
704 if(retVal != RT_ERR_OK)
705 return retVal;
706 }
707
708 return RT_ERR_OK;
709 }
710
711 /* Function Name:
712 * rtl8367c_getAsicIGMPQueryRX
713 * Description:
714 * Get port-based Query packet RX allowance
715 * Input:
716 * port - port number
717 * Output:
718 * allow_query - allowance of Query packet RX, 1:Allow, 0:Drop
719 * Return:
720 * RT_ERR_OK - Success
721 * RT_ERR_PORT_ID - Error PORT ID
722 * RT_ERR_SMI - SMI access error
723 * Note:
724 * None
725 */
726 ret_t rtl8367c_getAsicIGMPQueryRX(rtk_uint32 port, rtk_uint32 *allow_query)
727 {
728 ret_t retVal;
729 rtk_uint32 value;
730
731 if(port > RTL8367C_PORTIDMAX)
732 return RT_ERR_PORT_ID;
733
734 /* Allow Query */
735 if (port < 8)
736 {
737 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_QUERY_MASK, &value);
738 if(retVal != RT_ERR_OK)
739 return retVal;
740 }
741 else
742 {
743 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_QUERY_MASK, &value);
744 if(retVal != RT_ERR_OK)
745 return retVal;
746 }
747 *allow_query = value;
748
749 return RT_ERR_OK;
750 }
751
752 /* Function Name:
753 * rtl8367c_setAsicIGMPReportRX
754 * Description:
755 * Set port-based Report packet RX allowance
756 * Input:
757 * port - port number
758 * allow_report - allowance of Report packet RX, 1:Allow, 0:Drop
759 * Output:
760 * None
761 * Return:
762 * RT_ERR_OK - Success
763 * RT_ERR_PORT_ID - Error PORT ID
764 * RT_ERR_SMI - SMI access error
765 * Note:
766 * None
767 */
768 ret_t rtl8367c_setAsicIGMPReportRX(rtk_uint32 port, rtk_uint32 allow_report)
769 {
770 ret_t retVal;
771
772 if(port > RTL8367C_PORTIDMAX)
773 return RT_ERR_PORT_ID;
774
775 if(port < 8)
776 {
777 /* Allow Report */
778 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_REPORT_MASK, allow_report);
779 if(retVal != RT_ERR_OK)
780 return retVal;
781 }
782 else
783 {
784 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_REPORT_MASK, allow_report);
785 if(retVal != RT_ERR_OK)
786 return retVal;
787 }
788 return RT_ERR_OK;
789 }
790
791 /* Function Name:
792 * rtl8367c_getAsicIGMPReportRX
793 * Description:
794 * Get port-based Report packet RX allowance
795 * Input:
796 * port - port number
797 * Output:
798 * allow_report - allowance of Report packet RX, 1:Allow, 0:Drop
799 * Return:
800 * RT_ERR_OK - Success
801 * RT_ERR_PORT_ID - Error PORT ID
802 * RT_ERR_SMI - SMI access error
803 * Note:
804 * None
805 */
806 ret_t rtl8367c_getAsicIGMPReportRX(rtk_uint32 port, rtk_uint32 *allow_report)
807 {
808 ret_t retVal;
809 rtk_uint32 value;
810
811 if(port > RTL8367C_PORTIDMAX)
812 return RT_ERR_PORT_ID;
813
814 if(port < 8)
815 {
816 /* Allow Report */
817 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_REPORT_MASK, &value);
818 if(retVal != RT_ERR_OK)
819 return retVal;
820 }
821 else
822 {
823 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_REPORT_MASK, &value);
824 if(retVal != RT_ERR_OK)
825 return retVal;
826 }
827 *allow_report = value;
828
829 return RT_ERR_OK;
830 }
831
832 /* Function Name:
833 * rtl8367c_setAsicIGMPLeaveRX
834 * Description:
835 * Set port-based Leave packet RX allowance
836 * Input:
837 * port - port number
838 * allow_leave - allowance of Leave packet RX, 1:Allow, 0:Drop
839 * Output:
840 * None
841 * Return:
842 * RT_ERR_OK - Success
843 * RT_ERR_PORT_ID - Error PORT ID
844 * RT_ERR_SMI - SMI access error
845 * Note:
846 * None
847 */
848 ret_t rtl8367c_setAsicIGMPLeaveRX(rtk_uint32 port, rtk_uint32 allow_leave)
849 {
850 ret_t retVal;
851
852 if(port > RTL8367C_PORTIDMAX)
853 return RT_ERR_PORT_ID;
854
855 if(port < 8)
856 {
857 /* Allow Leave */
858 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_LEAVE_MASK, allow_leave);
859 if(retVal != RT_ERR_OK)
860 return retVal;
861 }
862 else
863 {
864 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_LEAVE_MASK, allow_leave);
865 if(retVal != RT_ERR_OK)
866 return retVal;
867 }
868 return RT_ERR_OK;
869 }
870
871 /* Function Name:
872 * rtl8367c_getAsicIGMPLeaveRX
873 * Description:
874 * Get port-based Leave packet RX allowance
875 * Input:
876 * port - port number
877 * Output:
878 * allow_leave - allowance of Leave packet RX, 1:Allow, 0:Drop
879 * Return:
880 * RT_ERR_OK - Success
881 * RT_ERR_PORT_ID - Error PORT ID
882 * RT_ERR_SMI - SMI access error
883 * Note:
884 * None
885 */
886 ret_t rtl8367c_getAsicIGMPLeaveRX(rtk_uint32 port, rtk_uint32 *allow_leave)
887 {
888 ret_t retVal;
889 rtk_uint32 value;
890
891 if(port > RTL8367C_PORTIDMAX)
892 return RT_ERR_PORT_ID;
893
894 if(port < 8)
895 {
896 /* Allow Leave */
897 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_LEAVE_MASK, &value);
898 if(retVal != RT_ERR_OK)
899 return retVal;
900 }
901 else
902 {
903 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_LEAVE_MASK, &value);
904 if(retVal != RT_ERR_OK)
905 return retVal;
906 }
907
908 *allow_leave = value;
909
910 return RT_ERR_OK;
911 }
912
913 /* Function Name:
914 * rtl8367c_setAsicIGMPMRPRX
915 * Description:
916 * Set port-based Multicast Routing Protocol packet RX allowance
917 * Input:
918 * port - port number
919 * allow_mrp - allowance of Multicast Routing Protocol packet RX, 1:Allow, 0:Drop
920 * Output:
921 * None
922 * Return:
923 * RT_ERR_OK - Success
924 * RT_ERR_PORT_ID - Error PORT ID
925 * RT_ERR_SMI - SMI access error
926 * Note:
927 * None
928 */
929 ret_t rtl8367c_setAsicIGMPMRPRX(rtk_uint32 port, rtk_uint32 allow_mrp)
930 {
931 ret_t retVal;
932
933 if(port > RTL8367C_PORTIDMAX)
934 return RT_ERR_PORT_ID;
935
936 if(port < 8)
937 {
938 /* Allow Multicast Routing Protocol */
939 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MRP_MASK, allow_mrp);
940 if(retVal != RT_ERR_OK)
941 return retVal;
942 }
943 else
944 {
945 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MRP_MASK, allow_mrp);
946 if(retVal != RT_ERR_OK)
947 return retVal;
948 }
949 return RT_ERR_OK;
950 }
951
952 /* Function Name:
953 * rtl8367c_getAsicIGMPMRPRX
954 * Description:
955 * Get port-based Multicast Routing Protocol packet RX allowance
956 * Input:
957 * port - port number
958 * Output:
959 * allow_mrp - allowance of Multicast Routing Protocol packet RX, 1:Allow, 0:Drop
960 * Return:
961 * RT_ERR_OK - Success
962 * RT_ERR_PORT_ID - Error PORT ID
963 * RT_ERR_SMI - SMI access error
964 * Note:
965 * None
966 */
967 ret_t rtl8367c_getAsicIGMPMRPRX(rtk_uint32 port, rtk_uint32 *allow_mrp)
968 {
969 ret_t retVal;
970 rtk_uint32 value;
971
972 if(port > RTL8367C_PORTIDMAX)
973 return RT_ERR_PORT_ID;
974
975 /* Allow Multicast Routing Protocol */
976 if(port < 8)
977 {
978 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MRP_MASK, &value);
979 if(retVal != RT_ERR_OK)
980 return retVal;
981 }
982 else
983 {
984 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MRP_MASK, &value);
985 if(retVal != RT_ERR_OK)
986 return retVal;
987 }
988 *allow_mrp = value;
989
990 return RT_ERR_OK;
991 }
992
993 /* Function Name:
994 * rtl8367c_setAsicIGMPMcDataRX
995 * Description:
996 * Set port-based Multicast data packet RX allowance
997 * Input:
998 * port - port number
999 * allow_mcdata - allowance of Multicast data packet RX, 1:Allow, 0:Drop
1000 * Output:
1001 * none
1002 * Return:
1003 * RT_ERR_OK - Success
1004 * RT_ERR_PORT_ID - Error PORT ID
1005 * RT_ERR_SMI - SMI access error
1006 * Note:
1007 * None
1008 */
1009 ret_t rtl8367c_setAsicIGMPMcDataRX(rtk_uint32 port, rtk_uint32 allow_mcdata)
1010 {
1011 ret_t retVal;
1012
1013 if(port > RTL8367C_PORTIDMAX)
1014 return RT_ERR_PORT_ID;
1015
1016 /* Allow Multicast Data */
1017 if(port < 8)
1018 {
1019 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MC_DATA_MASK, allow_mcdata);
1020 if(retVal != RT_ERR_OK)
1021 return retVal;
1022 }
1023 else
1024 {
1025 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MC_DATA_MASK, allow_mcdata);
1026 if(retVal != RT_ERR_OK)
1027 return retVal;
1028 }
1029 return RT_ERR_OK;
1030 }
1031
1032 /* Function Name:
1033 * rtl8367c_getAsicIGMPMcDataRX
1034 * Description:
1035 * Get port-based Multicast data packet RX allowance
1036 * Input:
1037 * port - port number
1038 * Output:
1039 * allow_mcdata - allowance of Multicast data packet RX, 1:Allow, 0:Drop
1040 * Return:
1041 * RT_ERR_OK - Success
1042 * RT_ERR_PORT_ID - Error PORT ID
1043 * RT_ERR_SMI - SMI access error
1044 * Note:
1045 * None
1046 */
1047 ret_t rtl8367c_getAsicIGMPMcDataRX(rtk_uint32 port, rtk_uint32 *allow_mcdata)
1048 {
1049 ret_t retVal;
1050 rtk_uint32 value;
1051
1052 if(port > RTL8367C_PORTIDMAX)
1053 return RT_ERR_PORT_ID;
1054
1055 /* Allow Multicast data */
1056 if(port < 8)
1057 {
1058 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MC_DATA_MASK, &value);
1059 if(retVal != RT_ERR_OK)
1060 return retVal;
1061 }
1062 else
1063 {
1064 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_ALLOW_MC_DATA_MASK, &value);
1065 if(retVal != RT_ERR_OK)
1066 return retVal;
1067 }
1068
1069 *allow_mcdata = value;
1070
1071 return RT_ERR_OK;
1072 }
1073
1074 /* Function Name:
1075 * rtl8367c_setAsicIGMPv1Opeartion
1076 * Description:
1077 * Set port-based IGMPv1 Control packet action
1078 * Input:
1079 * port - port number
1080 * igmpv1_op - IGMPv1 control packet action
1081 * Output:
1082 * None
1083 * Return:
1084 * RT_ERR_OK - Success
1085 * RT_ERR_PORT_ID - Error PORT ID
1086 * RT_ERR_SMI - SMI access error
1087 * Note:
1088 * None
1089 */
1090 ret_t rtl8367c_setAsicIGMPv1Opeartion(rtk_uint32 port, rtk_uint32 igmpv1_op)
1091 {
1092 ret_t retVal;
1093
1094 if(port > RTL8367C_PORTIDMAX)
1095 return RT_ERR_PORT_ID;
1096
1097 if(igmpv1_op >= PROTOCOL_OP_END)
1098 return RT_ERR_INPUT;
1099
1100 /* IGMPv1 operation */
1101 if(port < 8)
1102 {
1103 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV1_OP_MASK, igmpv1_op);
1104 if(retVal != RT_ERR_OK)
1105 return retVal;
1106 }
1107 else
1108 {
1109 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV1_OP_MASK, igmpv1_op);
1110 if(retVal != RT_ERR_OK)
1111 return retVal;
1112 }
1113
1114 return RT_ERR_OK;
1115 }
1116
1117 /* Function Name:
1118 * rtl8367c_getAsicIGMPv1Opeartion
1119 * Description:
1120 * Get port-based IGMPv1 Control packet action
1121 * Input:
1122 * port - port number
1123 * Output:
1124 * igmpv1_op - IGMPv1 control packet action
1125 * Return:
1126 * RT_ERR_OK - Success
1127 * RT_ERR_PORT_ID - Error PORT ID
1128 * RT_ERR_SMI - SMI access error
1129 * Note:
1130 * None
1131 */
1132 ret_t rtl8367c_getAsicIGMPv1Opeartion(rtk_uint32 port, rtk_uint32 *igmpv1_op)
1133 {
1134 ret_t retVal;
1135 rtk_uint32 value;
1136
1137 if(port > RTL8367C_PORTIDMAX)
1138 return RT_ERR_PORT_ID;
1139
1140 /* IGMPv1 operation */
1141 if(port < 8)
1142 {
1143 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV1_OP_MASK, &value);
1144 if(retVal != RT_ERR_OK)
1145 return retVal;
1146 }
1147 else
1148 {
1149 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV1_OP_MASK, &value);
1150 if(retVal != RT_ERR_OK)
1151 return retVal;
1152 }
1153
1154 *igmpv1_op = value;
1155
1156 return RT_ERR_OK;
1157 }
1158
1159 /* Function Name:
1160 * rtl8367c_setAsicIGMPv2Opeartion
1161 * Description:
1162 * Set port-based IGMPv2 Control packet action
1163 * Input:
1164 * port - port number
1165 * igmpv2_op - IGMPv2 control packet action
1166 * Output:
1167 * None
1168 * Return:
1169 * RT_ERR_OK - Success
1170 * RT_ERR_PORT_ID - Error PORT ID
1171 * RT_ERR_SMI - SMI access error
1172 * Note:
1173 * None
1174 */
1175 ret_t rtl8367c_setAsicIGMPv2Opeartion(rtk_uint32 port, rtk_uint32 igmpv2_op)
1176 {
1177 ret_t retVal;
1178
1179 if(port > RTL8367C_PORTIDMAX)
1180 return RT_ERR_PORT_ID;
1181
1182 if(igmpv2_op >= PROTOCOL_OP_END)
1183 return RT_ERR_INPUT;
1184
1185 /* IGMPv2 operation */
1186 if(port < 8)
1187 {
1188 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV2_OP_MASK, igmpv2_op);
1189 if(retVal != RT_ERR_OK)
1190 return retVal;
1191 }
1192 else
1193 {
1194 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV2_OP_MASK, igmpv2_op);
1195 if(retVal != RT_ERR_OK)
1196 return retVal;
1197 }
1198
1199 return RT_ERR_OK;
1200 }
1201
1202 /* Function Name:
1203 * rtl8367c_getAsicIGMPv2Opeartion
1204 * Description:
1205 * Get port-based IGMPv2 Control packet action
1206 * Input:
1207 * port - port number
1208 * Output:
1209 * igmpv2_op - IGMPv2 control packet action
1210 * Return:
1211 * RT_ERR_OK - Success
1212 * RT_ERR_PORT_ID - Error PORT ID
1213 * RT_ERR_SMI - SMI access error
1214 * Note:
1215 * None
1216 */
1217 ret_t rtl8367c_getAsicIGMPv2Opeartion(rtk_uint32 port, rtk_uint32 *igmpv2_op)
1218 {
1219 ret_t retVal;
1220 rtk_uint32 value;
1221
1222 if(port > RTL8367C_PORTIDMAX)
1223 return RT_ERR_PORT_ID;
1224
1225 /* IGMPv2 operation */
1226 if(port < 8)
1227 {
1228 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV2_OP_MASK, &value);
1229 if(retVal != RT_ERR_OK)
1230 return retVal;
1231 }
1232 else
1233 {
1234 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV2_OP_MASK, &value);
1235 if(retVal != RT_ERR_OK)
1236 return retVal;
1237 }
1238
1239 *igmpv2_op = value;
1240
1241 return RT_ERR_OK;
1242 }
1243
1244 /* Function Name:
1245 * rtl8367c_setAsicIGMPv3Opeartion
1246 * Description:
1247 * Set port-based IGMPv3 Control packet action
1248 * Input:
1249 * port - port number
1250 * igmpv3_op - IGMPv3 control packet action
1251 * Output:
1252 * None
1253 * Return:
1254 * RT_ERR_OK - Success
1255 * RT_ERR_PORT_ID - Error PORT ID
1256 * RT_ERR_SMI - SMI access error
1257 * Note:
1258 * None
1259 */
1260 ret_t rtl8367c_setAsicIGMPv3Opeartion(rtk_uint32 port, rtk_uint32 igmpv3_op)
1261 {
1262 ret_t retVal;
1263
1264 if(port > RTL8367C_PORTIDMAX)
1265 return RT_ERR_PORT_ID;
1266
1267 if(igmpv3_op >= PROTOCOL_OP_END)
1268 return RT_ERR_INPUT;
1269
1270 /* IGMPv3 operation */
1271 if(port < 8)
1272 {
1273 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV3_OP_MASK, igmpv3_op);
1274 if(retVal != RT_ERR_OK)
1275 return retVal;
1276 }
1277 else
1278 {
1279 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV3_OP_MASK, igmpv3_op);
1280 if(retVal != RT_ERR_OK)
1281 return retVal;
1282 }
1283
1284 return RT_ERR_OK;
1285 }
1286
1287 /* Function Name:
1288 * rtl8367c_getAsicIGMPv3Opeartion
1289 * Description:
1290 * Get port-based IGMPv3 Control packet action
1291 * Input:
1292 * port - port number
1293 * Output:
1294 * igmpv3_op - IGMPv3 control packet action
1295 * Return:
1296 * RT_ERR_OK - Success
1297 * RT_ERR_PORT_ID - Error PORT ID
1298 * RT_ERR_SMI - SMI access error
1299 * Note:
1300 * None
1301 */
1302 ret_t rtl8367c_getAsicIGMPv3Opeartion(rtk_uint32 port, rtk_uint32 *igmpv3_op)
1303 {
1304 ret_t retVal;
1305 rtk_uint32 value;
1306
1307 if(port > RTL8367C_PORTIDMAX)
1308 return RT_ERR_PORT_ID;
1309
1310 /* IGMPv3 operation */
1311 if(port < 8)
1312 {
1313 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_IGMPV3_OP_MASK, &value);
1314 if(retVal != RT_ERR_OK)
1315 return retVal;
1316 }
1317 else
1318 {
1319 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_IGMPV3_OP_MASK, &value);
1320 if(retVal != RT_ERR_OK)
1321 return retVal;
1322 }
1323
1324 *igmpv3_op = value;
1325
1326 return RT_ERR_OK;
1327 }
1328
1329 /* Function Name:
1330 * rtl8367c_setAsicMLDv1Opeartion
1331 * Description:
1332 * Set port-based MLDv1 Control packet action
1333 * Input:
1334 * port - port number
1335 * mldv1_op - MLDv1 control packet action
1336 * Output:
1337 * None
1338 * Return:
1339 * RT_ERR_OK - Success
1340 * RT_ERR_PORT_ID - Error PORT ID
1341 * RT_ERR_SMI - SMI access error
1342 * Note:
1343 * None
1344 */
1345 ret_t rtl8367c_setAsicMLDv1Opeartion(rtk_uint32 port, rtk_uint32 mldv1_op)
1346 {
1347 ret_t retVal;
1348
1349 if(port > RTL8367C_PORTIDMAX)
1350 return RT_ERR_PORT_ID;
1351
1352 if(mldv1_op >= PROTOCOL_OP_END)
1353 return RT_ERR_INPUT;
1354
1355 /* MLDv1 operation */
1356 if(port < 8)
1357 {
1358 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_MLDv1_OP_MASK, mldv1_op);
1359 if(retVal != RT_ERR_OK)
1360 return retVal;
1361 }
1362 else
1363 {
1364 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_MLDv1_OP_MASK, mldv1_op);
1365 if(retVal != RT_ERR_OK)
1366 return retVal;
1367 }
1368
1369 return RT_ERR_OK;
1370 }
1371
1372 /* Function Name:
1373 * rtl8367c_getAsicMLDv1Opeartion
1374 * Description:
1375 * Get port-based MLDv1 Control packet action
1376 * Input:
1377 * port - port number
1378 * Output:
1379 * mldv1_op - MLDv1 control packet action
1380 * Return:
1381 * RT_ERR_OK - Success
1382 * RT_ERR_PORT_ID - Error PORT ID
1383 * RT_ERR_SMI - SMI access error
1384 * Note:
1385 * None
1386 */
1387 ret_t rtl8367c_getAsicMLDv1Opeartion(rtk_uint32 port, rtk_uint32 *mldv1_op)
1388 {
1389 ret_t retVal;
1390 rtk_uint32 value;
1391
1392 if(port > RTL8367C_PORTIDMAX)
1393 return RT_ERR_PORT_ID;
1394
1395 /* MLDv1 operation */
1396 if(port < 8)
1397 {
1398 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_MLDv1_OP_MASK, &value);
1399 if(retVal != RT_ERR_OK)
1400 return retVal;
1401 }
1402 else
1403 {
1404 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_MLDv1_OP_MASK, &value);
1405 if(retVal != RT_ERR_OK)
1406 return retVal;
1407 }
1408
1409 *mldv1_op = value;
1410
1411 return RT_ERR_OK;
1412 }
1413
1414 /* Function Name:
1415 * rtl8367c_setAsicMLDv2Opeartion
1416 * Description:
1417 * Set port-based MLDv2 Control packet action
1418 * Input:
1419 * port - port number
1420 * mldv2_op - MLDv2 control packet action
1421 * Output:
1422 * none
1423 * Return:
1424 * RT_ERR_OK - Success
1425 * RT_ERR_PORT_ID - Error PORT ID
1426 * RT_ERR_SMI - SMI access error
1427 * Note:
1428 * None
1429 */
1430 ret_t rtl8367c_setAsicMLDv2Opeartion(rtk_uint32 port, rtk_uint32 mldv2_op)
1431 {
1432 ret_t retVal;
1433
1434 if(port > RTL8367C_PORTIDMAX)
1435 return RT_ERR_PORT_ID;
1436
1437 if(mldv2_op >= PROTOCOL_OP_END)
1438 return RT_ERR_INPUT;
1439
1440 /* MLDv2 operation */
1441 if(port < 8)
1442 {
1443 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_MLDv2_OP_MASK, mldv2_op);
1444 if(retVal != RT_ERR_OK)
1445 return retVal;
1446 }
1447 else
1448 {
1449 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_MLDv2_OP_MASK, mldv2_op);
1450 if(retVal != RT_ERR_OK)
1451 return retVal;
1452 }
1453
1454 return RT_ERR_OK;
1455 }
1456
1457 /* Function Name:
1458 * rtl8367c_getAsicMLDv2Opeartion
1459 * Description:
1460 * Get port-based MLDv2 Control packet action
1461 * Input:
1462 * port - port number
1463 * Output:
1464 * mldv2_op - MLDv2 control packet action
1465 * Return:
1466 * RT_ERR_OK - Success
1467 * RT_ERR_PORT_ID - Error PORT ID
1468 * RT_ERR_SMI - SMI access error
1469 * Note:
1470 * None
1471 */
1472 ret_t rtl8367c_getAsicMLDv2Opeartion(rtk_uint32 port, rtk_uint32 *mldv2_op)
1473 {
1474 ret_t retVal;
1475 rtk_uint32 value;
1476
1477 if(port > RTL8367C_PORTIDMAX)
1478 return RT_ERR_PORT_ID;
1479
1480 /* MLDv2 operation */
1481 if(port < 8)
1482 {
1483 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT0_CONTROL + port, RTL8367C_IGMP_PORT0_CONTROL_MLDv2_OP_MASK, &value);
1484 if(retVal != RT_ERR_OK)
1485 return retVal;
1486 }
1487 else
1488 {
1489 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT8_CONTROL + port - 8, RTL8367C_IGMP_PORT0_CONTROL_MLDv2_OP_MASK, &value);
1490 if(retVal != RT_ERR_OK)
1491 return retVal;
1492 }
1493
1494 *mldv2_op = value;
1495
1496 return RT_ERR_OK;
1497 }
1498
1499 /* Function Name:
1500 * rtl8367c_setAsicIGMPPortMAXGroup
1501 * Description:
1502 * Set per-port Max group number
1503 * Input:
1504 * port - Physical port number (0~7)
1505 * max_group - max IGMP group
1506 * Output:
1507 * None
1508 * Return:
1509 * RT_ERR_OK - Success
1510 * RT_ERR_SMI - SMI access error
1511 * RT_ERR_PORT_ID - Invalid port number
1512 * RT_ERR_OUT_OF_RANGE - input parameter out of range
1513 * Note:
1514 * None
1515 */
1516 ret_t rtl8367c_setAsicIGMPPortMAXGroup(rtk_uint32 port, rtk_uint32 max_group)
1517 {
1518 ret_t retVal;
1519
1520 if(port > RTL8367C_PORTIDMAX)
1521 return RT_ERR_PORT_ID;
1522
1523 if(max_group > RTL8367C_IGMP_MAX_GOUP)
1524 return RT_ERR_OUT_OF_RANGE;
1525
1526 if(port < 8)
1527 {
1528 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT01_MAX_GROUP + (port/2), RTL8367C_PORT0_MAX_GROUP_MASK << (RTL8367C_PORT1_MAX_GROUP_OFFSET * (port%2)), max_group);
1529 if(retVal != RT_ERR_OK)
1530 return retVal;
1531 }
1532 else
1533 {
1534 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_PORT89_MAX_GROUP + (port/2), RTL8367C_PORT0_MAX_GROUP_MASK << (RTL8367C_PORT1_MAX_GROUP_OFFSET * (port%2)), max_group);
1535 if(retVal != RT_ERR_OK)
1536 return retVal;
1537 }
1538
1539 return RT_ERR_OK;
1540 }
1541 /* Function Name:
1542 * rtl8367c_getAsicIGMPPortMAXGroup
1543 * Description:
1544 * Get per-port Max group number
1545 * Input:
1546 * port - Physical port number (0~7)
1547 * max_group - max IGMP group
1548 * Output:
1549 * None
1550 * Return:
1551 * RT_ERR_OK - Success
1552 * RT_ERR_SMI - SMI access error
1553 * RT_ERR_PORT_ID - Invalid port number
1554 * Note:
1555 * None
1556 */
1557 ret_t rtl8367c_getAsicIGMPPortMAXGroup(rtk_uint32 port, rtk_uint32 *max_group)
1558 {
1559 ret_t retVal;
1560 rtk_uint32 value;
1561
1562 if(port > RTL8367C_PORTIDMAX)
1563 return RT_ERR_PORT_ID;
1564
1565 if(port < 8)
1566 {
1567 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT01_MAX_GROUP + (port/2), RTL8367C_PORT0_MAX_GROUP_MASK << (RTL8367C_PORT1_MAX_GROUP_OFFSET * (port%2)), &value);
1568 if(retVal != RT_ERR_OK)
1569 return retVal;
1570 }
1571 else
1572 {
1573 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT89_MAX_GROUP + (port/2), RTL8367C_PORT0_MAX_GROUP_MASK << (RTL8367C_PORT1_MAX_GROUP_OFFSET * (port%2)), &value);
1574 if(retVal != RT_ERR_OK)
1575 return retVal;
1576 }
1577
1578 *max_group = value;
1579 return RT_ERR_OK;
1580 }
1581 /* Function Name:
1582 * rtl8367c_getAsicIGMPPortCurrentGroup
1583 * Description:
1584 * Get per-port current group number
1585 * Input:
1586 * port - Physical port number (0~7)
1587 * current_group - current IGMP group
1588 * Output:
1589 * None
1590 * Return:
1591 * RT_ERR_OK - Success
1592 * RT_ERR_SMI - SMI access error
1593 * RT_ERR_PORT_ID - Invalid port number
1594 * Note:
1595 * None
1596 */
1597 ret_t rtl8367c_getAsicIGMPPortCurrentGroup(rtk_uint32 port, rtk_uint32 *current_group)
1598 {
1599 ret_t retVal;
1600 rtk_uint32 value;
1601
1602 if(port > RTL8367C_PORTIDMAX)
1603 return RT_ERR_PORT_ID;
1604
1605 if(port < 8)
1606 {
1607 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT01_CURRENT_GROUP + (port/2), RTL8367C_PORT0_CURRENT_GROUP_MASK << (RTL8367C_PORT1_CURRENT_GROUP_OFFSET * (port%2)), &value);
1608 if(retVal != RT_ERR_OK)
1609 return retVal;
1610 }
1611 else
1612 {
1613 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_PORT89_CURRENT_GROUP + ((port - 8)/2), RTL8367C_PORT0_CURRENT_GROUP_MASK << (RTL8367C_PORT1_CURRENT_GROUP_OFFSET * (port%2)), &value);
1614 if(retVal != RT_ERR_OK)
1615 return retVal;
1616 }
1617
1618 *current_group = value;
1619 return RT_ERR_OK;
1620 }
1621 /* Function Name:
1622 * rtl8367c_getAsicIGMPGroup
1623 * Description:
1624 * Get IGMP group
1625 * Input:
1626 * idx - Group index (0~255)
1627 * valid - valid bit
1628 * grp - IGMP group
1629 * Output:
1630 * None
1631 * Return:
1632 * RT_ERR_OK - Success
1633 * RT_ERR_SMI - SMI access error
1634 * RT_ERR_OUT_OF_RANGE - Group index is out of range
1635 * Note:
1636 * None
1637 */
1638 ret_t rtl8367c_getAsicIGMPGroup(rtk_uint32 idx, rtk_uint32 *valid, rtl8367c_igmpgroup *grp)
1639 {
1640 ret_t retVal;
1641 rtk_uint32 regAddr, regData;
1642 rtk_uint32 i;
1643 rtk_uint32 groupInfo = 0;
1644
1645 if(idx > RTL8367C_IGMP_MAX_GOUP)
1646 return RT_ERR_OUT_OF_RANGE;
1647
1648 /* Write ACS_ADR register for data bits */
1649 regAddr = RTL8367C_TABLE_ACCESS_ADDR_REG;
1650 regData = idx;
1651 retVal = rtl8367c_setAsicReg(regAddr, regData);
1652 if(retVal != RT_ERR_OK)
1653 return retVal;
1654
1655 /* Write ACS_CMD register */
1656 regAddr = RTL8367C_TABLE_ACCESS_CTRL_REG;
1657 regData = RTL8367C_TABLE_ACCESS_REG_DATA(TB_OP_READ, TB_TARGET_IGMP_GROUP);
1658 retVal = rtl8367c_setAsicRegBits(regAddr, RTL8367C_TABLE_TYPE_MASK | RTL8367C_COMMAND_TYPE_MASK, regData);
1659 if(retVal != RT_ERR_OK)
1660 return retVal;
1661
1662 /* Read Data Bits */
1663 regAddr = RTL8367C_TABLE_ACCESS_RDDATA_BASE;
1664 for(i = 0 ;i <= 1; i++)
1665 {
1666 retVal = rtl8367c_getAsicReg(regAddr, &regData);
1667 if(retVal != RT_ERR_OK)
1668 return retVal;
1669
1670 groupInfo |= ((regData & 0xFFFF) << (i * 16));
1671 regAddr ++;
1672 }
1673
1674 grp->p0_timer = groupInfo & 0x00000007;
1675 grp->p1_timer = (groupInfo >> 3) & 0x00000007;
1676 grp->p2_timer = (groupInfo >> 6) & 0x00000007;
1677 grp->p3_timer = (groupInfo >> 9) & 0x00000007;
1678 grp->p4_timer = (groupInfo >> 12) & 0x00000007;
1679 grp->p5_timer = (groupInfo >> 15) & 0x00000007;
1680 grp->p6_timer = (groupInfo >> 18) & 0x00000007;
1681 grp->p7_timer = (groupInfo >> 21) & 0x00000007;
1682 grp->report_supp_flag = (groupInfo >> 24) & 0x00000001;
1683 grp->p8_timer = (groupInfo >> 25) & 0x00000007;
1684 grp->p9_timer = (groupInfo >> 28) & 0x00000007;
1685 grp->p10_timer = (groupInfo >> 31) & 0x00000001;
1686
1687 regAddr = RTL8367C_TABLE_ACCESS_RDDATA_BASE + 2;
1688 retVal = rtl8367c_getAsicReg(regAddr, &regData);
1689 if(retVal != RT_ERR_OK)
1690 return retVal;
1691
1692 grp->p10_timer |= (regData & 0x00000003) << 1;
1693
1694 /* Valid bit */
1695 retVal = rtl8367c_getAsicReg(RTL8367C_IGMP_GROUP_USAGE_REG(idx), &regData);
1696 if(retVal != RT_ERR_OK)
1697 return retVal;
1698
1699 *valid = ((regData & (0x0001 << (idx %16))) != 0) ? 1 : 0;
1700
1701 return RT_ERR_OK;
1702 }
1703 /* Function Name:
1704 * rtl8367c_setAsicIpMulticastPortIsoLeaky
1705 * Description:
1706 * Set IP multicast Port Isolation leaky
1707 * Input:
1708 * port - Physical port number (0~7)
1709 * enabled - 1: enabled, 0: disabled
1710 * Output:
1711 * None
1712 * Return:
1713 * RT_ERR_OK - Success
1714 * RT_ERR_SMI - SMI access error
1715 * RT_ERR_PORT_ID - Invalid port number
1716 * Note:
1717 * None
1718 */
1719 ret_t rtl8367c_setAsicIpMulticastPortIsoLeaky(rtk_uint32 port, rtk_uint32 enabled)
1720 {
1721 ret_t retVal;
1722
1723 if(port > RTL8367C_PORTIDMAX)
1724 return RT_ERR_PORT_ID;
1725
1726 retVal = rtl8367c_setAsicRegBits(RTL8367C_IPMCAST_PORTISO_LEAKY_REG, (0x0001 << port), enabled);
1727 if(retVal != RT_ERR_OK)
1728 return retVal;
1729
1730 return RT_ERR_OK;
1731 }
1732
1733 /* Function Name:
1734 * rtl8367c_getAsicIpMulticastPortIsoLeaky
1735 * Description:
1736 * Get IP multicast Port Isolation leaky
1737 * Input:
1738 * port - Physical port number (0~7)
1739 * enabled - 1: enabled, 0: disabled
1740 * Output:
1741 * None
1742 * Return:
1743 * RT_ERR_OK - Success
1744 * RT_ERR_SMI - SMI access error
1745 * Note:
1746 * None
1747 */
1748 ret_t rtl8367c_getAsicIpMulticastPortIsoLeaky(rtk_uint32 port, rtk_uint32 *enabled)
1749 {
1750 ret_t retVal;
1751 rtk_uint32 regData;
1752
1753 retVal = rtl8367c_getAsicRegBits(RTL8367C_IPMCAST_PORTISO_LEAKY_REG, (0x0001 << port), &regData);
1754 if(retVal != RT_ERR_OK)
1755 return retVal;
1756
1757 *enabled = regData;
1758 return RT_ERR_OK;
1759 }
1760
1761 /* Function Name:
1762 * rtl8367c_setAsicIGMPReportLeaveFlood
1763 * Description:
1764 * Set IGMP/MLD Report/Leave flood
1765 * Input:
1766 * flood - 0: Reserved, 1: flooding to router ports, 2: flooding to all ports, 3: flooding to router port or to all ports if there is no router port
1767 * Output:
1768 * None
1769 * Return:
1770 * RT_ERR_OK - Success
1771 * RT_ERR_SMI - SMI access error
1772 * Note:
1773 * None
1774 */
1775 ret_t rtl8367c_setAsicIGMPReportLeaveFlood(rtk_uint32 flood)
1776 {
1777 ret_t retVal;
1778
1779 retVal = rtl8367c_setAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG3, RTL8367C_REPORT_LEAVE_FORWARD_MASK, flood);
1780 if(retVal != RT_ERR_OK)
1781 return retVal;
1782
1783 return RT_ERR_OK;
1784 }
1785
1786 /* Function Name:
1787 * rtl8367c_getAsicIGMPReportLeaveFlood
1788 * Description:
1789 * Get IGMP/MLD Report/Leave flood
1790 * Input:
1791 * None
1792 * Output:
1793 * pflood - 0: Reserved, 1: flooding to router ports, 2: flooding to all ports, 3: flooding to router port or to all ports if there is no router port
1794 * Return:
1795 * RT_ERR_OK - Success
1796 * RT_ERR_SMI - SMI access error
1797 * Note:
1798 * None
1799 */
1800 ret_t rtl8367c_getAsicIGMPReportLeaveFlood(rtk_uint32 *pFlood)
1801 {
1802 ret_t retVal;
1803 rtk_uint32 regData;
1804
1805 retVal = rtl8367c_getAsicRegBits(RTL8367C_REG_IGMP_MLD_CFG3, RTL8367C_REPORT_LEAVE_FORWARD_MASK, &regData);
1806 if(retVal != RT_ERR_OK)
1807 return retVal;
1808
1809 *pFlood = regData;
1810 return RT_ERR_OK;
1811 }
1812
1813 /* Function Name:
1814 * rtl8367c_setAsicIGMPDropLeaveZero
1815 * Description:
1816 * Set the function of droppping Leave packet with group IP = 0.0.0.0
1817 * Input:
1818 * drop - 1: Drop, 0:Bypass
1819 * Output:
1820 * None
1821 * Return:
1822 * RT_ERR_OK - Success
1823 * RT_ERR_SMI - SMI access error
1824 * Note:
1825 * None
1826 */
1827 ret_t rtl8367c_setAsicIGMPDropLeaveZero(rtk_uint32 drop)
1828 {
1829 ret_t retVal;
1830
1831 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG1, RTL8367C_DROP_LEAVE_ZERO_OFFSET, drop);
1832 if(retVal != RT_ERR_OK)
1833 return retVal;
1834
1835 return RT_ERR_OK;
1836 }
1837
1838 /* Function Name:
1839 * rtl8367c_getAsicIGMPDropLeaveZero
1840 * Description:
1841 * Get the function of droppping Leave packet with group IP = 0.0.0.0
1842 * Input:
1843 * None
1844 * Output:
1845 * pDrop - 1: Drop, 0:Bypass
1846 * Return:
1847 * RT_ERR_OK - Success
1848 * RT_ERR_SMI - SMI access error
1849 * Note:
1850 * None
1851 */
1852 ret_t rtl8367c_getAsicIGMPDropLeaveZero(rtk_uint32 *pDrop)
1853 {
1854 ret_t retVal;
1855 rtk_uint32 regData;
1856
1857 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG1, RTL8367C_DROP_LEAVE_ZERO_OFFSET, &regData);
1858 if(retVal != RT_ERR_OK)
1859 return retVal;
1860
1861 *pDrop = regData;
1862 return RT_ERR_OK;
1863 }
1864
1865 /* Function Name:
1866 * rtl8367c_setAsicIGMPBypassStormCTRL
1867 * Description:
1868 * Set the function of bypass strom control for IGMP/MLD packet
1869 * Input:
1870 * bypass - 1: Bypass, 0:not bypass
1871 * Output:
1872 * None
1873 * Return:
1874 * RT_ERR_OK - Success
1875 * RT_ERR_SMI - SMI access error
1876 * Note:
1877 * None
1878 */
1879 ret_t rtl8367c_setAsicIGMPBypassStormCTRL(rtk_uint32 bypass)
1880 {
1881 ret_t retVal;
1882
1883 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_DISCARD_STORM_FILTER_OFFSET, bypass);
1884 if(retVal != RT_ERR_OK)
1885 return retVal;
1886
1887 return RT_ERR_OK;
1888 }
1889
1890 /* Function Name:
1891 * rtl8367c_getAsicIGMPBypassStormCTRL
1892 * Description:
1893 * Set the function of bypass strom control for IGMP/MLD packet
1894 * Input:
1895 * None
1896 * Output:
1897 * pBypass - 1: Bypass, 0:not bypass
1898 * Return:
1899 * RT_ERR_OK - Success
1900 * RT_ERR_SMI - SMI access error
1901 * Note:
1902 * None
1903 */
1904 ret_t rtl8367c_getAsicIGMPBypassStormCTRL(rtk_uint32 *pBypass)
1905 {
1906 ret_t retVal;
1907 rtk_uint32 regData;
1908
1909 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_DISCARD_STORM_FILTER_OFFSET, &regData);
1910 if(retVal != RT_ERR_OK)
1911 return retVal;
1912
1913 *pBypass = regData;
1914 return RT_ERR_OK;
1915 }
1916
1917 /* Function Name:
1918 * rtl8367c_setAsicIGMPIsoLeaky
1919 * Description:
1920 * Set Port Isolation leaky for IGMP/MLD packet
1921 * Input:
1922 * leaky - 1: Leaky, 0:not leaky
1923 * Output:
1924 * None
1925 * Return:
1926 * RT_ERR_OK - Success
1927 * RT_ERR_SMI - SMI access error
1928 * Note:
1929 * None
1930 */
1931 ret_t rtl8367c_setAsicIGMPIsoLeaky(rtk_uint32 leaky)
1932 {
1933 ret_t retVal;
1934
1935 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_PORTISO_LEAKY_OFFSET, leaky);
1936 if(retVal != RT_ERR_OK)
1937 return retVal;
1938
1939 return RT_ERR_OK;
1940 }
1941
1942 /* Function Name:
1943 * rtl8367c_getAsicIGMPIsoLeaky
1944 * Description:
1945 * Get Port Isolation leaky for IGMP/MLD packet
1946 * Input:
1947 * Noen
1948 * Output:
1949 * pLeaky - 1: Leaky, 0:not leaky
1950 * Return:
1951 * RT_ERR_OK - Success
1952 * RT_ERR_SMI - SMI access error
1953 * Note:
1954 * None
1955 */
1956 ret_t rtl8367c_getAsicIGMPIsoLeaky(rtk_uint32 *pLeaky)
1957 {
1958 ret_t retVal;
1959 rtk_uint32 regData;
1960
1961 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_PORTISO_LEAKY_OFFSET, &regData);
1962 if(retVal != RT_ERR_OK)
1963 return retVal;
1964
1965 *pLeaky = regData;
1966 return RT_ERR_OK;
1967 }
1968
1969 /* Function Name:
1970 * rtl8367c_setAsicIGMPVLANLeaky
1971 * Description:
1972 * Set VLAN leaky for IGMP/MLD packet
1973 * Input:
1974 * leaky - 1: Leaky, 0:not leaky
1975 * Output:
1976 * None
1977 * Return:
1978 * RT_ERR_OK - Success
1979 * RT_ERR_SMI - SMI access error
1980 * Note:
1981 * None
1982 */
1983 ret_t rtl8367c_setAsicIGMPVLANLeaky(rtk_uint32 leaky)
1984 {
1985 ret_t retVal;
1986
1987 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_VLAN_LEAKY_OFFSET, leaky);
1988 if(retVal != RT_ERR_OK)
1989 return retVal;
1990
1991 return RT_ERR_OK;
1992 }
1993
1994 /* Function Name:
1995 * rtl8367c_getAsicIGMPVLANLeaky
1996 * Description:
1997 * Get VLAN leaky for IGMP/MLD packet
1998 * Input:
1999 * Noen
2000 * Output:
2001 * pLeaky - 1: Leaky, 0:not leaky
2002 * Return:
2003 * RT_ERR_OK - Success
2004 * RT_ERR_SMI - SMI access error
2005 * Note:
2006 * None
2007 */
2008 ret_t rtl8367c_getAsicIGMPVLANLeaky(rtk_uint32 *pLeaky)
2009 {
2010 ret_t retVal;
2011 rtk_uint32 regData;
2012
2013 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG0, RTL8367C_IGMP_MLD_VLAN_LEAKY_OFFSET, &regData);
2014 if(retVal != RT_ERR_OK)
2015 return retVal;
2016
2017 *pLeaky = regData;
2018 return RT_ERR_OK;
2019 }
2020
2021 /* Function Name:
2022 * rtl8367c_setAsicIGMPBypassGroup
2023 * Description:
2024 * Set IGMP/MLD Bypass group
2025 * Input:
2026 * bypassType - Bypass type
2027 * enabled - enabled
2028 * Output:
2029 * None
2030 * Return:
2031 * RT_ERR_OK - Success
2032 * RT_ERR_SMI - SMI access error
2033 * Note:
2034 * None
2035 */
2036 ret_t rtl8367c_setAsicIGMPBypassGroup(rtk_uint32 bypassType, rtk_uint32 enabled)
2037 {
2038 ret_t retVal;
2039 rtk_uint32 offset;
2040
2041 switch(bypassType)
2042 {
2043 case BYPASS_224_0_0_X:
2044 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_224_0_0_OFFSET;
2045 break;
2046 case BYPASS_224_0_1_X:
2047 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_224_0_1_OFFSET;
2048 break;
2049 case BYPASS_239_255_255_X:
2050 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_239_255_255_OFFSET;
2051 break;
2052 case BYPASS_IPV6_00XX:
2053 offset = RTL8367C_IGMP_MLD_IP6_BYPASS_OFFSET;
2054 break;
2055 default:
2056 return RT_ERR_INPUT;
2057 }
2058
2059 retVal = rtl8367c_setAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG3, offset, enabled);
2060 if(retVal != RT_ERR_OK)
2061 return retVal;
2062
2063 return RT_ERR_OK;
2064 }
2065
2066 /* Function Name:
2067 * rtl8367c_getAsicIGMPBypassGroup
2068 * Description:
2069 * Get IGMP/MLD Bypass group
2070 * Input:
2071 * bypassType - Bypass type
2072 * Output:
2073 * pEnabled - enabled
2074 * Return:
2075 * RT_ERR_OK - Success
2076 * RT_ERR_SMI - SMI access error
2077 * Note:
2078 * None
2079 */
2080 ret_t rtl8367c_getAsicIGMPBypassGroup(rtk_uint32 bypassType, rtk_uint32 *pEnabled)
2081 {
2082 ret_t retVal;
2083 rtk_uint32 offset;
2084
2085 switch(bypassType)
2086 {
2087 case BYPASS_224_0_0_X:
2088 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_224_0_0_OFFSET;
2089 break;
2090 case BYPASS_224_0_1_X:
2091 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_224_0_1_OFFSET;
2092 break;
2093 case BYPASS_239_255_255_X:
2094 offset = RTL8367C_IGMP_MLD_IP4_BYPASS_239_255_255_OFFSET;
2095 break;
2096 case BYPASS_IPV6_00XX:
2097 offset = RTL8367C_IGMP_MLD_IP6_BYPASS_OFFSET;
2098 break;
2099 default:
2100 return RT_ERR_INPUT;
2101 }
2102
2103 retVal = rtl8367c_getAsicRegBit(RTL8367C_REG_IGMP_MLD_CFG3, offset, pEnabled);
2104 if(retVal != RT_ERR_OK)
2105 return retVal;
2106
2107 return RT_ERR_OK;
2108 }
2109
OpenWrt Source Repository