static sw_error_t
_garuda_portvlan_member_update(a_uint32_t dev_id, fal_port_t port_id,
fal_pbmp_t mem_port_map)
{
sw_error_t rv;
HSL_DEV_ID_CHECK(dev_id);
if (A_FALSE == hsl_port_prop_check(dev_id, port_id, HSL_PP_INCL_CPU))
{
return SW_BAD_PARAM;
}
if (A_FALSE ==
hsl_mports_prop_check(dev_id, mem_port_map, HSL_PP_INCL_CPU))
{
return SW_BAD_PARAM;
}
HSL_REG_FIELD_SET(rv, dev_id, PORT_BASE_VLAN, port_id,
PORT_VID_MEM, (a_uint8_t *) (&mem_port_map),
sizeof (a_uint32_t));
return rv;
}
static sw_error_t
_athena_vlan_entry_append(a_uint32_t dev_id, const fal_vlan_t * vlan_entry)
{
sw_error_t rv;
a_uint32_t reg[2] = { 0 };
#ifdef HSL_STANDALONG
a_int16_t i, loc = MAX_VLAN_ENTRY;
v_array_t *p_v_array;
#endif
HSL_DEV_ID_CHECK(dev_id);
if ((vlan_entry->vid == 0) || (vlan_entry->vid > MAX_VLAN_ID))
return SW_OUT_OF_RANGE;
if (A_FALSE == hsl_mports_prop_check(dev_id, vlan_entry->mem_ports, HSL_PP_INCL_CPU))
return SW_BAD_PARAM;
#ifdef HSL_STANDALONG
if ((p_v_array = p_vlan_table[dev_id]) == NULL)
return SW_NOT_INITIALIZED;
for (i = 0; i < MAX_VLAN_ENTRY; i++) {
if (p_v_array[i].active == A_FALSE) {
loc = i;
} else if (p_v_array[i].vlan_entry.vid == vlan_entry->vid) {
return SW_ALREADY_EXIST;
}
}
if (loc == MAX_VLAN_ENTRY)
return SW_FULL;
#endif
rv = athena_vlan_sw_to_hw(vlan_entry, reg);
SW_RTN_ON_ERROR(rv);
HSL_REG_ENTRY_SET(rv, dev_id, VLAN_TABLE_FUNC0, 0,
(a_uint8_t *) (®[0]), sizeof (a_uint32_t));
SW_RTN_ON_ERROR(rv);
HSL_REG_ENTRY_SET(rv, dev_id, VLAN_TABLE_FUNC1, 0,
(a_uint8_t *) (®[1]), sizeof (a_uint32_t));
SW_RTN_ON_ERROR(rv);
rv = athena_vlan_commit(dev_id, VLAN_LOAD_ENTRY);
SW_RTN_ON_ERROR(rv);
#ifdef HSL_STANDALONG
p_v_array[loc].vlan_entry = *vlan_entry;
p_v_array[loc].active = A_TRUE;
#endif
return SW_OK;
}
static sw_error_t
_athena_vlan_member_update(a_uint32_t dev_id, a_uint32_t vlan_id,
fal_pbmp_t member, fal_pbmp_t u_member)
{
#ifdef HSL_STANDALONG
sw_error_t rv;
a_int16_t loc;
a_uint32_t reg_tmp;
v_array_t *p_v_array;
fal_vlan_t *p_sw_vlan;
HSL_DEV_ID_CHECK(dev_id);
if ((vlan_id == 0) || (vlan_id > MAX_VLAN_ID))
return SW_OUT_OF_RANGE;
if (A_FALSE == hsl_mports_prop_check(dev_id, member, HSL_PP_INCL_CPU))
return SW_BAD_PARAM;
if (u_member != 0)
return SW_BAD_PARAM;
if ((p_v_array = p_vlan_table[dev_id]) == NULL)
return SW_NOT_INITIALIZED;
rv = athena_vlan_table_location(dev_id, vlan_id, &loc);
SW_RTN_ON_ERROR(rv);
p_sw_vlan = &p_v_array[loc].vlan_entry;
/* set value for VLAN_TABLE_FUNC0, all 0 except vid */
reg_tmp = 0;
SW_SET_REG_BY_FIELD(VLAN_TABLE_FUNC0, VLAN_ID, vlan_id, reg_tmp);
SW_SET_REG_BY_FIELD(VLAN_TABLE_FUNC0, VT_PRI_EN,
(a_int32_t)p_sw_vlan->vid_pri_en, reg_tmp);
SW_SET_REG_BY_FIELD(VLAN_TABLE_FUNC0, VT_PRI, p_sw_vlan->vid_pri, reg_tmp);
HSL_REG_ENTRY_SET(rv, dev_id, VLAN_TABLE_FUNC0, 0,
(a_uint8_t *) (®_tmp), sizeof (a_uint32_t));
SW_RTN_ON_ERROR(rv);
/* set vlan member for VLAN_TABLE_FUNC1 */
HSL_REG_FIELD_SET(rv, dev_id, VLAN_TABLE_FUNC1, 0, VID_MEM,
(a_uint8_t *) (&member), sizeof (a_uint32_t));
SW_RTN_ON_ERROR(rv);
rv = athena_vlan_commit(dev_id, VLAN_LOAD_ENTRY);
SW_RTN_ON_ERROR(rv);
p_v_array[loc].vlan_entry.mem_ports = member;
return SW_OK;
#else
return SW_NOT_SUPPORTED;
#endif
}
static sw_error_t
shiva_atu_sw_to_hw(a_uint32_t dev_id, const fal_fdb_entry_t * entry,
a_uint32_t reg[])
{
a_uint32_t port;
if (A_FALSE == entry->portmap_en)
{
if (A_TRUE !=
hsl_port_prop_check(dev_id, entry->port.id, HSL_PP_INCL_CPU))
{
return SW_BAD_PARAM;
}
port = 0x1UL << entry->port.id;
}
else
{
if (A_FALSE ==
hsl_mports_prop_check(dev_id, entry->port.map, HSL_PP_INCL_CPU))
{
return SW_BAD_PARAM;
}
port = entry->port.map;
}
if (FAL_MAC_CPY_TO_CPU == entry->dacmd)
{
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, COPY_TO_CPU, 1, reg[2]);
}
else if (FAL_MAC_RDT_TO_CPU == entry->dacmd)
{
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, REDRCT_TO_CPU, 1, reg[2]);
}
else if (FAL_MAC_FRWRD != entry->dacmd)
{
return SW_NOT_SUPPORTED;
}
if (FAL_MAC_DROP == entry->sacmd)
{
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, SA_DROP_EN, 1, reg[2]);
}
else if (FAL_MAC_FRWRD != entry->sacmd)
{
return SW_NOT_SUPPORTED;
}
if (A_TRUE == entry->leaky_en)
{
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, LEAKY_EN, 1, reg[2]);
}
else
{
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, LEAKY_EN, 0, reg[2]);
}
if (A_TRUE == entry->static_en)
{
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, AT_STATUS, 15, reg[2]);
}
else
{
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, AT_STATUS, 7, reg[2]);
}
if (A_TRUE == entry->mirror_en)
{
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, MIRROR_EN, 1, reg[2]);
}
if (A_TRUE == entry->clone_en)
{
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, CLONE_EN, 1, reg[2]);
}
if (A_TRUE == entry->cross_pt_state)
{
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, CROSS_PT, 1, reg[2]);
}
if (A_TRUE == entry->da_pri_en)
{
hsl_dev_t *p_dev;
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, AT_PRI_EN, 1, reg[2]);
SW_RTN_ON_NULL(p_dev = hsl_dev_ptr_get(dev_id));
if (entry->da_queue > (p_dev->nr_queue - 1))
return SW_BAD_PARAM;
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, AT_PRI, entry->da_queue, reg[2]);
}
SW_SET_REG_BY_FIELD(ADDR_TABLE_FUNC2, DES_PORT, port, reg[2]);
shiva_fdb_fill_addr(entry->addr, ®[0], ®[1]);
return SW_OK;
}
