| /* |
| * Copyright (c) 2009 Mindspeed Technologies, Inc. |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version 2 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| * |
| */ |
| #include "module_mc4.h" |
| #include "module_mc6.h" |
| #include "layer2.h" |
| #include "fe.h" |
| |
| |
| /* This function returns total multicast entries |
| configured in a given hash index */ |
| static int MC4_Get_Hash_Entries(int mc4_hash_index) |
| { |
| |
| int tot_mc4_entries = 0; |
| PMC4Entry pMC4Entry; |
| struct slist_entry *entry; |
| |
| slist_for_each(pMC4Entry, entry, &mc4_table_memory[mc4_hash_index], list) |
| { |
| tot_mc4_entries++; |
| if((pMC4Entry->mcdest.num_listeners > MCx_MAX_LISTENERS_IN_QUERY) || |
| ((pMC4Entry->mcdest.num_listeners == MCx_MAX_LISTENERS_IN_QUERY) && (pMC4Entry->mcdest.flags & MC_ACP_LISTENER))) |
| tot_mc4_entries++; |
| } |
| |
| |
| return tot_mc4_entries; |
| |
| } |
| |
| |
| /* This function fills the snapshot of MC4 entries in a given hash index */ |
| static int MC4_Get_Hash_Snapshot(int mc4_hash_index, int mc4_tot_entries, PMC4Command pMC4Snapshot) |
| { |
| |
| int tot_mc4_entries = 0, i; |
| PMC4Entry pMC4Entry; |
| struct slist_entry *entry; |
| int j = 0; |
| |
| slist_for_each(pMC4Entry, entry, &mc4_table_memory[mc4_hash_index], list) |
| { |
| memset(pMC4Snapshot, 0, sizeof(MC4Command)); |
| pMC4Snapshot->src_addr = pMC4Entry->src_addr; |
| pMC4Snapshot->src_addr_mask = pMC4Entry->mcdest.src_mask_len; |
| pMC4Snapshot->dst_addr = pMC4Entry->dst_addr; |
| pMC4Snapshot->queue = pMC4Entry->mcdest.queue_base; |
| pMC4Snapshot->num_output = pMC4Entry->mcdest.num_listeners; |
| for(i = 0,j = 0; j <pMC4Entry->mcdest.num_listeners; j++) |
| { |
| unsigned short output_index; |
| POnifDesc pOnif; |
| output_index = pMC4Entry->mcdest.listeners[j].output_index; |
| pOnif = get_onif_by_index(output_index); |
| strcpy((char *)pMC4Snapshot->output_list[i].output_device_str, (char *)pOnif->name); |
| pMC4Snapshot->output_list[i].timer = pMC4Entry->mcdest.listeners[j].timer; |
| pMC4Snapshot->output_list[i].shaper_mask= pMC4Entry->mcdest.listeners[j].shaper_mask; |
| pMC4Snapshot->output_list[i].uc_bit = (pMC4Entry->mcdest.listeners[j].uc_bit); |
| if(pMC4Snapshot->output_list[i].uc_bit) |
| COPY_MACADDR(pMC4Snapshot->output_list[i].uc_mac,pMC4Entry->mcdest.listeners[j].dstmac); |
| pMC4Snapshot->output_list[i].queue = pMC4Entry->mcdest.listeners[j].queue_base; |
| if((++i >= MCx_MAX_LISTENERS_IN_QUERY) && |
| ( (pMC4Entry->mcdest.num_listeners - (j+1)) || (pMC4Entry->mcdest.flags & MC_ACP_LISTENER))) |
| { |
| pMC4Snapshot->num_output = MCx_MAX_LISTENERS_IN_QUERY; |
| pMC4Snapshot++; |
| tot_mc4_entries++; |
| mc4_tot_entries--; |
| i = 0; |
| memset(pMC4Snapshot, 0, sizeof(MC4Command)); |
| } |
| } |
| pMC4Snapshot->num_output = i; |
| if ((pMC4Entry->mcdest.flags & MC_ACP_LISTENER) && i < MCx_MAX_LISTENERS_IN_QUERY) |
| { |
| pMC4Snapshot->num_output++; |
| strcpy((char *)pMC4Snapshot->output_list[i].output_device_str, "ACP"); |
| pMC4Snapshot->output_list[i].timer = pMC4Entry->mcdest.wifi_listener_timer; |
| } |
| pMC4Snapshot++; |
| tot_mc4_entries++; |
| mc4_tot_entries--; |
| if (mc4_tot_entries == 0) |
| break; |
| } |
| |
| return tot_mc4_entries; |
| |
| } |
| |
| |
| /* This function creates the snapshot memory and returns the |
| next MC4 entry from the snapshot of the MC4 entries of a |
| single hash to the caller */ |
| |
| int MC4_Get_Next_Hash_Entry(PMC4Command pMC4Cmd, int reset_action) |
| { |
| int mc4_hash_entries; |
| PMC4Command pMC4; |
| static PMC4Command pMC4Snapshot = NULL; |
| static int mc4_hash_index = 0, mc4_snapshot_entries =0, mc4_snapshot_index=0, mc4_snapshot_buf_entries = 0; |
| |
| if(reset_action) |
| { |
| mc4_hash_index = 0; |
| mc4_snapshot_entries =0; |
| mc4_snapshot_index=0; |
| if(pMC4Snapshot) |
| { |
| Heap_Free(pMC4Snapshot); |
| pMC4Snapshot = NULL; |
| } |
| mc4_snapshot_buf_entries = 0; |
| } |
| |
| if (mc4_snapshot_index == 0) |
| { |
| |
| while( mc4_hash_index < MC4_NUM_HASH_ENTRIES) |
| { |
| |
| mc4_hash_entries = MC4_Get_Hash_Entries(mc4_hash_index); |
| if(mc4_hash_entries == 0) |
| { |
| mc4_hash_index++; |
| continue; |
| } |
| |
| if(mc4_hash_entries > mc4_snapshot_buf_entries) |
| { |
| if(pMC4Snapshot) |
| Heap_Free(pMC4Snapshot); |
| pMC4Snapshot = Heap_Alloc(mc4_hash_entries * sizeof(MC4Command)); |
| |
| if (!pMC4Snapshot) |
| { |
| mc4_hash_index = 0; |
| mc4_snapshot_buf_entries = 0; |
| return ERR_NOT_ENOUGH_MEMORY; |
| } |
| mc4_snapshot_buf_entries = mc4_hash_entries; |
| } |
| |
| mc4_snapshot_entries = MC4_Get_Hash_Snapshot(mc4_hash_index ,mc4_hash_entries, pMC4Snapshot); |
| |
| break; |
| } |
| |
| if (mc4_hash_index >= MC4_NUM_HASH_ENTRIES) |
| { |
| mc4_hash_index = 0; |
| if(pMC4Snapshot) |
| { |
| Heap_Free(pMC4Snapshot); |
| pMC4Snapshot = NULL; |
| } |
| mc4_snapshot_buf_entries = 0; |
| return ERR_MC_ENTRY_NOT_FOUND; |
| } |
| |
| } |
| |
| pMC4 = &pMC4Snapshot[mc4_snapshot_index++]; |
| SFL_memcpy(pMC4Cmd, pMC4, sizeof(MC4Command)); |
| if (mc4_snapshot_index == mc4_snapshot_entries) |
| { |
| mc4_snapshot_index = 0; |
| mc4_hash_index ++; |
| } |
| |
| |
| return NO_ERR; |
| |
| } |
| |
| |
| /* This function returns total multicastv6 entries |
| configured in a given hash index */ |
| static int MC6_Get_Hash_Entries(int mc6_hash_index) |
| { |
| |
| int tot_mc6_entries = 0; |
| PMC6Entry pMC6Entry; |
| struct slist_entry *entry; |
| |
| slist_for_each(pMC6Entry, entry, &mc6_table_memory[mc6_hash_index], list) |
| { |
| tot_mc6_entries++; |
| if((pMC6Entry->mcdest.num_listeners > MCx_MAX_LISTENERS_IN_QUERY) || |
| ((pMC6Entry->mcdest.num_listeners == MCx_MAX_LISTENERS_IN_QUERY) && (pMC6Entry->mcdest.flags & MC_ACP_LISTENER))) |
| tot_mc6_entries++; |
| } |
| |
| return tot_mc6_entries; |
| |
| } |
| |
| |
| /* This function fills the snapshot of MC6 entries in a given hash index */ |
| static int MC6_Get_Hash_Snapshot(int mc6_hash_index, int mc6_tot_entries, PMC6Command pMC6Snapshot) |
| { |
| |
| int tot_mc6_entries = 0,i; |
| PMC6Entry pMC6Entry; |
| struct slist_entry *entry; |
| int j =0; |
| |
| slist_for_each(pMC6Entry, entry, &mc6_table_memory[mc6_hash_index], list) |
| { |
| memset(pMC6Snapshot, 0, sizeof(MC6Command)); |
| SFL_memcpy(pMC6Snapshot->src_addr, pMC6Entry->src_addr, IPV6_ADDRESS_LENGTH); |
| pMC6Snapshot->src_mask_len = pMC6Entry->mcdest.src_mask_len; |
| SFL_memcpy(pMC6Snapshot->dst_addr, pMC6Entry->dst_addr, IPV6_ADDRESS_LENGTH); |
| pMC6Snapshot->queue = pMC6Entry->mcdest.queue_base; |
| for(i = 0,j = 0; j <pMC6Entry->mcdest.num_listeners; j++) |
| { |
| unsigned short output_index; |
| POnifDesc pOnif; |
| output_index = pMC6Entry->mcdest.listeners[j].output_index; |
| pOnif = get_onif_by_index(output_index); |
| strcpy((char *)pMC6Snapshot->output_list[i].output_device_str, (char *)pOnif->name); |
| pMC6Snapshot->output_list[i].timer = pMC6Entry->mcdest.listeners[j].timer; |
| pMC6Snapshot->output_list[i].shaper_mask= pMC6Entry->mcdest.listeners[j].shaper_mask; |
| pMC6Snapshot->output_list[i].uc_bit = pMC6Entry->mcdest.listeners[j].uc_bit; |
| if(pMC6Snapshot->output_list[i].uc_bit) |
| COPY_MACADDR(pMC6Snapshot->output_list[i].uc_mac,pMC6Entry->mcdest.listeners[j].dstmac); |
| pMC6Snapshot->output_list[i].queue = pMC6Entry->mcdest.listeners[j].queue_base; |
| if((++i >= MCx_MAX_LISTENERS_IN_QUERY) && |
| ( (pMC6Entry->mcdest.num_listeners - (j+1)) || (pMC6Entry->mcdest.flags & MC_ACP_LISTENER))) |
| { |
| pMC6Snapshot->num_output = MCx_MAX_LISTENERS_IN_QUERY; |
| pMC6Snapshot++; |
| tot_mc6_entries++; |
| mc6_tot_entries--; |
| i = 0; |
| memset(pMC6Snapshot, 0, sizeof(MC6Command)); |
| } |
| } |
| pMC6Snapshot->num_output = i; |
| if ((pMC6Entry->mcdest.flags & MC_ACP_LISTENER) && i < MCx_MAX_LISTENERS_IN_QUERY) |
| { |
| pMC6Snapshot->num_output++; |
| strcpy((char *)pMC6Snapshot->output_list[i].output_device_str, "ACP"); |
| pMC6Snapshot->output_list[i].timer = pMC6Entry->mcdest.wifi_listener_timer; |
| } |
| pMC6Snapshot++; |
| tot_mc6_entries++; |
| mc6_tot_entries--; |
| if (mc6_tot_entries == 0) |
| break; |
| } |
| |
| return tot_mc6_entries; |
| |
| } |
| |
| |
| /* This function creates the snapshot memory and returns the |
| next MC6 entry from the snapshot of the MC4 entries of a |
| single hash to the caller */ |
| |
| int MC6_Get_Next_Hash_Entry(PMC6Command pMC6Cmd, int reset_action) |
| { |
| int mc6_hash_entries; |
| PMC6Command pMC6; |
| static PMC6Command pMC6Snapshot = NULL; |
| static int mc6_hash_index = 0, mc6_snapshot_entries =0, mc6_snapshot_index=0, mc6_snapshot_buf_entries = 0; |
| |
| if(reset_action) |
| { |
| mc6_hash_index = 0; |
| mc6_snapshot_entries =0; |
| mc6_snapshot_index=0; |
| if(pMC6Snapshot) |
| { |
| Heap_Free(pMC6Snapshot); |
| pMC6Snapshot = NULL; |
| } |
| mc6_snapshot_buf_entries = 0; |
| } |
| |
| if (mc6_snapshot_index == 0) |
| { |
| while( mc6_hash_index < MC6_NUM_HASH_ENTRIES) |
| { |
| |
| mc6_hash_entries = MC6_Get_Hash_Entries(mc6_hash_index); |
| if(mc6_hash_entries == 0) |
| { |
| mc6_hash_index++; |
| continue; |
| } |
| |
| if(mc6_hash_entries > mc6_snapshot_buf_entries) |
| { |
| if(pMC6Snapshot) |
| Heap_Free(pMC6Snapshot); |
| pMC6Snapshot = Heap_Alloc(mc6_hash_entries * sizeof(MC6Command)); |
| |
| if (!pMC6Snapshot) |
| { |
| mc6_hash_index = 0; |
| mc6_snapshot_buf_entries = 0; |
| return ERR_NOT_ENOUGH_MEMORY; |
| } |
| mc6_snapshot_buf_entries = mc6_hash_entries; |
| } |
| |
| mc6_snapshot_entries = MC6_Get_Hash_Snapshot(mc6_hash_index , mc6_hash_entries, pMC6Snapshot); |
| |
| break; |
| } |
| |
| if (mc6_hash_index >= MC6_NUM_HASH_ENTRIES) |
| { |
| mc6_hash_index = 0; |
| if(pMC6Snapshot) |
| { |
| Heap_Free(pMC6Snapshot); |
| pMC6Snapshot = NULL; |
| } |
| mc6_snapshot_buf_entries = 0; |
| return ERR_MC_ENTRY_NOT_FOUND; |
| } |
| |
| } |
| |
| pMC6 = &pMC6Snapshot[mc6_snapshot_index++]; |
| SFL_memcpy(pMC6Cmd, pMC6, sizeof(MC6Command)); |
| if (mc6_snapshot_index == mc6_snapshot_entries) |
| { |
| mc6_snapshot_index = 0; |
| mc6_hash_index ++; |
| } |
| |
| |
| return NO_ERR; |
| |
| } |
