2 * Copyright (C) 2013 Realtek Semiconductor Corp.
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
11 * $Date: 2017-03-08 15:13:58 +0800 (週三, 08 三月 2017) $
13 * Purpose : RTK switch high-level API for RTL8367/RTL8367C
14 * Feature : Here is a list of all functions and variables in L2 module.
18 #include <rtk_switch.h>
19 #include <rtk_error.h>
23 #include <rtl8367c_asicdrv.h>
24 #include <rtl8367c_asicdrv_lut.h>
25 #include <rtl8367c_asicdrv_port.h>
30 * Initialize l2 module of the specified device.
37 * RT_ERR_FAILED - Failed
38 * RT_ERR_SMI - SMI access error
40 * Initialize l2 module before calling any l2 APIs.
42 rtk_api_ret_t
rtk_l2_init(void)
47 /* Check initialization state */
50 if ((retVal
= rtl8367c_setAsicLutIpMulticastLookup(DISABLED
)) != RT_ERR_OK
)
54 if ((retVal
= rtl8367c_setAsicLutCamTbUsage(ENABLED
)) != RT_ERR_OK
)
57 if ((retVal
= rtl8367c_setAsicLutAgeTimerSpeed(6,2)) != RT_ERR_OK
)
60 RTK_SCAN_ALL_LOG_PORT(port
)
62 if ((retVal
= rtl8367c_setAsicLutLearnLimitNo(rtk_switch_port_L2P_get(port
), rtk_switch_maxLutAddrNumber_get())) != RT_ERR_OK
)
73 * Add LUT unicast entry.
75 * pMac - 6 bytes unicast(I/G bit is 0) mac address to be written into LUT.
76 * pL2_data - Unicast entry parameter
81 * RT_ERR_FAILED - Failed
82 * RT_ERR_SMI - SMI access error
83 * RT_ERR_PORT_ID - Invalid port number.
84 * RT_ERR_MAC - Invalid MAC address.
85 * RT_ERR_L2_FID - Invalid FID .
86 * RT_ERR_L2_INDEXTBL_FULL - hashed index is full of entries.
87 * RT_ERR_INPUT - Invalid input parameters.
89 * If the unicast mac address already existed in LUT, it will udpate the status of the entry.
90 * Otherwise, it will find an empty or asic auto learned entry to write. If all the entries
91 * with the same hash value can't be replaced, ASIC will return a RT_ERR_L2_INDEXTBL_FULL error.
93 rtk_api_ret_t
rtk_l2_addr_add(rtk_mac_t
*pMac
, rtk_l2_ucastAddr_t
*pL2_data
)
97 rtl8367c_luttb l2Table
;
99 /* Check initialization state */
100 RTK_CHK_INIT_STATE();
102 /* must be unicast address */
103 if ((pMac
== NULL
) || (pMac
->octet
[0] & 0x1))
109 RTK_CHK_PORT_VALID(pL2_data
->port
);
111 if (pL2_data
->ivl
>= RTK_ENABLE_END
)
114 if (pL2_data
->cvid
> RTL8367C_VIDMAX
)
115 return RT_ERR_L2_VID
;
117 if (pL2_data
->fid
> RTL8367C_FIDMAX
)
118 return RT_ERR_L2_FID
;
120 if (pL2_data
->is_static
>= RTK_ENABLE_END
)
123 if (pL2_data
->sa_block
>= RTK_ENABLE_END
)
126 if (pL2_data
->da_block
>= RTK_ENABLE_END
)
129 if (pL2_data
->auth
>= RTK_ENABLE_END
)
132 if (pL2_data
->efid
> RTL8367C_EFIDMAX
)
135 if (pL2_data
->priority
> RTL8367C_PRIMAX
)
138 if (pL2_data
->sa_pri_en
>= RTK_ENABLE_END
)
141 if (pL2_data
->fwd_pri_en
>= RTK_ENABLE_END
)
144 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
146 /* fill key (MAC,FID) to get L2 entry */
147 memcpy(l2Table
.mac
.octet
, pMac
->octet
, ETHER_ADDR_LEN
);
148 l2Table
.ivl_svl
= pL2_data
->ivl
;
149 l2Table
.fid
= pL2_data
->fid
;
150 l2Table
.cvid_fid
= pL2_data
->cvid
;
151 l2Table
.efid
= pL2_data
->efid
;
152 method
= LUTREADMETHOD_MAC
;
153 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
154 if (RT_ERR_OK
== retVal
)
156 memcpy(l2Table
.mac
.octet
, pMac
->octet
, ETHER_ADDR_LEN
);
157 l2Table
.ivl_svl
= pL2_data
->ivl
;
158 l2Table
.cvid_fid
= pL2_data
->cvid
;
159 l2Table
.fid
= pL2_data
->fid
;
160 l2Table
.efid
= pL2_data
->efid
;
161 l2Table
.spa
= rtk_switch_port_L2P_get(pL2_data
->port
);
162 l2Table
.nosalearn
= pL2_data
->is_static
;
163 l2Table
.sa_block
= pL2_data
->sa_block
;
164 l2Table
.da_block
= pL2_data
->da_block
;
165 l2Table
.l3lookup
= 0;
166 l2Table
.auth
= pL2_data
->auth
;
168 l2Table
.lut_pri
= pL2_data
->priority
;
169 l2Table
.sa_en
= pL2_data
->sa_pri_en
;
170 l2Table
.fwd_en
= pL2_data
->fwd_pri_en
;
171 if((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
174 pL2_data
->address
= l2Table
.address
;
177 else if (RT_ERR_L2_ENTRY_NOTFOUND
== retVal
)
179 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
180 memcpy(l2Table
.mac
.octet
, pMac
->octet
, ETHER_ADDR_LEN
);
181 l2Table
.ivl_svl
= pL2_data
->ivl
;
182 l2Table
.cvid_fid
= pL2_data
->cvid
;
183 l2Table
.fid
= pL2_data
->fid
;
184 l2Table
.efid
= pL2_data
->efid
;
185 l2Table
.spa
= rtk_switch_port_L2P_get(pL2_data
->port
);
186 l2Table
.nosalearn
= pL2_data
->is_static
;
187 l2Table
.sa_block
= pL2_data
->sa_block
;
188 l2Table
.da_block
= pL2_data
->da_block
;
189 l2Table
.l3lookup
= 0;
190 l2Table
.auth
= pL2_data
->auth
;
192 l2Table
.lut_pri
= pL2_data
->priority
;
193 l2Table
.sa_en
= pL2_data
->sa_pri_en
;
194 l2Table
.fwd_en
= pL2_data
->fwd_pri_en
;
196 if ((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
199 pL2_data
->address
= l2Table
.address
;
201 method
= LUTREADMETHOD_MAC
;
202 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
203 if (RT_ERR_L2_ENTRY_NOTFOUND
== retVal
)
204 return RT_ERR_L2_INDEXTBL_FULL
;
216 * Get LUT unicast entry.
218 * pMac - 6 bytes unicast(I/G bit is 0) mac address to be written into LUT.
220 * pL2_data - Unicast entry parameter
223 * RT_ERR_FAILED - Failed
224 * RT_ERR_SMI - SMI access error
225 * RT_ERR_PORT_ID - Invalid port number.
226 * RT_ERR_MAC - Invalid MAC address.
227 * RT_ERR_L2_FID - Invalid FID .
228 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
229 * RT_ERR_INPUT - Invalid input parameters.
231 * If the unicast mac address existed in LUT, it will return the port and fid where
232 * the mac is learned. Otherwise, it will return a RT_ERR_L2_ENTRY_NOTFOUND error.
234 rtk_api_ret_t
rtk_l2_addr_get(rtk_mac_t
*pMac
, rtk_l2_ucastAddr_t
*pL2_data
)
236 rtk_api_ret_t retVal
;
238 rtl8367c_luttb l2Table
;
240 /* Check initialization state */
241 RTK_CHK_INIT_STATE();
243 /* must be unicast address */
244 if ((pMac
== NULL
) || (pMac
->octet
[0] & 0x1))
247 if (pL2_data
->fid
> RTL8367C_FIDMAX
|| pL2_data
->efid
> RTL8367C_EFIDMAX
)
248 return RT_ERR_L2_FID
;
250 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
252 memcpy(l2Table
.mac
.octet
, pMac
->octet
, ETHER_ADDR_LEN
);
253 l2Table
.ivl_svl
= pL2_data
->ivl
;
254 l2Table
.cvid_fid
= pL2_data
->cvid
;
255 l2Table
.fid
= pL2_data
->fid
;
256 l2Table
.efid
= pL2_data
->efid
;
257 method
= LUTREADMETHOD_MAC
;
259 if ((retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
)) != RT_ERR_OK
)
262 memcpy(pL2_data
->mac
.octet
, pMac
->octet
,ETHER_ADDR_LEN
);
263 pL2_data
->port
= rtk_switch_port_P2L_get(l2Table
.spa
);
264 pL2_data
->fid
= l2Table
.fid
;
265 pL2_data
->efid
= l2Table
.efid
;
266 pL2_data
->ivl
= l2Table
.ivl_svl
;
267 pL2_data
->cvid
= l2Table
.cvid_fid
;
268 pL2_data
->is_static
= l2Table
.nosalearn
;
269 pL2_data
->auth
= l2Table
.auth
;
270 pL2_data
->sa_block
= l2Table
.sa_block
;
271 pL2_data
->da_block
= l2Table
.da_block
;
272 pL2_data
->priority
= l2Table
.lut_pri
;
273 pL2_data
->sa_pri_en
= l2Table
.sa_en
;
274 pL2_data
->fwd_pri_en
= l2Table
.fwd_en
;
275 pL2_data
->address
= l2Table
.address
;
281 * rtk_l2_addr_next_get
283 * Get Next LUT unicast entry.
285 * read_method - The reading method.
286 * port - The port number if the read_metohd is READMETHOD_NEXT_L2UCSPA
287 * pAddress - The Address ID
289 * pL2_data - Unicast entry parameter
292 * RT_ERR_FAILED - Failed
293 * RT_ERR_SMI - SMI access error
294 * RT_ERR_PORT_ID - Invalid port number.
295 * RT_ERR_MAC - Invalid MAC address.
296 * RT_ERR_L2_FID - Invalid FID .
297 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
298 * RT_ERR_INPUT - Invalid input parameters.
300 * Get the next unicast entry after the current entry pointed by pAddress.
301 * The address of next entry is returned by pAddress. User can use (address + 1)
302 * as pAddress to call this API again for dumping all entries is LUT.
304 rtk_api_ret_t
rtk_l2_addr_next_get(rtk_l2_read_method_t read_method
, rtk_port_t port
, rtk_uint32
*pAddress
, rtk_l2_ucastAddr_t
*pL2_data
)
306 rtk_api_ret_t retVal
;
308 rtl8367c_luttb l2Table
;
310 /* Check initialization state */
311 RTK_CHK_INIT_STATE();
314 if ((pL2_data
== NULL
) || (pAddress
== NULL
))
317 if(read_method
== READMETHOD_NEXT_L2UC
)
318 method
= LUTREADMETHOD_NEXT_L2UC
;
319 else if(read_method
== READMETHOD_NEXT_L2UCSPA
)
320 method
= LUTREADMETHOD_NEXT_L2UCSPA
;
324 /* Check Port Valid */
325 RTK_CHK_PORT_VALID(port
);
327 if(*pAddress
> RTK_MAX_LUT_ADDR_ID
)
328 return RT_ERR_L2_L2UNI_PARAM
;
330 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
331 l2Table
.address
= *pAddress
;
333 if(read_method
== READMETHOD_NEXT_L2UCSPA
)
334 l2Table
.spa
= rtk_switch_port_L2P_get(port
);
336 if ((retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
)) != RT_ERR_OK
)
339 if(l2Table
.address
< *pAddress
)
340 return RT_ERR_L2_ENTRY_NOTFOUND
;
342 memcpy(pL2_data
->mac
.octet
, l2Table
.mac
.octet
, ETHER_ADDR_LEN
);
343 pL2_data
->port
= rtk_switch_port_P2L_get(l2Table
.spa
);
344 pL2_data
->fid
= l2Table
.fid
;
345 pL2_data
->efid
= l2Table
.efid
;
346 pL2_data
->ivl
= l2Table
.ivl_svl
;
347 pL2_data
->cvid
= l2Table
.cvid_fid
;
348 pL2_data
->is_static
= l2Table
.nosalearn
;
349 pL2_data
->auth
= l2Table
.auth
;
350 pL2_data
->sa_block
= l2Table
.sa_block
;
351 pL2_data
->da_block
= l2Table
.da_block
;
352 pL2_data
->priority
= l2Table
.lut_pri
;
353 pL2_data
->sa_pri_en
= l2Table
.sa_en
;
354 pL2_data
->fwd_pri_en
= l2Table
.fwd_en
;
355 pL2_data
->address
= l2Table
.address
;
357 *pAddress
= l2Table
.address
;
366 * Delete LUT unicast entry.
368 * pMac - 6 bytes unicast(I/G bit is 0) mac address to be written into LUT.
369 * fid - Filtering database
374 * RT_ERR_FAILED - Failed
375 * RT_ERR_SMI - SMI access error
376 * RT_ERR_PORT_ID - Invalid port number.
377 * RT_ERR_MAC - Invalid MAC address.
378 * RT_ERR_L2_FID - Invalid FID .
379 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
380 * RT_ERR_INPUT - Invalid input parameters.
382 * If the mac has existed in the LUT, it will be deleted. Otherwise, it will return RT_ERR_L2_ENTRY_NOTFOUND.
384 rtk_api_ret_t
rtk_l2_addr_del(rtk_mac_t
*pMac
, rtk_l2_ucastAddr_t
*pL2_data
)
386 rtk_api_ret_t retVal
;
388 rtl8367c_luttb l2Table
;
390 /* Check initialization state */
391 RTK_CHK_INIT_STATE();
393 /* must be unicast address */
394 if ((pMac
== NULL
) || (pMac
->octet
[0] & 0x1))
397 if (pL2_data
->fid
> RTL8367C_FIDMAX
|| pL2_data
->efid
> RTL8367C_EFIDMAX
)
398 return RT_ERR_L2_FID
;
400 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
402 /* fill key (MAC,FID) to get L2 entry */
403 memcpy(l2Table
.mac
.octet
, pMac
->octet
, ETHER_ADDR_LEN
);
404 l2Table
.ivl_svl
= pL2_data
->ivl
;
405 l2Table
.cvid_fid
= pL2_data
->cvid
;
406 l2Table
.fid
= pL2_data
->fid
;
407 l2Table
.efid
= pL2_data
->efid
;
408 method
= LUTREADMETHOD_MAC
;
409 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
410 if (RT_ERR_OK
== retVal
)
412 memcpy(l2Table
.mac
.octet
, pMac
->octet
, ETHER_ADDR_LEN
);
413 l2Table
.ivl_svl
= pL2_data
->ivl
;
414 l2Table
.cvid_fid
= pL2_data
->cvid
;
415 l2Table
.fid
= pL2_data
->fid
;
416 l2Table
.efid
= pL2_data
->efid
;
418 l2Table
.nosalearn
= 0;
419 l2Table
.sa_block
= 0;
420 l2Table
.da_block
= 0;
426 if((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
429 pL2_data
->address
= l2Table
.address
;
437 * rtk_l2_mcastAddr_add
439 * Add LUT multicast entry.
441 * pMcastAddr - L2 multicast entry structure
446 * RT_ERR_FAILED - Failed
447 * RT_ERR_SMI - SMI access error
448 * RT_ERR_PORT_ID - Invalid port number.
449 * RT_ERR_MAC - Invalid MAC address.
450 * RT_ERR_L2_FID - Invalid FID .
451 * RT_ERR_L2_VID - Invalid VID .
452 * RT_ERR_L2_INDEXTBL_FULL - hashed index is full of entries.
453 * RT_ERR_PORT_MASK - Invalid portmask.
454 * RT_ERR_INPUT - Invalid input parameters.
456 * If the multicast mac address already existed in the LUT, it will udpate the
457 * port mask of the entry. Otherwise, it will find an empty or asic auto learned
458 * entry to write. If all the entries with the same hash value can't be replaced,
459 * ASIC will return a RT_ERR_L2_INDEXTBL_FULL error.
461 rtk_api_ret_t
rtk_l2_mcastAddr_add(rtk_l2_mcastAddr_t
*pMcastAddr
)
463 rtk_api_ret_t retVal
;
465 rtl8367c_luttb l2Table
;
468 /* Check initialization state */
469 RTK_CHK_INIT_STATE();
471 if(NULL
== pMcastAddr
)
472 return RT_ERR_NULL_POINTER
;
474 /* must be L2 multicast address */
475 if( (pMcastAddr
->mac
.octet
[0] & 0x01) != 0x01)
478 RTK_CHK_PORTMASK_VALID(&pMcastAddr
->portmask
);
480 if(pMcastAddr
->ivl
== 1)
482 if (pMcastAddr
->vid
> RTL8367C_VIDMAX
)
483 return RT_ERR_L2_VID
;
485 else if(pMcastAddr
->ivl
== 0)
487 if (pMcastAddr
->fid
> RTL8367C_FIDMAX
)
488 return RT_ERR_L2_FID
;
493 if(pMcastAddr
->fwd_pri_en
>= RTK_ENABLE_END
)
496 if(pMcastAddr
->priority
> RTL8367C_PRIMAX
)
499 /* Get physical port mask */
500 if ((retVal
= rtk_switch_portmask_L2P_get(&pMcastAddr
->portmask
, &pmask
)) != RT_ERR_OK
)
503 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
505 /* fill key (MAC,FID) to get L2 entry */
506 memcpy(l2Table
.mac
.octet
, pMcastAddr
->mac
.octet
, ETHER_ADDR_LEN
);
507 l2Table
.ivl_svl
= pMcastAddr
->ivl
;
510 l2Table
.cvid_fid
= pMcastAddr
->vid
;
512 l2Table
.cvid_fid
= pMcastAddr
->fid
;
514 method
= LUTREADMETHOD_MAC
;
515 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
516 if (RT_ERR_OK
== retVal
)
518 memcpy(l2Table
.mac
.octet
, pMcastAddr
->mac
.octet
, ETHER_ADDR_LEN
);
519 l2Table
.ivl_svl
= pMcastAddr
->ivl
;
522 l2Table
.cvid_fid
= pMcastAddr
->vid
;
524 l2Table
.cvid_fid
= pMcastAddr
->fid
;
527 l2Table
.nosalearn
= 1;
528 l2Table
.l3lookup
= 0;
529 l2Table
.lut_pri
= pMcastAddr
->priority
;
530 l2Table
.fwd_en
= pMcastAddr
->fwd_pri_en
;
531 if((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
534 pMcastAddr
->address
= l2Table
.address
;
537 else if (RT_ERR_L2_ENTRY_NOTFOUND
== retVal
)
539 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
540 memcpy(l2Table
.mac
.octet
, pMcastAddr
->mac
.octet
, ETHER_ADDR_LEN
);
541 l2Table
.ivl_svl
= pMcastAddr
->ivl
;
543 l2Table
.cvid_fid
= pMcastAddr
->vid
;
545 l2Table
.cvid_fid
= pMcastAddr
->fid
;
548 l2Table
.nosalearn
= 1;
549 l2Table
.l3lookup
= 0;
550 l2Table
.lut_pri
= pMcastAddr
->priority
;
551 l2Table
.fwd_en
= pMcastAddr
->fwd_pri_en
;
552 if ((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
555 pMcastAddr
->address
= l2Table
.address
;
557 method
= LUTREADMETHOD_MAC
;
558 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
559 if (RT_ERR_L2_ENTRY_NOTFOUND
== retVal
)
560 return RT_ERR_L2_INDEXTBL_FULL
;
570 * rtk_l2_mcastAddr_get
572 * Get LUT multicast entry.
574 * pMcastAddr - L2 multicast entry structure
576 * pMcastAddr - L2 multicast entry structure
579 * RT_ERR_FAILED - Failed
580 * RT_ERR_SMI - SMI access error
581 * RT_ERR_MAC - Invalid MAC address.
582 * RT_ERR_L2_FID - Invalid FID .
583 * RT_ERR_L2_VID - Invalid VID .
584 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
585 * RT_ERR_INPUT - Invalid input parameters.
587 * If the multicast mac address existed in the LUT, it will return the port where
588 * the mac is learned. Otherwise, it will return a RT_ERR_L2_ENTRY_NOTFOUND error.
590 rtk_api_ret_t
rtk_l2_mcastAddr_get(rtk_l2_mcastAddr_t
*pMcastAddr
)
592 rtk_api_ret_t retVal
;
594 rtl8367c_luttb l2Table
;
596 /* Check initialization state */
597 RTK_CHK_INIT_STATE();
599 if(NULL
== pMcastAddr
)
600 return RT_ERR_NULL_POINTER
;
602 /* must be L2 multicast address */
603 if( (pMcastAddr
->mac
.octet
[0] & 0x01) != 0x01)
606 if(pMcastAddr
->ivl
== 1)
608 if (pMcastAddr
->vid
> RTL8367C_VIDMAX
)
609 return RT_ERR_L2_VID
;
611 else if(pMcastAddr
->ivl
== 0)
613 if (pMcastAddr
->fid
> RTL8367C_FIDMAX
)
614 return RT_ERR_L2_FID
;
619 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
620 memcpy(l2Table
.mac
.octet
, pMcastAddr
->mac
.octet
, ETHER_ADDR_LEN
);
621 l2Table
.ivl_svl
= pMcastAddr
->ivl
;
624 l2Table
.cvid_fid
= pMcastAddr
->vid
;
626 l2Table
.cvid_fid
= pMcastAddr
->fid
;
628 method
= LUTREADMETHOD_MAC
;
630 if ((retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
)) != RT_ERR_OK
)
633 pMcastAddr
->priority
= l2Table
.lut_pri
;
634 pMcastAddr
->fwd_pri_en
= l2Table
.fwd_en
;
635 pMcastAddr
->igmp_asic
= l2Table
.igmp_asic
;
636 pMcastAddr
->igmp_index
= l2Table
.igmpidx
;
637 pMcastAddr
->address
= l2Table
.address
;
639 /* Get Logical port mask */
640 if ((retVal
= rtk_switch_portmask_P2L_get(l2Table
.mbr
, &pMcastAddr
->portmask
)) != RT_ERR_OK
)
647 * rtk_l2_mcastAddr_next_get
649 * Get Next L2 Multicast entry.
651 * pAddress - The Address ID
653 * pMcastAddr - L2 multicast entry structure
656 * RT_ERR_FAILED - Failed
657 * RT_ERR_SMI - SMI access error
658 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
659 * RT_ERR_INPUT - Invalid input parameters.
661 * Get the next L2 multicast entry after the current entry pointed by pAddress.
662 * The address of next entry is returned by pAddress. User can use (address + 1)
663 * as pAddress to call this API again for dumping all multicast entries is LUT.
665 rtk_api_ret_t
rtk_l2_mcastAddr_next_get(rtk_uint32
*pAddress
, rtk_l2_mcastAddr_t
*pMcastAddr
)
667 rtk_api_ret_t retVal
;
668 rtl8367c_luttb l2Table
;
670 /* Check initialization state */
671 RTK_CHK_INIT_STATE();
674 if ((pAddress
== NULL
) || (pMcastAddr
== NULL
))
677 if(*pAddress
> RTK_MAX_LUT_ADDR_ID
)
678 return RT_ERR_L2_L2UNI_PARAM
;
680 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
681 l2Table
.address
= *pAddress
;
683 if ((retVal
= rtl8367c_getAsicL2LookupTb(LUTREADMETHOD_NEXT_L2MC
, &l2Table
)) != RT_ERR_OK
)
686 if(l2Table
.address
< *pAddress
)
687 return RT_ERR_L2_ENTRY_NOTFOUND
;
689 memcpy(pMcastAddr
->mac
.octet
, l2Table
.mac
.octet
, ETHER_ADDR_LEN
);
690 pMcastAddr
->ivl
= l2Table
.ivl_svl
;
693 pMcastAddr
->vid
= l2Table
.cvid_fid
;
695 pMcastAddr
->fid
= l2Table
.cvid_fid
;
697 pMcastAddr
->priority
= l2Table
.lut_pri
;
698 pMcastAddr
->fwd_pri_en
= l2Table
.fwd_en
;
699 pMcastAddr
->igmp_asic
= l2Table
.igmp_asic
;
700 pMcastAddr
->igmp_index
= l2Table
.igmpidx
;
701 pMcastAddr
->address
= l2Table
.address
;
703 /* Get Logical port mask */
704 if ((retVal
= rtk_switch_portmask_P2L_get(l2Table
.mbr
, &pMcastAddr
->portmask
)) != RT_ERR_OK
)
707 *pAddress
= l2Table
.address
;
713 * rtk_l2_mcastAddr_del
715 * Delete LUT multicast entry.
717 * pMcastAddr - L2 multicast entry structure
722 * RT_ERR_FAILED - Failed
723 * RT_ERR_SMI - SMI access error
724 * RT_ERR_MAC - Invalid MAC address.
725 * RT_ERR_L2_FID - Invalid FID .
726 * RT_ERR_L2_VID - Invalid VID .
727 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
728 * RT_ERR_INPUT - Invalid input parameters.
730 * If the mac has existed in the LUT, it will be deleted. Otherwise, it will return RT_ERR_L2_ENTRY_NOTFOUND.
732 rtk_api_ret_t
rtk_l2_mcastAddr_del(rtk_l2_mcastAddr_t
*pMcastAddr
)
734 rtk_api_ret_t retVal
;
736 rtl8367c_luttb l2Table
;
738 /* Check initialization state */
739 RTK_CHK_INIT_STATE();
741 if(NULL
== pMcastAddr
)
742 return RT_ERR_NULL_POINTER
;
744 /* must be L2 multicast address */
745 if( (pMcastAddr
->mac
.octet
[0] & 0x01) != 0x01)
748 if(pMcastAddr
->ivl
== 1)
750 if (pMcastAddr
->vid
> RTL8367C_VIDMAX
)
751 return RT_ERR_L2_VID
;
753 else if(pMcastAddr
->ivl
== 0)
755 if (pMcastAddr
->fid
> RTL8367C_FIDMAX
)
756 return RT_ERR_L2_FID
;
761 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
763 /* fill key (MAC,FID) to get L2 entry */
764 memcpy(l2Table
.mac
.octet
, pMcastAddr
->mac
.octet
, ETHER_ADDR_LEN
);
765 l2Table
.ivl_svl
= pMcastAddr
->ivl
;
768 l2Table
.cvid_fid
= pMcastAddr
->vid
;
770 l2Table
.cvid_fid
= pMcastAddr
->fid
;
772 method
= LUTREADMETHOD_MAC
;
773 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
774 if (RT_ERR_OK
== retVal
)
776 memcpy(l2Table
.mac
.octet
, pMcastAddr
->mac
.octet
, ETHER_ADDR_LEN
);
777 l2Table
.ivl_svl
= pMcastAddr
->ivl
;
780 l2Table
.cvid_fid
= pMcastAddr
->vid
;
782 l2Table
.cvid_fid
= pMcastAddr
->fid
;
785 l2Table
.nosalearn
= 0;
786 l2Table
.sa_block
= 0;
787 l2Table
.l3lookup
= 0;
790 if((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
793 pMcastAddr
->address
= l2Table
.address
;
801 * rtk_l2_ipMcastAddr_add
803 * Add Lut IP multicast entry
805 * pIpMcastAddr - IP Multicast entry
810 * RT_ERR_FAILED - Failed
811 * RT_ERR_SMI - SMI access error
812 * RT_ERR_PORT_ID - Invalid port number.
813 * RT_ERR_L2_INDEXTBL_FULL - hashed index is full of entries.
814 * RT_ERR_PORT_MASK - Invalid portmask.
815 * RT_ERR_INPUT - Invalid input parameters.
817 * System supports L2 entry with IP multicast DIP/SIP to forward IP multicasting frame as user
818 * desired. If this function is enabled, then system will be looked up L2 IP multicast entry to
819 * forward IP multicast frame directly without flooding.
821 rtk_api_ret_t
rtk_l2_ipMcastAddr_add(rtk_l2_ipMcastAddr_t
*pIpMcastAddr
)
823 rtk_api_ret_t retVal
;
825 rtl8367c_luttb l2Table
;
828 /* Check initialization state */
829 RTK_CHK_INIT_STATE();
831 if(NULL
== pIpMcastAddr
)
832 return RT_ERR_NULL_POINTER
;
834 /* check port mask */
835 RTK_CHK_PORTMASK_VALID(&pIpMcastAddr
->portmask
);
837 if( (pIpMcastAddr
->dip
& 0xF0000000) != 0xE0000000)
840 if(pIpMcastAddr
->fwd_pri_en
>= RTK_ENABLE_END
)
841 return RT_ERR_ENABLE
;
843 if(pIpMcastAddr
->priority
> RTL8367C_PRIMAX
)
846 /* Get Physical port mask */
847 if ((retVal
= rtk_switch_portmask_L2P_get(&pIpMcastAddr
->portmask
, &pmask
)) != RT_ERR_OK
)
850 memset(&l2Table
, 0x00, sizeof(rtl8367c_luttb
));
851 l2Table
.sip
= pIpMcastAddr
->sip
;
852 l2Table
.dip
= pIpMcastAddr
->dip
;
853 l2Table
.l3lookup
= 1;
854 l2Table
.l3vidlookup
= 0;
855 method
= LUTREADMETHOD_MAC
;
856 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
857 if (RT_ERR_OK
== retVal
)
859 l2Table
.sip
= pIpMcastAddr
->sip
;
860 l2Table
.dip
= pIpMcastAddr
->dip
;
862 l2Table
.nosalearn
= 1;
863 l2Table
.l3lookup
= 1;
864 l2Table
.l3vidlookup
= 0;
865 l2Table
.lut_pri
= pIpMcastAddr
->priority
;
866 l2Table
.fwd_en
= pIpMcastAddr
->fwd_pri_en
;
867 if((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
870 pIpMcastAddr
->address
= l2Table
.address
;
873 else if (RT_ERR_L2_ENTRY_NOTFOUND
== retVal
)
875 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
876 l2Table
.sip
= pIpMcastAddr
->sip
;
877 l2Table
.dip
= pIpMcastAddr
->dip
;
879 l2Table
.nosalearn
= 1;
880 l2Table
.l3lookup
= 1;
881 l2Table
.l3vidlookup
= 0;
882 l2Table
.lut_pri
= pIpMcastAddr
->priority
;
883 l2Table
.fwd_en
= pIpMcastAddr
->fwd_pri_en
;
884 if ((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
887 pIpMcastAddr
->address
= l2Table
.address
;
889 method
= LUTREADMETHOD_MAC
;
890 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
891 if (RT_ERR_L2_ENTRY_NOTFOUND
== retVal
)
892 return RT_ERR_L2_INDEXTBL_FULL
;
903 * rtk_l2_ipMcastAddr_get
905 * Get LUT IP multicast entry.
907 * pIpMcastAddr - IP Multicast entry
909 * pIpMcastAddr - IP Multicast entry
912 * RT_ERR_FAILED - Failed
913 * RT_ERR_SMI - SMI access error
914 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
915 * RT_ERR_INPUT - Invalid input parameters.
917 * The API can get Lut table of IP multicast entry.
919 rtk_api_ret_t
rtk_l2_ipMcastAddr_get(rtk_l2_ipMcastAddr_t
*pIpMcastAddr
)
921 rtk_api_ret_t retVal
;
923 rtl8367c_luttb l2Table
;
925 /* Check initialization state */
926 RTK_CHK_INIT_STATE();
928 if(NULL
== pIpMcastAddr
)
929 return RT_ERR_NULL_POINTER
;
931 if( (pIpMcastAddr
->dip
& 0xF0000000) != 0xE0000000)
934 memset(&l2Table
, 0x00, sizeof(rtl8367c_luttb
));
935 l2Table
.sip
= pIpMcastAddr
->sip
;
936 l2Table
.dip
= pIpMcastAddr
->dip
;
937 l2Table
.l3lookup
= 1;
938 l2Table
.l3vidlookup
= 0;
939 method
= LUTREADMETHOD_MAC
;
940 if ((retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
)) != RT_ERR_OK
)
943 /* Get Logical port mask */
944 if ((retVal
= rtk_switch_portmask_P2L_get(l2Table
.mbr
, &pIpMcastAddr
->portmask
)) != RT_ERR_OK
)
947 pIpMcastAddr
->priority
= l2Table
.lut_pri
;
948 pIpMcastAddr
->fwd_pri_en
= l2Table
.fwd_en
;
949 pIpMcastAddr
->igmp_asic
= l2Table
.igmp_asic
;
950 pIpMcastAddr
->igmp_index
= l2Table
.igmpidx
;
951 pIpMcastAddr
->address
= l2Table
.address
;
957 * rtk_l2_ipMcastAddr_next_get
959 * Get Next IP Multicast entry.
961 * pAddress - The Address ID
963 * pIpMcastAddr - IP Multicast entry
966 * RT_ERR_FAILED - Failed
967 * RT_ERR_SMI - SMI access error
968 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
969 * RT_ERR_INPUT - Invalid input parameters.
971 * Get the next IP multicast entry after the current entry pointed by pAddress.
972 * The address of next entry is returned by pAddress. User can use (address + 1)
973 * as pAddress to call this API again for dumping all IP multicast entries is LUT.
975 rtk_api_ret_t
rtk_l2_ipMcastAddr_next_get(rtk_uint32
*pAddress
, rtk_l2_ipMcastAddr_t
*pIpMcastAddr
)
977 rtk_api_ret_t retVal
;
978 rtl8367c_luttb l2Table
;
980 /* Check initialization state */
981 RTK_CHK_INIT_STATE();
984 if ((pAddress
== NULL
) || (pIpMcastAddr
== NULL
) )
987 if(*pAddress
> RTK_MAX_LUT_ADDR_ID
)
988 return RT_ERR_L2_L2UNI_PARAM
;
990 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
991 l2Table
.address
= *pAddress
;
995 if ((retVal
= rtl8367c_getAsicL2LookupTb(LUTREADMETHOD_NEXT_L3MC
, &l2Table
)) != RT_ERR_OK
)
998 if(l2Table
.address
< *pAddress
)
999 return RT_ERR_L2_ENTRY_NOTFOUND
;
1001 }while(l2Table
.l3vidlookup
== 1);
1003 pIpMcastAddr
->sip
= l2Table
.sip
;
1004 pIpMcastAddr
->dip
= l2Table
.dip
;
1006 /* Get Logical port mask */
1007 if ((retVal
= rtk_switch_portmask_P2L_get(l2Table
.mbr
, &pIpMcastAddr
->portmask
)) != RT_ERR_OK
)
1010 pIpMcastAddr
->priority
= l2Table
.lut_pri
;
1011 pIpMcastAddr
->fwd_pri_en
= l2Table
.fwd_en
;
1012 pIpMcastAddr
->igmp_asic
= l2Table
.igmp_asic
;
1013 pIpMcastAddr
->igmp_index
= l2Table
.igmpidx
;
1014 pIpMcastAddr
->address
= l2Table
.address
;
1015 *pAddress
= l2Table
.address
;
1021 * rtk_l2_ipMcastAddr_del
1023 * Delete a ip multicast address entry from the specified device.
1025 * pIpMcastAddr - IP Multicast entry
1030 * RT_ERR_FAILED - Failed
1031 * RT_ERR_SMI - SMI access error
1032 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
1033 * RT_ERR_INPUT - Invalid input parameters.
1035 * The API can delete a IP multicast address entry from the specified device.
1037 rtk_api_ret_t
rtk_l2_ipMcastAddr_del(rtk_l2_ipMcastAddr_t
*pIpMcastAddr
)
1039 rtk_api_ret_t retVal
;
1041 rtl8367c_luttb l2Table
;
1043 /* Check initialization state */
1044 RTK_CHK_INIT_STATE();
1046 /* Error Checking */
1047 if (pIpMcastAddr
== NULL
)
1048 return RT_ERR_INPUT
;
1050 if( (pIpMcastAddr
->dip
& 0xF0000000) != 0xE0000000)
1051 return RT_ERR_INPUT
;
1053 memset(&l2Table
, 0x00, sizeof(rtl8367c_luttb
));
1054 l2Table
.sip
= pIpMcastAddr
->sip
;
1055 l2Table
.dip
= pIpMcastAddr
->dip
;
1056 l2Table
.l3lookup
= 1;
1057 l2Table
.l3vidlookup
= 0;
1058 method
= LUTREADMETHOD_MAC
;
1059 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
1060 if (RT_ERR_OK
== retVal
)
1062 l2Table
.sip
= pIpMcastAddr
->sip
;
1063 l2Table
.dip
= pIpMcastAddr
->dip
;
1065 l2Table
.nosalearn
= 0;
1066 l2Table
.l3lookup
= 1;
1067 l2Table
.l3vidlookup
= 0;
1068 l2Table
.lut_pri
= 0;
1070 if((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
1073 pIpMcastAddr
->address
= l2Table
.address
;
1081 * rtk_l2_ipVidMcastAddr_add
1083 * Add Lut IP multicast+VID entry
1085 * pIpVidMcastAddr - IP & VID multicast Entry
1090 * RT_ERR_FAILED - Failed
1091 * RT_ERR_SMI - SMI access error
1092 * RT_ERR_PORT_ID - Invalid port number.
1093 * RT_ERR_L2_INDEXTBL_FULL - hashed index is full of entries.
1094 * RT_ERR_PORT_MASK - Invalid portmask.
1095 * RT_ERR_INPUT - Invalid input parameters.
1099 rtk_api_ret_t
rtk_l2_ipVidMcastAddr_add(rtk_l2_ipVidMcastAddr_t
*pIpVidMcastAddr
)
1101 rtk_api_ret_t retVal
;
1103 rtl8367c_luttb l2Table
;
1106 /* Check initialization state */
1107 RTK_CHK_INIT_STATE();
1109 if(NULL
== pIpVidMcastAddr
)
1110 return RT_ERR_NULL_POINTER
;
1112 /* check port mask */
1113 RTK_CHK_PORTMASK_VALID(&pIpVidMcastAddr
->portmask
);
1115 if (pIpVidMcastAddr
->vid
> RTL8367C_VIDMAX
)
1116 return RT_ERR_L2_VID
;
1118 if( (pIpVidMcastAddr
->dip
& 0xF0000000) != 0xE0000000)
1119 return RT_ERR_INPUT
;
1121 /* Get Physical port mask */
1122 if ((retVal
= rtk_switch_portmask_L2P_get(&pIpVidMcastAddr
->portmask
, &pmask
)) != RT_ERR_OK
)
1125 memset(&l2Table
, 0x00, sizeof(rtl8367c_luttb
));
1126 l2Table
.sip
= pIpVidMcastAddr
->sip
;
1127 l2Table
.dip
= pIpVidMcastAddr
->dip
;
1128 l2Table
.l3lookup
= 1;
1129 l2Table
.l3vidlookup
= 1;
1130 l2Table
.l3_vid
= pIpVidMcastAddr
->vid
;
1131 method
= LUTREADMETHOD_MAC
;
1132 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
1133 if (RT_ERR_OK
== retVal
)
1135 l2Table
.sip
= pIpVidMcastAddr
->sip
;
1136 l2Table
.dip
= pIpVidMcastAddr
->dip
;
1137 l2Table
.mbr
= pmask
;
1138 l2Table
.nosalearn
= 1;
1139 l2Table
.l3lookup
= 1;
1140 l2Table
.l3vidlookup
= 1;
1141 l2Table
.l3_vid
= pIpVidMcastAddr
->vid
;
1142 if((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
1145 pIpVidMcastAddr
->address
= l2Table
.address
;
1148 else if (RT_ERR_L2_ENTRY_NOTFOUND
== retVal
)
1150 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
1151 l2Table
.sip
= pIpVidMcastAddr
->sip
;
1152 l2Table
.dip
= pIpVidMcastAddr
->dip
;
1153 l2Table
.mbr
= pmask
;
1154 l2Table
.nosalearn
= 1;
1155 l2Table
.l3lookup
= 1;
1156 l2Table
.l3vidlookup
= 1;
1157 l2Table
.l3_vid
= pIpVidMcastAddr
->vid
;
1158 if ((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
1161 pIpVidMcastAddr
->address
= l2Table
.address
;
1163 method
= LUTREADMETHOD_MAC
;
1164 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
1165 if (RT_ERR_L2_ENTRY_NOTFOUND
== retVal
)
1166 return RT_ERR_L2_INDEXTBL_FULL
;
1176 * rtk_l2_ipVidMcastAddr_get
1178 * Get LUT IP multicast+VID entry.
1180 * pIpVidMcastAddr - IP & VID multicast Entry
1182 * pIpVidMcastAddr - IP & VID multicast Entry
1185 * RT_ERR_FAILED - Failed
1186 * RT_ERR_SMI - SMI access error
1187 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
1188 * RT_ERR_INPUT - Invalid input parameters.
1192 rtk_api_ret_t
rtk_l2_ipVidMcastAddr_get(rtk_l2_ipVidMcastAddr_t
*pIpVidMcastAddr
)
1194 rtk_api_ret_t retVal
;
1196 rtl8367c_luttb l2Table
;
1198 /* Check initialization state */
1199 RTK_CHK_INIT_STATE();
1201 if(NULL
== pIpVidMcastAddr
)
1202 return RT_ERR_NULL_POINTER
;
1204 if (pIpVidMcastAddr
->vid
> RTL8367C_VIDMAX
)
1205 return RT_ERR_L2_VID
;
1207 if( (pIpVidMcastAddr
->dip
& 0xF0000000) != 0xE0000000)
1208 return RT_ERR_INPUT
;
1210 memset(&l2Table
, 0x00, sizeof(rtl8367c_luttb
));
1211 l2Table
.sip
= pIpVidMcastAddr
->sip
;
1212 l2Table
.dip
= pIpVidMcastAddr
->dip
;
1213 l2Table
.l3lookup
= 1;
1214 l2Table
.l3vidlookup
= 1;
1215 l2Table
.l3_vid
= pIpVidMcastAddr
->vid
;
1216 method
= LUTREADMETHOD_MAC
;
1217 if ((retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
)) != RT_ERR_OK
)
1220 pIpVidMcastAddr
->address
= l2Table
.address
;
1222 /* Get Logical port mask */
1223 if ((retVal
= rtk_switch_portmask_P2L_get(l2Table
.mbr
, &pIpVidMcastAddr
->portmask
)) != RT_ERR_OK
)
1230 * rtk_l2_ipVidMcastAddr_next_get
1232 * Get Next IP Multicast+VID entry.
1234 * pAddress - The Address ID
1236 * pIpVidMcastAddr - IP & VID multicast Entry
1239 * RT_ERR_FAILED - Failed
1240 * RT_ERR_SMI - SMI access error
1241 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
1242 * RT_ERR_INPUT - Invalid input parameters.
1244 * Get the next IP multicast entry after the current entry pointed by pAddress.
1245 * The address of next entry is returned by pAddress. User can use (address + 1)
1246 * as pAddress to call this API again for dumping all IP multicast entries is LUT.
1248 rtk_api_ret_t
rtk_l2_ipVidMcastAddr_next_get(rtk_uint32
*pAddress
, rtk_l2_ipVidMcastAddr_t
*pIpVidMcastAddr
)
1250 rtk_api_ret_t retVal
;
1251 rtl8367c_luttb l2Table
;
1253 /* Check initialization state */
1254 RTK_CHK_INIT_STATE();
1256 /* Error Checking */
1257 if ((pAddress
== NULL
) || (pIpVidMcastAddr
== NULL
))
1258 return RT_ERR_INPUT
;
1260 if(*pAddress
> RTK_MAX_LUT_ADDR_ID
)
1261 return RT_ERR_L2_L2UNI_PARAM
;
1263 memset(&l2Table
, 0, sizeof(rtl8367c_luttb
));
1264 l2Table
.address
= *pAddress
;
1268 if ((retVal
= rtl8367c_getAsicL2LookupTb(LUTREADMETHOD_NEXT_L3MC
, &l2Table
)) != RT_ERR_OK
)
1271 if(l2Table
.address
< *pAddress
)
1272 return RT_ERR_L2_ENTRY_NOTFOUND
;
1274 }while(l2Table
.l3vidlookup
== 0);
1276 pIpVidMcastAddr
->sip
= l2Table
.sip
;
1277 pIpVidMcastAddr
->dip
= l2Table
.dip
;
1278 pIpVidMcastAddr
->vid
= l2Table
.l3_vid
;
1279 pIpVidMcastAddr
->address
= l2Table
.address
;
1281 /* Get Logical port mask */
1282 if ((retVal
= rtk_switch_portmask_P2L_get(l2Table
.mbr
, &pIpVidMcastAddr
->portmask
)) != RT_ERR_OK
)
1285 *pAddress
= l2Table
.address
;
1291 * rtk_l2_ipVidMcastAddr_del
1293 * Delete a ip multicast+VID address entry from the specified device.
1295 * pIpVidMcastAddr - IP & VID multicast Entry
1300 * RT_ERR_FAILED - Failed
1301 * RT_ERR_SMI - SMI access error
1302 * RT_ERR_L2_ENTRY_NOTFOUND - No such LUT entry.
1303 * RT_ERR_INPUT - Invalid input parameters.
1307 rtk_api_ret_t
rtk_l2_ipVidMcastAddr_del(rtk_l2_ipVidMcastAddr_t
*pIpVidMcastAddr
)
1309 rtk_api_ret_t retVal
;
1311 rtl8367c_luttb l2Table
;
1313 /* Check initialization state */
1314 RTK_CHK_INIT_STATE();
1316 if(NULL
== pIpVidMcastAddr
)
1317 return RT_ERR_NULL_POINTER
;
1319 if (pIpVidMcastAddr
->vid
> RTL8367C_VIDMAX
)
1320 return RT_ERR_L2_VID
;
1322 if( (pIpVidMcastAddr
->dip
& 0xF0000000) != 0xE0000000)
1323 return RT_ERR_INPUT
;
1325 memset(&l2Table
, 0x00, sizeof(rtl8367c_luttb
));
1326 l2Table
.sip
= pIpVidMcastAddr
->sip
;
1327 l2Table
.dip
= pIpVidMcastAddr
->dip
;
1328 l2Table
.l3lookup
= 1;
1329 l2Table
.l3vidlookup
= 1;
1330 l2Table
.l3_vid
= pIpVidMcastAddr
->vid
;
1331 method
= LUTREADMETHOD_MAC
;
1332 retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
);
1333 if (RT_ERR_OK
== retVal
)
1335 l2Table
.sip
= pIpVidMcastAddr
->sip
;
1336 l2Table
.dip
= pIpVidMcastAddr
->dip
;
1338 l2Table
.nosalearn
= 0;
1339 l2Table
.l3lookup
= 1;
1340 l2Table
.l3vidlookup
= 1;
1341 l2Table
.l3_vid
= pIpVidMcastAddr
->vid
;
1342 if((retVal
= rtl8367c_setAsicL2LookupTb(&l2Table
)) != RT_ERR_OK
)
1345 pIpVidMcastAddr
->address
= l2Table
.address
;
1353 * rtk_l2_ucastAddr_flush
1355 * Flush L2 mac address by type in the specified device (both dynamic and static).
1357 * pConfig - flush configuration
1362 * RT_ERR_FAILED - Failed
1363 * RT_ERR_SMI - SMI access error
1364 * RT_ERR_PORT_ID - Invalid port number.
1365 * RT_ERR_VLAN_VID - Invalid VID parameter.
1366 * RT_ERR_INPUT - Invalid input parameters.
1368 * flushByVid - 1: Flush by VID, 0: Don't flush by VID
1369 * vid - VID (0 ~ 4095)
1370 * flushByFid - 1: Flush by FID, 0: Don't flush by FID
1371 * fid - FID (0 ~ 15)
1372 * flushByPort - 1: Flush by Port, 0: Don't flush by Port
1374 * flushByMac - Not Supported
1375 * ucastAddr - Not Supported
1376 * flushStaticAddr - 1: Flush both Static and Dynamic entries, 0: Flush only Dynamic entries
1377 * flushAddrOnAllPorts - 1: Flush VID-matched entries at all ports, 0: Flush VID-matched entries per port.
1379 rtk_api_ret_t
rtk_l2_ucastAddr_flush(rtk_l2_flushCfg_t
*pConfig
)
1381 rtk_api_ret_t retVal
;
1383 /* Check initialization state */
1384 RTK_CHK_INIT_STATE();
1387 return RT_ERR_NULL_POINTER
;
1389 if(pConfig
->flushByVid
>= RTK_ENABLE_END
)
1390 return RT_ERR_ENABLE
;
1392 if(pConfig
->flushByFid
>= RTK_ENABLE_END
)
1393 return RT_ERR_ENABLE
;
1395 if(pConfig
->flushByPort
>= RTK_ENABLE_END
)
1396 return RT_ERR_ENABLE
;
1398 if(pConfig
->flushByMac
>= RTK_ENABLE_END
)
1399 return RT_ERR_ENABLE
;
1401 if(pConfig
->flushStaticAddr
>= RTK_ENABLE_END
)
1402 return RT_ERR_ENABLE
;
1404 if(pConfig
->flushAddrOnAllPorts
>= RTK_ENABLE_END
)
1405 return RT_ERR_ENABLE
;
1407 if(pConfig
->vid
> RTL8367C_VIDMAX
)
1408 return RT_ERR_VLAN_VID
;
1410 if(pConfig
->fid
> RTL8367C_FIDMAX
)
1411 return RT_ERR_INPUT
;
1413 /* check port valid */
1414 RTK_CHK_PORT_VALID(pConfig
->port
);
1416 if(pConfig
->flushByVid
== ENABLED
)
1418 if ((retVal
= rtl8367c_setAsicLutFlushMode(FLUSHMDOE_VID
)) != RT_ERR_OK
)
1421 if ((retVal
= rtl8367c_setAsicLutFlushVid(pConfig
->vid
)) != RT_ERR_OK
)
1424 if ((retVal
= rtl8367c_setAsicLutFlushType((pConfig
->flushStaticAddr
== ENABLED
) ? FLUSHTYPE_BOTH
: FLUSHTYPE_DYNAMIC
)) != RT_ERR_OK
)
1427 if(pConfig
->flushAddrOnAllPorts
== ENABLED
)
1429 if ((retVal
= rtl8367c_setAsicLutForceFlush(RTL8367C_PORTMASK
)) != RT_ERR_OK
)
1432 else if(pConfig
->flushByPort
== ENABLED
)
1434 if ((retVal
= rtl8367c_setAsicLutForceFlush(1 << rtk_switch_port_L2P_get(pConfig
->port
))) != RT_ERR_OK
)
1438 return RT_ERR_INPUT
;
1440 else if(pConfig
->flushByFid
== ENABLED
)
1442 if ((retVal
= rtl8367c_setAsicLutFlushMode(FLUSHMDOE_FID
)) != RT_ERR_OK
)
1445 if ((retVal
= rtl8367c_setAsicLutFlushFid(pConfig
->fid
)) != RT_ERR_OK
)
1448 if ((retVal
= rtl8367c_setAsicLutFlushType((pConfig
->flushStaticAddr
== ENABLED
) ? FLUSHTYPE_BOTH
: FLUSHTYPE_DYNAMIC
)) != RT_ERR_OK
)
1451 if(pConfig
->flushAddrOnAllPorts
== ENABLED
)
1453 if ((retVal
= rtl8367c_setAsicLutForceFlush(RTL8367C_PORTMASK
)) != RT_ERR_OK
)
1456 else if(pConfig
->flushByPort
== ENABLED
)
1458 if ((retVal
= rtl8367c_setAsicLutForceFlush(1 << rtk_switch_port_L2P_get(pConfig
->port
))) != RT_ERR_OK
)
1462 return RT_ERR_INPUT
;
1464 else if(pConfig
->flushByPort
== ENABLED
)
1466 if ((retVal
= rtl8367c_setAsicLutFlushType((pConfig
->flushStaticAddr
== ENABLED
) ? FLUSHTYPE_BOTH
: FLUSHTYPE_DYNAMIC
)) != RT_ERR_OK
)
1469 if ((retVal
= rtl8367c_setAsicLutFlushMode(FLUSHMDOE_PORT
)) != RT_ERR_OK
)
1472 if ((retVal
= rtl8367c_setAsicLutForceFlush(1 << rtk_switch_port_L2P_get(pConfig
->port
))) != RT_ERR_OK
)
1475 else if(pConfig
->flushByMac
== ENABLED
)
1477 /* Should use API "rtk_l2_addr_del" to remove a specified entry*/
1478 return RT_ERR_CHIP_NOT_SUPPORTED
;
1481 return RT_ERR_INPUT
;
1487 * rtk_l2_table_clear
1489 * Flush all static & dynamic entries in LUT.
1496 * RT_ERR_FAILED - Failed
1497 * RT_ERR_SMI - SMI access error
1501 rtk_api_ret_t
rtk_l2_table_clear(void)
1503 rtk_api_ret_t retVal
;
1505 /* Check initialization state */
1506 RTK_CHK_INIT_STATE();
1508 if ((retVal
= rtl8367c_setAsicLutFlushAll()) != RT_ERR_OK
)
1515 * rtk_l2_table_clearStatus_get
1517 * Get table clear status
1521 * pStatus - Clear status, 1:Busy, 0:finish
1524 * RT_ERR_FAILED - Failed
1525 * RT_ERR_SMI - SMI access error
1529 rtk_api_ret_t
rtk_l2_table_clearStatus_get(rtk_l2_clearStatus_t
*pStatus
)
1531 rtk_api_ret_t retVal
;
1533 /* Check initialization state */
1534 RTK_CHK_INIT_STATE();
1537 return RT_ERR_NULL_POINTER
;
1539 if ((retVal
= rtl8367c_getAsicLutFlushAllStatus((rtk_uint32
*)pStatus
)) != RT_ERR_OK
)
1546 * rtk_l2_flushLinkDownPortAddrEnable_set
1548 * Set HW flush linkdown port mac configuration of the specified device.
1551 * enable - link down flush status
1556 * RT_ERR_FAILED - Failed
1557 * RT_ERR_SMI - SMI access error
1558 * RT_ERR_PORT_ID - Invalid port number.
1559 * RT_ERR_ENABLE - Invalid enable input.
1561 * The status of flush linkdown port address is as following:
1565 rtk_api_ret_t
rtk_l2_flushLinkDownPortAddrEnable_set(rtk_port_t port
, rtk_enable_t enable
)
1567 rtk_api_ret_t retVal
;
1569 /* Check initialization state */
1570 RTK_CHK_INIT_STATE();
1572 if (port
!= RTK_WHOLE_SYSTEM
)
1573 return RT_ERR_PORT_ID
;
1575 if (enable
>= RTK_ENABLE_END
)
1576 return RT_ERR_ENABLE
;
1578 if ((retVal
= rtl8367c_setAsicLutLinkDownForceAging(enable
)) != RT_ERR_OK
)
1586 * rtk_l2_flushLinkDownPortAddrEnable_get
1588 * Get HW flush linkdown port mac configuration of the specified device.
1592 * pEnable - link down flush status
1595 * RT_ERR_FAILED - Failed
1596 * RT_ERR_SMI - SMI access error
1597 * RT_ERR_PORT_ID - Invalid port number.
1599 * The status of flush linkdown port address is as following:
1603 rtk_api_ret_t
rtk_l2_flushLinkDownPortAddrEnable_get(rtk_port_t port
, rtk_enable_t
*pEnable
)
1605 rtk_api_ret_t retVal
;
1607 /* Check initialization state */
1608 RTK_CHK_INIT_STATE();
1610 if (port
!= RTK_WHOLE_SYSTEM
)
1611 return RT_ERR_PORT_ID
;
1614 return RT_ERR_NULL_POINTER
;
1616 if ((retVal
= rtl8367c_getAsicLutLinkDownForceAging(pEnable
)) != RT_ERR_OK
)
1623 * rtk_l2_agingEnable_set
1625 * Set L2 LUT aging status per port setting.
1628 * enable - Aging status
1633 * RT_ERR_FAILED - Failed
1634 * RT_ERR_SMI - SMI access error
1635 * RT_ERR_PORT_ID - Invalid port number.
1636 * RT_ERR_ENABLE - Invalid enable input.
1638 * This API can be used to set L2 LUT aging status per port.
1640 rtk_api_ret_t
rtk_l2_agingEnable_set(rtk_port_t port
, rtk_enable_t enable
)
1642 rtk_api_ret_t retVal
;
1644 /* Check initialization state */
1645 RTK_CHK_INIT_STATE();
1647 /* check port valid */
1648 RTK_CHK_PORT_VALID(port
);
1650 if (enable
>= RTK_ENABLE_END
)
1651 return RT_ERR_ENABLE
;
1658 if ((retVal
= rtl8367c_setAsicLutDisableAging(rtk_switch_port_L2P_get(port
), enable
)) != RT_ERR_OK
)
1665 * rtk_l2_agingEnable_get
1667 * Get L2 LUT aging status per port setting.
1671 * pEnable - Aging status
1674 * RT_ERR_FAILED - Failed
1675 * RT_ERR_SMI - SMI access error
1676 * RT_ERR_PORT_ID - Invalid port number.
1678 * This API can be used to get L2 LUT aging function per port.
1680 rtk_api_ret_t
rtk_l2_agingEnable_get(rtk_port_t port
, rtk_enable_t
*pEnable
)
1682 rtk_api_ret_t retVal
;
1684 /* Check initialization state */
1685 RTK_CHK_INIT_STATE();
1687 /* check port valid */
1688 RTK_CHK_PORT_VALID(port
);
1691 return RT_ERR_NULL_POINTER
;
1693 if ((retVal
= rtl8367c_getAsicLutDisableAging(rtk_switch_port_L2P_get(port
), pEnable
)) != RT_ERR_OK
)
1705 * rtk_l2_limitLearningCnt_set
1707 * Set per-Port auto learning limit number
1710 * mac_cnt - Auto learning entries limit number
1715 * RT_ERR_FAILED - Failed
1716 * RT_ERR_SMI - SMI access error
1717 * RT_ERR_PORT_ID - Invalid port number.
1718 * RT_ERR_LIMITED_L2ENTRY_NUM - Invalid auto learning limit number
1720 * The API can set per-port ASIC auto learning limit number from 0(disable learning)
1723 rtk_api_ret_t
rtk_l2_limitLearningCnt_set(rtk_port_t port
, rtk_mac_cnt_t mac_cnt
)
1725 rtk_api_ret_t retVal
;
1727 /* Check initialization state */
1728 RTK_CHK_INIT_STATE();
1730 /* check port valid */
1731 RTK_CHK_PORT_VALID(port
);
1733 if (mac_cnt
> rtk_switch_maxLutAddrNumber_get())
1734 return RT_ERR_LIMITED_L2ENTRY_NUM
;
1736 if ((retVal
= rtl8367c_setAsicLutLearnLimitNo(rtk_switch_port_L2P_get(port
), mac_cnt
)) != RT_ERR_OK
)
1743 * rtk_l2_limitLearningCnt_get
1745 * Get per-Port auto learning limit number
1749 * pMac_cnt - Auto learning entries limit number
1752 * RT_ERR_FAILED - Failed
1753 * RT_ERR_SMI - SMI access error
1754 * RT_ERR_PORT_ID - Invalid port number.
1756 * The API can get per-port ASIC auto learning limit number.
1758 rtk_api_ret_t
rtk_l2_limitLearningCnt_get(rtk_port_t port
, rtk_mac_cnt_t
*pMac_cnt
)
1760 rtk_api_ret_t retVal
;
1762 /* Check initialization state */
1763 RTK_CHK_INIT_STATE();
1765 /* check port valid */
1766 RTK_CHK_PORT_VALID(port
);
1768 if(NULL
== pMac_cnt
)
1769 return RT_ERR_NULL_POINTER
;
1771 if ((retVal
= rtl8367c_getAsicLutLearnLimitNo(rtk_switch_port_L2P_get(port
), pMac_cnt
)) != RT_ERR_OK
)
1778 * rtk_l2_limitSystemLearningCnt_set
1780 * Set System auto learning limit number
1782 * mac_cnt - Auto learning entries limit number
1787 * RT_ERR_FAILED - Failed
1788 * RT_ERR_SMI - SMI access error
1789 * RT_ERR_LIMITED_L2ENTRY_NUM - Invalid auto learning limit number
1791 * The API can set system ASIC auto learning limit number from 0(disable learning)
1794 rtk_api_ret_t
rtk_l2_limitSystemLearningCnt_set(rtk_mac_cnt_t mac_cnt
)
1796 rtk_api_ret_t retVal
;
1798 /* Check initialization state */
1799 RTK_CHK_INIT_STATE();
1801 if (mac_cnt
> rtk_switch_maxLutAddrNumber_get())
1802 return RT_ERR_LIMITED_L2ENTRY_NUM
;
1804 if ((retVal
= rtl8367c_setAsicSystemLutLearnLimitNo(mac_cnt
)) != RT_ERR_OK
)
1811 * rtk_l2_limitSystemLearningCnt_get
1813 * Get System auto learning limit number
1817 * pMac_cnt - Auto learning entries limit number
1820 * RT_ERR_FAILED - Failed
1821 * RT_ERR_SMI - SMI access error
1822 * RT_ERR_PORT_ID - Invalid port number.
1824 * The API can get system ASIC auto learning limit number.
1826 rtk_api_ret_t
rtk_l2_limitSystemLearningCnt_get(rtk_mac_cnt_t
*pMac_cnt
)
1828 rtk_api_ret_t retVal
;
1830 /* Check initialization state */
1831 RTK_CHK_INIT_STATE();
1833 if(NULL
== pMac_cnt
)
1834 return RT_ERR_NULL_POINTER
;
1836 if ((retVal
= rtl8367c_getAsicSystemLutLearnLimitNo(pMac_cnt
)) != RT_ERR_OK
)
1843 * rtk_l2_limitLearningCntAction_set
1845 * Configure auto learn over limit number action.
1848 * action - Auto learning entries limit number
1853 * RT_ERR_FAILED - Failed
1854 * RT_ERR_SMI - SMI access error
1855 * RT_ERR_PORT_ID - Invalid port number.
1856 * RT_ERR_NOT_ALLOWED - Invalid learn over action
1858 * The API can set SA unknown packet action while auto learn limit number is over
1859 * The action symbol as following:
1860 * - LIMIT_LEARN_CNT_ACTION_DROP,
1861 * - LIMIT_LEARN_CNT_ACTION_FORWARD,
1862 * - LIMIT_LEARN_CNT_ACTION_TO_CPU,
1864 rtk_api_ret_t
rtk_l2_limitLearningCntAction_set(rtk_port_t port
, rtk_l2_limitLearnCntAction_t action
)
1866 rtk_api_ret_t retVal
;
1869 /* Check initialization state */
1870 RTK_CHK_INIT_STATE();
1872 if (port
!= RTK_WHOLE_SYSTEM
)
1873 return RT_ERR_PORT_ID
;
1875 if ( LIMIT_LEARN_CNT_ACTION_DROP
== action
)
1877 else if ( LIMIT_LEARN_CNT_ACTION_FORWARD
== action
)
1879 else if ( LIMIT_LEARN_CNT_ACTION_TO_CPU
== action
)
1882 return RT_ERR_NOT_ALLOWED
;
1884 if ((retVal
= rtl8367c_setAsicLutLearnOverAct(data
)) != RT_ERR_OK
)
1891 * rtk_l2_limitLearningCntAction_get
1893 * Get auto learn over limit number action.
1897 * pAction - Learn over action
1900 * RT_ERR_FAILED - Failed
1901 * RT_ERR_SMI - SMI access error
1902 * RT_ERR_PORT_ID - Invalid port number.
1904 * The API can get SA unknown packet action while auto learn limit number is over
1905 * The action symbol as following:
1906 * - LIMIT_LEARN_CNT_ACTION_DROP,
1907 * - LIMIT_LEARN_CNT_ACTION_FORWARD,
1908 * - LIMIT_LEARN_CNT_ACTION_TO_CPU,
1910 rtk_api_ret_t
rtk_l2_limitLearningCntAction_get(rtk_port_t port
, rtk_l2_limitLearnCntAction_t
*pAction
)
1912 rtk_api_ret_t retVal
;
1915 /* Check initialization state */
1916 RTK_CHK_INIT_STATE();
1918 if (port
!= RTK_WHOLE_SYSTEM
)
1919 return RT_ERR_PORT_ID
;
1922 return RT_ERR_NULL_POINTER
;
1924 if ((retVal
= rtl8367c_getAsicLutLearnOverAct(&action
)) != RT_ERR_OK
)
1928 *pAction
= LIMIT_LEARN_CNT_ACTION_DROP
;
1929 else if ( 0 == action
)
1930 *pAction
= LIMIT_LEARN_CNT_ACTION_FORWARD
;
1931 else if ( 2 == action
)
1932 *pAction
= LIMIT_LEARN_CNT_ACTION_TO_CPU
;
1940 * rtk_l2_limitSystemLearningCntAction_set
1942 * Configure system auto learn over limit number action.
1945 * action - Auto learning entries limit number
1950 * RT_ERR_FAILED - Failed
1951 * RT_ERR_SMI - SMI access error
1952 * RT_ERR_PORT_ID - Invalid port number.
1953 * RT_ERR_NOT_ALLOWED - Invalid learn over action
1955 * The API can set SA unknown packet action while auto learn limit number is over
1956 * The action symbol as following:
1957 * - LIMIT_LEARN_CNT_ACTION_DROP,
1958 * - LIMIT_LEARN_CNT_ACTION_FORWARD,
1959 * - LIMIT_LEARN_CNT_ACTION_TO_CPU,
1961 rtk_api_ret_t
rtk_l2_limitSystemLearningCntAction_set(rtk_l2_limitLearnCntAction_t action
)
1963 rtk_api_ret_t retVal
;
1966 /* Check initialization state */
1967 RTK_CHK_INIT_STATE();
1969 if ( LIMIT_LEARN_CNT_ACTION_DROP
== action
)
1971 else if ( LIMIT_LEARN_CNT_ACTION_FORWARD
== action
)
1973 else if ( LIMIT_LEARN_CNT_ACTION_TO_CPU
== action
)
1976 return RT_ERR_NOT_ALLOWED
;
1978 if ((retVal
= rtl8367c_setAsicSystemLutLearnOverAct(data
)) != RT_ERR_OK
)
1985 * rtk_l2_limitSystemLearningCntAction_get
1987 * Get system auto learn over limit number action.
1991 * pAction - Learn over action
1994 * RT_ERR_FAILED - Failed
1995 * RT_ERR_SMI - SMI access error
1996 * RT_ERR_PORT_ID - Invalid port number.
1998 * The API can get SA unknown packet action while auto learn limit number is over
1999 * The action symbol as following:
2000 * - LIMIT_LEARN_CNT_ACTION_DROP,
2001 * - LIMIT_LEARN_CNT_ACTION_FORWARD,
2002 * - LIMIT_LEARN_CNT_ACTION_TO_CPU,
2004 rtk_api_ret_t
rtk_l2_limitSystemLearningCntAction_get(rtk_l2_limitLearnCntAction_t
*pAction
)
2006 rtk_api_ret_t retVal
;
2009 /* Check initialization state */
2010 RTK_CHK_INIT_STATE();
2013 return RT_ERR_NULL_POINTER
;
2015 if ((retVal
= rtl8367c_getAsicSystemLutLearnOverAct(&action
)) != RT_ERR_OK
)
2019 *pAction
= LIMIT_LEARN_CNT_ACTION_DROP
;
2020 else if ( 0 == action
)
2021 *pAction
= LIMIT_LEARN_CNT_ACTION_FORWARD
;
2022 else if ( 2 == action
)
2023 *pAction
= LIMIT_LEARN_CNT_ACTION_TO_CPU
;
2031 * rtk_l2_limitSystemLearningCntPortMask_set
2033 * Configure system auto learn portmask
2035 * pPortmask - Port Mask
2040 * RT_ERR_FAILED - Failed
2041 * RT_ERR_SMI - SMI access error
2042 * RT_ERR_PORT_MASK - Invalid port mask.
2046 rtk_api_ret_t
rtk_l2_limitSystemLearningCntPortMask_set(rtk_portmask_t
*pPortmask
)
2048 rtk_api_ret_t retVal
;
2051 /* Check initialization state */
2052 RTK_CHK_INIT_STATE();
2054 if(NULL
== pPortmask
)
2055 return RT_ERR_NULL_POINTER
;
2057 /* Check port mask */
2058 RTK_CHK_PORTMASK_VALID(pPortmask
);
2060 if ((retVal
= rtk_switch_portmask_L2P_get(pPortmask
, &pmask
)) != RT_ERR_OK
)
2063 if ((retVal
= rtl8367c_setAsicSystemLutLearnPortMask(pmask
)) != RT_ERR_OK
)
2070 * rtk_l2_limitSystemLearningCntPortMask_get
2072 * get system auto learn portmask
2076 * pPortmask - Port Mask
2079 * RT_ERR_FAILED - Failed
2080 * RT_ERR_SMI - SMI access error
2081 * RT_ERR_NULL_POINTER - Null pointer.
2085 rtk_api_ret_t
rtk_l2_limitSystemLearningCntPortMask_get(rtk_portmask_t
*pPortmask
)
2087 rtk_api_ret_t retVal
;
2090 /* Check initialization state */
2091 RTK_CHK_INIT_STATE();
2093 if(NULL
== pPortmask
)
2094 return RT_ERR_NULL_POINTER
;
2096 if ((retVal
= rtl8367c_getAsicSystemLutLearnPortMask(&pmask
)) != RT_ERR_OK
)
2099 if ((retVal
= rtk_switch_portmask_P2L_get(pmask
, pPortmask
)) != RT_ERR_OK
)
2106 * rtk_l2_learningCnt_get
2108 * Get per-Port current auto learning number
2112 * pMac_cnt - ASIC auto learning entries number
2115 * RT_ERR_FAILED - Failed
2116 * RT_ERR_SMI - SMI access error
2117 * RT_ERR_PORT_ID - Invalid port number.
2119 * The API can get per-port ASIC auto learning number
2121 rtk_api_ret_t
rtk_l2_learningCnt_get(rtk_port_t port
, rtk_mac_cnt_t
*pMac_cnt
)
2123 rtk_api_ret_t retVal
;
2125 /* Check initialization state */
2126 RTK_CHK_INIT_STATE();
2128 /* check port valid */
2129 RTK_CHK_PORT_VALID(port
);
2131 if(NULL
== pMac_cnt
)
2132 return RT_ERR_NULL_POINTER
;
2134 if ((retVal
= rtl8367c_getAsicLutLearnNo(rtk_switch_port_L2P_get(port
), pMac_cnt
)) != RT_ERR_OK
)
2141 * rtk_l2_floodPortMask_set
2143 * Set flooding portmask
2145 * type - flooding type.
2146 * pFlood_portmask - flooding porkmask
2151 * RT_ERR_FAILED - Failed
2152 * RT_ERR_SMI - SMI access error
2153 * RT_ERR_PORT_MASK - Invalid portmask.
2154 * RT_ERR_INPUT - Invalid input parameters.
2156 * This API can set the flooding mask.
2157 * The flooding type is as following:
2162 rtk_api_ret_t
rtk_l2_floodPortMask_set(rtk_l2_flood_type_t floood_type
, rtk_portmask_t
*pFlood_portmask
)
2164 rtk_api_ret_t retVal
;
2167 /* Check initialization state */
2168 RTK_CHK_INIT_STATE();
2170 if (floood_type
>= FLOOD_END
)
2171 return RT_ERR_INPUT
;
2173 /* check port valid */
2174 RTK_CHK_PORTMASK_VALID(pFlood_portmask
);
2176 /* Get Physical port mask */
2177 if ((retVal
= rtk_switch_portmask_L2P_get(pFlood_portmask
, &pmask
))!=RT_ERR_OK
)
2180 switch (floood_type
)
2182 case FLOOD_UNKNOWNDA
:
2183 if ((retVal
= rtl8367c_setAsicPortUnknownDaFloodingPortmask(pmask
)) != RT_ERR_OK
)
2186 case FLOOD_UNKNOWNMC
:
2187 if ((retVal
= rtl8367c_setAsicPortUnknownMulticastFloodingPortmask(pmask
)) != RT_ERR_OK
)
2191 if ((retVal
= rtl8367c_setAsicPortBcastFloodingPortmask(pmask
)) != RT_ERR_OK
)
2201 * rtk_l2_floodPortMask_get
2203 * Get flooding portmask
2205 * type - flooding type.
2207 * pFlood_portmask - flooding porkmask
2210 * RT_ERR_FAILED - Failed
2211 * RT_ERR_SMI - SMI access error
2212 * RT_ERR_PORT_ID - Invalid port number.
2214 * This API can get the flooding mask.
2215 * The flooding type is as following:
2220 rtk_api_ret_t
rtk_l2_floodPortMask_get(rtk_l2_flood_type_t floood_type
, rtk_portmask_t
*pFlood_portmask
)
2222 rtk_api_ret_t retVal
;
2225 /* Check initialization state */
2226 RTK_CHK_INIT_STATE();
2228 if (floood_type
>= FLOOD_END
)
2229 return RT_ERR_INPUT
;
2231 if(NULL
== pFlood_portmask
)
2232 return RT_ERR_NULL_POINTER
;
2234 switch (floood_type
)
2236 case FLOOD_UNKNOWNDA
:
2237 if ((retVal
= rtl8367c_getAsicPortUnknownDaFloodingPortmask(&pmask
)) != RT_ERR_OK
)
2240 case FLOOD_UNKNOWNMC
:
2241 if ((retVal
= rtl8367c_getAsicPortUnknownMulticastFloodingPortmask(&pmask
)) != RT_ERR_OK
)
2245 if ((retVal
= rtl8367c_getAsicPortBcastFloodingPortmask(&pmask
)) != RT_ERR_OK
)
2252 /* Get Logical port mask */
2253 if ((retVal
= rtk_switch_portmask_P2L_get(pmask
, pFlood_portmask
))!=RT_ERR_OK
)
2260 * rtk_l2_localPktPermit_set
2262 * Set permittion of frames if source port and destination port are the same.
2265 * permit - permittion status
2270 * RT_ERR_FAILED - Failed
2271 * RT_ERR_SMI - SMI access error
2272 * RT_ERR_PORT_ID - Invalid port number.
2273 * RT_ERR_ENABLE - Invalid permit value.
2275 * This API is setted to permit frame if its source port is equal to destination port.
2277 rtk_api_ret_t
rtk_l2_localPktPermit_set(rtk_port_t port
, rtk_enable_t permit
)
2279 rtk_api_ret_t retVal
;
2281 /* Check initialization state */
2282 RTK_CHK_INIT_STATE();
2284 /* check port valid */
2285 RTK_CHK_PORT_VALID(port
);
2287 if (permit
>= RTK_ENABLE_END
)
2288 return RT_ERR_ENABLE
;
2290 if ((retVal
= rtl8367c_setAsicPortBlockSpa(rtk_switch_port_L2P_get(port
), permit
)) != RT_ERR_OK
)
2297 * rtk_l2_localPktPermit_get
2299 * Get permittion of frames if source port and destination port are the same.
2303 * pPermit - permittion status
2306 * RT_ERR_FAILED - Failed
2307 * RT_ERR_SMI - SMI access error
2308 * RT_ERR_PORT_ID - Invalid port number.
2310 * This API is to get permittion status for frames if its source port is equal to destination port.
2312 rtk_api_ret_t
rtk_l2_localPktPermit_get(rtk_port_t port
, rtk_enable_t
*pPermit
)
2314 rtk_api_ret_t retVal
;
2316 /* Check initialization state */
2317 RTK_CHK_INIT_STATE();
2319 /* check port valid */
2320 RTK_CHK_PORT_VALID(port
);
2323 return RT_ERR_NULL_POINTER
;
2325 if ((retVal
= rtl8367c_getAsicPortBlockSpa(rtk_switch_port_L2P_get(port
), pPermit
)) != RT_ERR_OK
)
2334 * Set LUT agging out speed
2336 * aging_time - Agging out time.
2341 * RT_ERR_FAILED - Failed
2342 * RT_ERR_SMI - SMI access error
2343 * RT_ERR_OUT_OF_RANGE - input out of range.
2345 * The API can set LUT agging out period for each entry and the range is from 45s to 458s.
2347 rtk_api_ret_t
rtk_l2_aging_set(rtk_l2_age_time_t aging_time
)
2350 CONST_T rtk_uint32 agePara
[10][3] = {
2351 {45, 0, 1}, {88, 0, 2}, {133, 0, 3}, {177, 0, 4}, {221, 0, 5}, {266, 0, 6}, {310, 0, 7},
2352 {354, 2, 6}, {413, 2, 7}, {458, 3, 7}};
2354 /* Check initialization state */
2355 RTK_CHK_INIT_STATE();
2357 if (aging_time
>agePara
[9][0])
2358 return RT_ERR_OUT_OF_RANGE
;
2360 for (i
= 0; i
<10; i
++)
2362 if (aging_time
<=agePara
[i
][0])
2364 return rtl8367c_setAsicLutAgeTimerSpeed(agePara
[i
][2], agePara
[i
][1]);
2368 return RT_ERR_FAILED
;
2374 * Get LUT agging out time
2378 * pEnable - Aging status
2381 * RT_ERR_FAILED - Failed
2382 * RT_ERR_SMI - SMI access error
2383 * RT_ERR_PORT_ID - Invalid port number.
2385 * The API can get LUT agging out period for each entry.
2387 rtk_api_ret_t
rtk_l2_aging_get(rtk_l2_age_time_t
*pAging_time
)
2389 rtk_api_ret_t retVal
;
2390 rtk_uint32 i
,time
, speed
;
2391 CONST_T rtk_uint32 agePara
[10][3] = {
2392 {45, 0, 1}, {88, 0, 2}, {133, 0, 3}, {177, 0, 4}, {221, 0, 5}, {266, 0, 6}, {310, 0, 7},
2393 {354, 2, 6}, {413, 2, 7}, {458, 3, 7}};
2395 /* Check initialization state */
2396 RTK_CHK_INIT_STATE();
2398 if(NULL
== pAging_time
)
2399 return RT_ERR_NULL_POINTER
;
2401 if ((retVal
= rtl8367c_getAsicLutAgeTimerSpeed(&time
, &speed
)) != RT_ERR_OK
)
2404 for (i
= 0; i
<10; i
++)
2406 if (time
==agePara
[i
][2]&&speed
==agePara
[i
][1])
2408 *pAging_time
= agePara
[i
][0];
2413 return RT_ERR_FAILED
;
2417 * rtk_l2_ipMcastAddrLookup_set
2419 * Set Lut IP multicast lookup function
2421 * type - Lookup type for IPMC packet.
2426 * RT_ERR_FAILED - Failed
2427 * RT_ERR_SMI - SMI access error
2429 * LOOKUP_MAC - Lookup by MAC address
2430 * LOOKUP_IP - Lookup by IP address
2431 * LOOKUP_IP_VID - Lookup by IP address & VLAN ID
2433 rtk_api_ret_t
rtk_l2_ipMcastAddrLookup_set(rtk_l2_ipmc_lookup_type_t type
)
2435 rtk_api_ret_t retVal
;
2437 /* Check initialization state */
2438 RTK_CHK_INIT_STATE();
2440 if(type
== LOOKUP_MAC
)
2442 if((retVal
= rtl8367c_setAsicLutIpMulticastLookup(DISABLED
)) != RT_ERR_OK
)
2445 else if(type
== LOOKUP_IP
)
2447 if((retVal
= rtl8367c_setAsicLutIpMulticastLookup(ENABLED
)) != RT_ERR_OK
)
2450 if ((retVal
= rtl8367c_setAsicLutIpMulticastVidLookup(DISABLED
))!=RT_ERR_OK
)
2453 if ((retVal
= rtl8367c_setAsicLutIpLookupMethod(1))!=RT_ERR_OK
)
2456 else if(type
== LOOKUP_IP_VID
)
2458 if((retVal
= rtl8367c_setAsicLutIpMulticastLookup(ENABLED
)) != RT_ERR_OK
)
2461 if ((retVal
= rtl8367c_setAsicLutIpMulticastVidLookup(ENABLED
))!=RT_ERR_OK
)
2464 if ((retVal
= rtl8367c_setAsicLutIpLookupMethod(1))!=RT_ERR_OK
)
2468 return RT_ERR_INPUT
;
2474 * rtk_l2_ipMcastAddrLookup_get
2476 * Get Lut IP multicast lookup function
2480 * pType - Lookup type for IPMC packet.
2483 * RT_ERR_FAILED - Failed
2484 * RT_ERR_SMI - SMI access error
2488 rtk_api_ret_t
rtk_l2_ipMcastAddrLookup_get(rtk_l2_ipmc_lookup_type_t
*pType
)
2490 rtk_api_ret_t retVal
;
2491 rtk_uint32 enabled
, vid_lookup
;
2493 /* Check initialization state */
2494 RTK_CHK_INIT_STATE();
2497 return RT_ERR_NULL_POINTER
;
2499 if((retVal
= rtl8367c_getAsicLutIpMulticastLookup(&enabled
)) != RT_ERR_OK
)
2502 if ((retVal
= rtl8367c_getAsicLutIpMulticastVidLookup(&vid_lookup
))!=RT_ERR_OK
)
2505 if(enabled
== ENABLED
)
2507 if(vid_lookup
== ENABLED
)
2508 *pType
= LOOKUP_IP_VID
;
2513 *pType
= LOOKUP_MAC
;
2519 * rtk_l2_ipMcastForwardRouterPort_set
2521 * Set IPMC packet forward to rounter port also or not
2523 * enabled - 1: Inlcude router port, 0, exclude router port
2528 * RT_ERR_FAILED - Failed
2529 * RT_ERR_SMI - SMI access error
2533 rtk_api_ret_t
rtk_l2_ipMcastForwardRouterPort_set(rtk_enable_t enabled
)
2535 rtk_api_ret_t retVal
;
2537 /* Check initialization state */
2538 RTK_CHK_INIT_STATE();
2540 if (enabled
>= RTK_ENABLE_END
)
2541 return RT_ERR_ENABLE
;
2543 if((retVal
= rtl8367c_setAsicLutIpmcFwdRouterPort(enabled
)) != RT_ERR_OK
)
2550 * rtk_l2_ipMcastForwardRouterPort_get
2552 * Get IPMC packet forward to rounter port also or not
2556 * pEnabled - 1: Inlcude router port, 0, exclude router port
2559 * RT_ERR_FAILED - Failed
2560 * RT_ERR_NULL_POINTER - Null pointer
2564 rtk_api_ret_t
rtk_l2_ipMcastForwardRouterPort_get(rtk_enable_t
*pEnabled
)
2566 rtk_api_ret_t retVal
;
2568 /* Check initialization state */
2569 RTK_CHK_INIT_STATE();
2571 if (NULL
== pEnabled
)
2572 return RT_ERR_NULL_POINTER
;
2574 if((retVal
= rtl8367c_getAsicLutIpmcFwdRouterPort(pEnabled
)) != RT_ERR_OK
)
2581 * rtk_l2_ipMcastGroupEntry_add
2583 * Add an IP Multicast entry to group table
2585 * ip_addr - IP address
2587 * pPortmask - portmask
2592 * RT_ERR_FAILED - Failed
2593 * RT_ERR_SMI - SMI access error
2594 * RT_ERR_TBL_FULL - Table Full
2596 * Add an entry to IP Multicast Group table.
2598 rtk_api_ret_t
rtk_l2_ipMcastGroupEntry_add(ipaddr_t ip_addr
, rtk_uint32 vid
, rtk_portmask_t
*pPortmask
)
2600 rtk_uint32 empty_idx
= 0xFFFF;
2602 ipaddr_t group_addr
;
2603 rtk_uint32 group_vid
;
2606 rtk_uint32 physicalPortmask
;
2607 rtk_api_ret_t retVal
;
2609 /* Check initialization state */
2610 RTK_CHK_INIT_STATE();
2612 if (vid
> RTL8367C_VIDMAX
)
2613 return RT_ERR_L2_VID
;
2615 if(NULL
== pPortmask
)
2616 return RT_ERR_NULL_POINTER
;
2618 if((ip_addr
& 0xF0000000) != 0xE0000000)
2619 return RT_ERR_INPUT
;
2621 /* Get Physical port mask */
2622 if ((retVal
= rtk_switch_portmask_L2P_get(pPortmask
, &physicalPortmask
))!=RT_ERR_OK
)
2625 for(index
= 0; index
<= RTL8367C_LUT_IPMCGRP_TABLE_MAX
; index
++)
2627 if ((retVal
= rtl8367c_getAsicLutIPMCGroup((rtk_uint32
)index
, &group_addr
, &group_vid
, &pmask
, &valid
))!=RT_ERR_OK
)
2630 if( (valid
== ENABLED
) && (group_addr
== ip_addr
) && (group_vid
== vid
) )
2632 if(pmask
!= physicalPortmask
)
2634 pmask
= physicalPortmask
;
2635 if ((retVal
= rtl8367c_setAsicLutIPMCGroup(index
, ip_addr
, vid
, pmask
, valid
))!=RT_ERR_OK
)
2642 if( (valid
== DISABLED
) && (empty_idx
== 0xFFFF) ) /* Unused */
2643 empty_idx
= (rtk_uint32
)index
;
2646 if(empty_idx
== 0xFFFF)
2647 return RT_ERR_TBL_FULL
;
2649 pmask
= physicalPortmask
;
2650 if ((retVal
= rtl8367c_setAsicLutIPMCGroup(empty_idx
, ip_addr
, vid
, pmask
, ENABLED
))!=RT_ERR_OK
)
2657 * rtk_l2_ipMcastGroupEntry_del
2659 * Delete an entry from IP Multicast group table
2661 * ip_addr - IP address
2667 * RT_ERR_FAILED - Failed
2668 * RT_ERR_SMI - SMI access error
2669 * RT_ERR_TBL_FULL - Table Full
2671 * Delete an entry from IP Multicast group table.
2673 rtk_api_ret_t
rtk_l2_ipMcastGroupEntry_del(ipaddr_t ip_addr
, rtk_uint32 vid
)
2676 ipaddr_t group_addr
;
2677 rtk_uint32 group_vid
;
2680 rtk_api_ret_t retVal
;
2682 /* Check initialization state */
2683 RTK_CHK_INIT_STATE();
2685 if (vid
> RTL8367C_VIDMAX
)
2686 return RT_ERR_L2_VID
;
2688 if((ip_addr
& 0xF0000000) != 0xE0000000)
2689 return RT_ERR_INPUT
;
2691 for(index
= 0; index
<= RTL8367C_LUT_IPMCGRP_TABLE_MAX
; index
++)
2693 if ((retVal
= rtl8367c_getAsicLutIPMCGroup((rtk_uint32
)index
, &group_addr
, &group_vid
, &pmask
, &valid
))!=RT_ERR_OK
)
2696 if( (valid
== ENABLED
) && (group_addr
== ip_addr
) && (group_vid
== vid
) )
2698 group_addr
= 0xE0000000;
2701 if ((retVal
= rtl8367c_setAsicLutIPMCGroup(index
, group_addr
, group_vid
, pmask
, DISABLED
))!=RT_ERR_OK
)
2708 return RT_ERR_FAILED
;
2712 * rtk_l2_ipMcastGroupEntry_get
2714 * get an entry from IP Multicast group table
2716 * ip_addr - IP address
2719 * pPortmask - member port mask
2722 * RT_ERR_FAILED - Failed
2723 * RT_ERR_SMI - SMI access error
2724 * RT_ERR_TBL_FULL - Table Full
2726 * Delete an entry from IP Multicast group table.
2728 rtk_api_ret_t
rtk_l2_ipMcastGroupEntry_get(ipaddr_t ip_addr
, rtk_uint32 vid
, rtk_portmask_t
*pPortmask
)
2731 ipaddr_t group_addr
;
2732 rtk_uint32 group_vid
;
2735 rtk_api_ret_t retVal
;
2737 /* Check initialization state */
2738 RTK_CHK_INIT_STATE();
2740 if((ip_addr
& 0xF0000000) != 0xE0000000)
2741 return RT_ERR_INPUT
;
2743 if (vid
> RTL8367C_VIDMAX
)
2744 return RT_ERR_L2_VID
;
2746 if(NULL
== pPortmask
)
2747 return RT_ERR_NULL_POINTER
;
2749 for(index
= 0; index
<= RTL8367C_LUT_IPMCGRP_TABLE_MAX
; index
++)
2751 if ((retVal
= rtl8367c_getAsicLutIPMCGroup((rtk_uint32
)index
, &group_addr
, &group_vid
, &pmask
, &valid
))!=RT_ERR_OK
)
2754 if( (valid
== ENABLED
) && (group_addr
== ip_addr
) && (group_vid
== vid
) )
2756 if ((retVal
= rtk_switch_portmask_P2L_get(pmask
, pPortmask
))!=RT_ERR_OK
)
2763 return RT_ERR_FAILED
;
2769 * Get LUT unicast entry.
2771 * pL2_entry - Index field in the structure.
2773 * pL2_entry - other fields such as MAC, port, age...
2776 * RT_ERR_FAILED - Failed
2777 * RT_ERR_SMI - SMI access error
2778 * RT_ERR_L2_EMPTY_ENTRY - Empty LUT entry.
2779 * RT_ERR_INPUT - Invalid input parameters.
2781 * This API is used to get address by index from 0~2111.
2783 rtk_api_ret_t
rtk_l2_entry_get(rtk_l2_addr_table_t
*pL2_entry
)
2785 rtk_api_ret_t retVal
;
2787 rtl8367c_luttb l2Table
;
2789 /* Check initialization state */
2790 RTK_CHK_INIT_STATE();
2792 if (pL2_entry
->index
>= rtk_switch_maxLutAddrNumber_get())
2793 return RT_ERR_INPUT
;
2795 memset(&l2Table
, 0x00, sizeof(rtl8367c_luttb
));
2796 l2Table
.address
= pL2_entry
->index
;
2797 method
= LUTREADMETHOD_ADDRESS
;
2798 if ((retVal
= rtl8367c_getAsicL2LookupTb(method
, &l2Table
)) != RT_ERR_OK
)
2801 if ((pL2_entry
->index
>0x800)&&(l2Table
.lookup_hit
==0))
2802 return RT_ERR_L2_EMPTY_ENTRY
;
2804 if(l2Table
.l3lookup
)
2806 if(l2Table
.l3vidlookup
)
2808 memset(&pL2_entry
->mac
, 0, sizeof(rtk_mac_t
));
2809 pL2_entry
->is_ipmul
= l2Table
.l3lookup
;
2810 pL2_entry
->sip
= l2Table
.sip
;
2811 pL2_entry
->dip
= l2Table
.dip
;
2812 pL2_entry
->is_static
= l2Table
.nosalearn
;
2814 /* Get Logical port mask */
2815 if ((retVal
= rtk_switch_portmask_P2L_get(l2Table
.mbr
, &(pL2_entry
->portmask
)))!=RT_ERR_OK
)
2820 pL2_entry
->auth
= 0;
2821 pL2_entry
->sa_block
= 0;
2822 pL2_entry
->is_ipvidmul
= 1;
2823 pL2_entry
->l3_vid
= l2Table
.l3_vid
;
2827 memset(&pL2_entry
->mac
, 0, sizeof(rtk_mac_t
));
2828 pL2_entry
->is_ipmul
= l2Table
.l3lookup
;
2829 pL2_entry
->sip
= l2Table
.sip
;
2830 pL2_entry
->dip
= l2Table
.dip
;
2831 pL2_entry
->is_static
= l2Table
.nosalearn
;
2833 /* Get Logical port mask */
2834 if ((retVal
= rtk_switch_portmask_P2L_get(l2Table
.mbr
, &(pL2_entry
->portmask
)))!=RT_ERR_OK
)
2839 pL2_entry
->auth
= 0;
2840 pL2_entry
->sa_block
= 0;
2841 pL2_entry
->is_ipvidmul
= 0;
2842 pL2_entry
->l3_vid
= 0;
2845 else if(l2Table
.mac
.octet
[0]&0x01)
2847 memset(&pL2_entry
->sip
, 0, sizeof(ipaddr_t
));
2848 memset(&pL2_entry
->dip
, 0, sizeof(ipaddr_t
));
2849 pL2_entry
->mac
.octet
[0] = l2Table
.mac
.octet
[0];
2850 pL2_entry
->mac
.octet
[1] = l2Table
.mac
.octet
[1];
2851 pL2_entry
->mac
.octet
[2] = l2Table
.mac
.octet
[2];
2852 pL2_entry
->mac
.octet
[3] = l2Table
.mac
.octet
[3];
2853 pL2_entry
->mac
.octet
[4] = l2Table
.mac
.octet
[4];
2854 pL2_entry
->mac
.octet
[5] = l2Table
.mac
.octet
[5];
2855 pL2_entry
->is_ipmul
= l2Table
.l3lookup
;
2856 pL2_entry
->is_static
= l2Table
.nosalearn
;
2858 /* Get Logical port mask */
2859 if ((retVal
= rtk_switch_portmask_P2L_get(l2Table
.mbr
, &(pL2_entry
->portmask
)))!=RT_ERR_OK
)
2862 pL2_entry
->ivl
= l2Table
.ivl_svl
;
2863 if(l2Table
.ivl_svl
== 1) /* IVL */
2865 pL2_entry
->cvid
= l2Table
.cvid_fid
;
2870 pL2_entry
->cvid
= 0;
2871 pL2_entry
->fid
= l2Table
.cvid_fid
;
2873 pL2_entry
->auth
= l2Table
.auth
;
2874 pL2_entry
->sa_block
= l2Table
.sa_block
;
2876 pL2_entry
->is_ipvidmul
= 0;
2877 pL2_entry
->l3_vid
= 0;
2879 else if((l2Table
.age
!= 0)||(l2Table
.nosalearn
== 1))
2881 memset(&pL2_entry
->sip
, 0, sizeof(ipaddr_t
));
2882 memset(&pL2_entry
->dip
, 0, sizeof(ipaddr_t
));
2883 pL2_entry
->mac
.octet
[0] = l2Table
.mac
.octet
[0];
2884 pL2_entry
->mac
.octet
[1] = l2Table
.mac
.octet
[1];
2885 pL2_entry
->mac
.octet
[2] = l2Table
.mac
.octet
[2];
2886 pL2_entry
->mac
.octet
[3] = l2Table
.mac
.octet
[3];
2887 pL2_entry
->mac
.octet
[4] = l2Table
.mac
.octet
[4];
2888 pL2_entry
->mac
.octet
[5] = l2Table
.mac
.octet
[5];
2889 pL2_entry
->is_ipmul
= l2Table
.l3lookup
;
2890 pL2_entry
->is_static
= l2Table
.nosalearn
;
2892 /* Get Logical port mask */
2893 if ((retVal
= rtk_switch_portmask_P2L_get(1<<(l2Table
.spa
), &(pL2_entry
->portmask
)))!=RT_ERR_OK
)
2896 pL2_entry
->ivl
= l2Table
.ivl_svl
;
2897 pL2_entry
->cvid
= l2Table
.cvid_fid
;
2898 pL2_entry
->fid
= l2Table
.fid
;
2899 pL2_entry
->auth
= l2Table
.auth
;
2900 pL2_entry
->sa_block
= l2Table
.sa_block
;
2901 pL2_entry
->age
= l2Table
.age
;
2902 pL2_entry
->is_ipvidmul
= 0;
2903 pL2_entry
->l3_vid
= 0;
2906 return RT_ERR_L2_EMPTY_ENTRY
;