| /******************************************************************************* |
| Copyright (C) Marvell International Ltd. and its affiliates |
| |
| This software file (the "File") is owned and distributed by Marvell |
| International Ltd. and/or its affiliates ("Marvell") under the following |
| alternative licensing terms. Once you have made an election to distribute the |
| File under one of the following license alternatives, please (i) delete this |
| introductory statement regarding license alternatives, (ii) delete the two |
| license alternatives that you have not elected to use and (iii) preserve the |
| Marvell copyright notice above. |
| |
| ******************************************************************************** |
| Marvell Commercial License Option |
| |
| If you received this File from Marvell and you have entered into a commercial |
| license agreement (a "Commercial License") with Marvell, the File is licensed |
| to you under the terms of the applicable Commercial License. |
| |
| ******************************************************************************** |
| Marvell GPL License Option |
| |
| If you received this File from Marvell, you may opt to use, redistribute and/or |
| modify this File in accordance with the terms and conditions of the General |
| Public License Version 2, June 1991 (the "GPL License"), a copy of which is |
| available along with the File in the license.txt file or by writing to the Free |
| Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or |
| on the worldwide web at http://www.gnu.org/licenses/gpl.txt. |
| |
| THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED |
| WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY |
| DISCLAIMED. The GPL License provides additional details about this warranty |
| disclaimer. |
| ******************************************************************************** |
| Marvell BSD License Option |
| |
| If you received this File from Marvell, you may opt to use, redistribute and/or |
| modify this File under the following licensing terms. |
| Redistribution and use in source and binary forms, with or without modification, |
| are permitted provided that the following conditions are met: |
| |
| * Redistributions of source code must retain the above copyright notice, |
| this list of conditions and the following disclaimer. |
| |
| * Redistributions in binary form must reproduce the above copyright |
| notice, this list of conditions and the following disclaimer in the |
| documentation and/or other materials provided with the distribution. |
| |
| * Neither the name of Marvell nor the names of its contributors may be |
| used to endorse or promote products derived from this software without |
| specific prior written permission. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
| ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR |
| ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON |
| ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| ******************************************************************************/ |
| |
| #include <linux/ctype.h> |
| #include "tpm_common.h" |
| #include "tpm_header.h" |
| #include "tpm_sysfs_utils.h" |
| #include "tpm_sysfs_help.h" |
| #include "tpm_sysfs_hwcall.h" |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| extern struct semaphore tpm_sfs_2_ioctl_sem; |
| extern tpm_ioctl_mng_t tpm_sfs_2_ioctl_command; |
| #define PR_RULE_IDX(rule_idx) {} |
| #define PR_HIT_COUNT(hit_count){} |
| #define PR_RESULT {} |
| #define PR_MAC_COUNT {} |
| #else |
| #define PR_RULE_IDX(rule_idx) {printk(KERN_INFO "OK. rule_idx = %d\n", rule_idx);} |
| #define PR_HIT_COUNT(hit_count){printk(KERN_INFO "OK. hit_count = %d\n", hit_count);} |
| #define PR_RESULT {printk(KERN_INFO "OK.\n");} |
| #define PR_MAC_COUNT(count) {printk(KERN_INFO "OK. mac_learn_entry_count = %d\n", count);} |
| #endif |
| |
| static char *l2_key_empty_name = "l2_key_empty"; |
| static char *l3_key_empty_name = "l3_key_empty"; |
| static char *ipv4_key_empty_name = "ipv4_key_empty"; |
| static char *ipv6_key_empty_name = "ipv6_key_empty"; |
| static char *frwd_empty_name = "frwd_empty"; |
| static char *mod_empty_name = "mod_empty"; |
| char *ipv6_gen_key_empty_name = "ipv6_gen_key_empty"; |
| char *ipv6_dip_key_empty_name = "ipv6_dip_key_empty"; |
| char *ipv6_l4_key_empty_name = "ipv6_l4_key_empty"; |
| |
| extern int32_t module_tpmSetup(tpm_setup_t *tpm_initp); |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_l2_rule_bounce(uint32_t owner_id, |
| tpm_src_port_type_t src_port, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_parse_flags_t parse_flags_bm, |
| tpm_l2_acl_key_t *l2_key, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_pkt_mod_t *pkt_mod, |
| tpm_pkt_mod_bm_t pkt_mod_bm, |
| tpm_rule_action_t *rule_action) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_L2_ACL_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->src_port = src_port; |
| tpm_add_acl_rule->rule_num = rule_num; |
| tpm_add_acl_rule->parse_rule_bm = parse_rule_bm; |
| tpm_add_acl_rule->l2_acl_rule.parse_flags_bm = parse_flags_bm; |
| tpm_add_acl_rule->l2_acl_rule.pkt_mod_bm = pkt_mod_bm; |
| memcpy(&(tpm_add_acl_rule->l2_acl_rule.l2_key), (void*)l2_key, sizeof(tpm_l2_acl_key_t)); |
| memcpy(&(tpm_add_acl_rule->l2_acl_rule.pkt_frwd), (void*)pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&(tpm_add_acl_rule->l2_acl_rule.pkt_mod), (void*)pkt_mod, sizeof(tpm_pkt_mod_t)); |
| memcpy(&(tpm_add_acl_rule->l2_acl_rule.rule_action), (void*)rule_action, sizeof(tpm_rule_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_l2_rule tpm_add_l2_rule_bounce |
| #else |
| #define _tpm_add_l2_rule tpm_add_l2_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_l2_rule_add |
| * |
| * DESCRIPTION: |
| * This function creates a L2 rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_l2_rule_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| l2ruleadd_owner=0, l2ruleadd_srcport, l2ruleadd_rulenum, l2ruleadd_parserulebm, l2ruleadd_parseflagbm, l2ruleadd_action, l2ruleadd_nextphase, |
| l2ruleadd_l2keyname, l2ruleadd_frwdname, l2ruleadd_modname, l2ruleadd_pktmodbm, l2ruleadd_max |
| } l2ruleadd_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| char srcport_str[20]; |
| char uc_srcport_str[20]; |
| int indx; |
| uint32_t src_port; |
| uint32_t rulenum; |
| uint32_t parserulebm; |
| uint32_t parseflagbm; |
| uint32_t pkt_mod_bm; |
| uint32_t action; |
| char nextphase_str[20]; |
| uint32_t nextphase; |
| char l2keyname[20]; |
| char frwdname[20]; |
| char modname[20]; |
| int parsedargs; |
| int numparms; |
| // DB |
| tpmcfg_frwd_entry_t *pdbfrwdentry = 0; |
| tpmcfg_l2_key_entry_t *pdbl2keyentry = 0; |
| tpmcfg_mod_entry_t *pdbmodentry = 0; |
| //Used in API call |
| tpm_rule_action_t rule_action; |
| tpm_pkt_frwd_t pkt_frwd; |
| tpm_l2_acl_key_t l2_acl; |
| tpm_pkt_mod_t pkt_mod; |
| uint32_t rule_idx; |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != l2ruleadd_max) |
| { |
| parm_error_completion(numparms, l2ruleadd_max, buf, sfs_help_l2_rule_add); |
| // if (numparms == 1 && buf[0] == '?') |
| // { |
| // char helpbuf[3000]; |
| // int helpbuf_len; |
| // |
| // helpbuf_len = sfs_help_l2_rule_add(helpbuf); |
| // print_help_buffer(helpbuf, helpbuf_len); |
| // } |
| // else |
| // { |
| // printk(KERN_INFO "Parse problem: expected %d parameters, found %d\n", l2ruleadd_max, numparms); |
| // } |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %s %d 0x%x 0x%x 0x%x %s %s %s %s 0x%x", &ownerid, srcport_str, &rulenum, &parserulebm, |
| &parseflagbm, &action, nextphase_str, l2keyname, frwdname, modname, &pkt_mod_bm); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rulenum[%d], parserulebm[0x%x], action[0x%x], nextphase_str[%s], l2keyname[%s], frwdname[%s], modname[%s], pkt_mod_bm[0x%x]\n", |
| len, parsedargs, ownerid, srcport_str, rulenum, parserulebm, action, nextphase_str, l2keyname, frwdname, modname, pkt_mod_bm); |
| |
| // Minimal help for src_port upper/lower case support |
| for (indx = 0; indx < strlen(srcport_str); indx++) uc_srcport_str[indx] = (char)toupper(srcport_str[indx]); |
| uc_srcport_str[strlen(srcport_str)] = 0; |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_srcport_value(uc_srcport_str, &src_port) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid src_port[%s]\n", srcport_str); |
| } |
| else if (get_phase_value(nextphase_str, &nextphase) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid next_phase[%s]\n", nextphase_str); |
| } |
| else if (((pdbl2keyentry = find_tpm_l2_key_entry_by_name(l2keyname)) == 0) && strcmp(l2keyname, l2_key_empty_name) != 0) |
| { |
| printk(KERN_INFO "L2 key entry [%s] not found\n", l2keyname); |
| } |
| else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && strcmp(frwdname, frwd_empty_name) != 0) |
| { |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| } |
| else if (((pdbmodentry = find_tpm_mod_entry_by_name(modname)) == 0) && strcmp(modname, mod_empty_name) != 0) |
| { |
| printk(KERN_INFO "mod entry [%s] not found\n", modname); |
| } |
| else |
| { |
| tpmcfg_l2_prim_key_entry_t *pentry; |
| rule_action.next_phase = nextphase; |
| rule_action.pkt_act = action; |
| |
| if (pdbl2keyentry != 0) memcpy(&l2_acl, &pdbl2keyentry->l2_acl, sizeof(tpm_l2_acl_key_t)); |
| else memset(&l2_acl, 0, sizeof(tpm_l2_acl_key_t)); |
| |
| if (pdbfrwdentry != 0) memcpy(&pkt_frwd, &pdbfrwdentry->frwd, sizeof(tpm_pkt_frwd_t)); |
| else memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if (pdbmodentry != 0) memcpy(&pkt_mod, &pdbmodentry->mod, sizeof(tpm_pkt_mod_t)); |
| else memset(&pkt_mod, 0, sizeof(tpm_pkt_mod_t)); |
| |
| if ((rc = _tpm_add_l2_rule(ownerid, |
| src_port, |
| rulenum, |
| &rule_idx, |
| parserulebm, |
| parseflagbm, |
| &l2_acl, |
| &pkt_frwd, |
| &pkt_mod, |
| pkt_mod_bm, |
| &rule_action)) == TPM_RC_OK) |
| { |
| if ((pentry = find_tpm_l2_prim_key_entry_by_owner_id_and_rule_num(ownerid, rulenum)) == 0) |
| pentry = find_free_tpm_l2_prim_key_entry(); |
| |
| if (pentry == 0) |
| { |
| printk(KERN_INFO "L2 rule DB full\n"); |
| } |
| else |
| { |
| pentry->action = action; |
| strcpy(pentry->frwd_name, frwdname); |
| strcpy(pentry->key_name, l2keyname); |
| strcpy(pentry->mod_name, modname); |
| strcpy(pentry->next_phase, nextphase_str); |
| pentry->owner_id = ownerid; |
| pentry->parse_rule_bm = parserulebm; |
| pentry->parse_flags_bm = parseflagbm; |
| pentry->pkt_mod_bm = pkt_mod_bm; |
| pentry->rule_num = rulenum; |
| pentry->rule_idx = rule_idx; |
| strcpy(pentry->src_port, srcport_str); |
| pentry->used = 1; |
| } |
| |
| PR_RULE_IDX(rule_idx) |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_l2_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_l3_type_rule_bounce(uint32_t owner_id, |
| tpm_src_port_type_t src_port, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_parse_flags_t parse_flags_bm, |
| tpm_l3_type_key_t *l3_key, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_rule_action_t *rule_action) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_L3_ACL_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->src_port = src_port; |
| tpm_add_acl_rule->rule_num = rule_num; |
| tpm_add_acl_rule->parse_rule_bm = parse_rule_bm; |
| tpm_add_acl_rule->l3_acl_rule.parse_flags_bm = parse_flags_bm; |
| memcpy(&(tpm_add_acl_rule->l3_acl_rule.l3_key), (void*)l3_key, sizeof(tpm_l3_type_key_t)); |
| memcpy(&(tpm_add_acl_rule->l3_acl_rule.pkt_frwd), (void*)pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&(tpm_add_acl_rule->l3_acl_rule.rule_action), (void*)rule_action, sizeof(tpm_rule_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_l3_type_rule tpm_add_l3_type_rule_bounce |
| #else |
| #define _tpm_add_l3_type_rule tpm_add_l3_type_rule |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_l3_rule_add |
| * |
| * DESCRIPTION: |
| * This function creates a L3 rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_l3_rule_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| l3ruleadd_owner=0, l3ruleadd_srcport, l3ruleadd_rulenum, l3ruleadd_parserulebm, l3ruleadd_parseflagsbm, l3ruleadd_action, l3ruleadd_nextphase, |
| l2ruleadd_frwdname, l3ruleadd_l3keyname, l3ruleadd_max |
| } l3ruleadd_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| char srcport_str[20]; |
| char uc_srcport_str[20]; |
| int indx; |
| uint32_t src_port; |
| uint32_t rulenum; |
| uint32_t parserulebm; |
| uint32_t parseflagbm; |
| uint32_t action; |
| char nextphase_str[20]; |
| uint32_t nextphase; |
| char frwdname[20]; |
| char l3keyname[20]; |
| int parsedargs; |
| int numparms; |
| // DB |
| tpmcfg_l3_key_entry_t *pdbl3keyentry = 0; |
| tpmcfg_frwd_entry_t *pdbfrwdentry = 0; |
| // Used in API call |
| tpm_rule_action_t rule_action; |
| tpm_pkt_frwd_t pkt_frwd; |
| tpm_l3_type_key_t l3_acl; |
| uint32_t rule_idx; |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != l3ruleadd_max) |
| { |
| parm_error_completion(numparms, l3ruleadd_max, buf, sfs_help_l3_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %s %d 0x%x 0x%x 0x%x %s %s %s", |
| &ownerid, srcport_str, &rulenum, &parserulebm, &parseflagbm, &action, nextphase_str, l3keyname, frwdname); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rulenum[%d], parserulebm[0x%x], parseflagbm[0x%x], action[0x%x], nextphase_str[%s], l3keyname[%s], frwdname[%s]\n", |
| len, parsedargs, ownerid, srcport_str, rulenum, parserulebm, parseflagbm, action, nextphase_str, l3keyname, frwdname); |
| |
| // Minimal help for src_port upper/lower case support |
| for (indx = 0; indx < strlen(srcport_str); indx++) uc_srcport_str[indx] = (char)toupper(srcport_str[indx]); |
| uc_srcport_str[strlen(srcport_str)] = 0; |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_srcport_value(uc_srcport_str, &src_port) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid src_port[%s]\n", uc_srcport_str); |
| } |
| else if (get_phase_value(nextphase_str, &nextphase) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid next_phase[%s]\n", nextphase_str); |
| } |
| else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && strcmp(frwdname, frwd_empty_name) != 0) |
| { |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| } |
| else if (((pdbl3keyentry = find_tpm_l3_key_entry_by_name(l3keyname)) == 0) && strcmp(l3keyname, l3_key_empty_name) != 0) |
| { |
| printk(KERN_INFO "L3 key entry [%s] not found\n", l3keyname); |
| } |
| else |
| { |
| rule_action.next_phase = nextphase; |
| rule_action.pkt_act = action; |
| |
| if (pdbl3keyentry != 0) memcpy(&l3_acl, &pdbl3keyentry->l3_acl, sizeof(tpm_l3_type_key_t)); |
| else memset(&l3_acl, 0, sizeof(tpm_l3_type_key_t)); |
| |
| if (pdbfrwdentry != 0) memcpy(&pkt_frwd, &pdbfrwdentry->frwd, sizeof(tpm_pkt_frwd_t)); |
| else memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if ((rc = _tpm_add_l3_type_rule(ownerid, |
| src_port, |
| rulenum, |
| &rule_idx, |
| parserulebm, |
| parseflagbm, |
| &l3_acl, |
| &pkt_frwd, |
| &rule_action)) == TPM_RC_OK) |
| PR_RULE_IDX(rule_idx) |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_l3_type_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv4_rule_bounce(uint32_t owner_id, |
| tpm_src_port_type_t src_port, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_parse_flags_t parse_flags_bm, |
| tpm_ipv4_acl_key_t *ipv4_key, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_pkt_mod_t *pkt_mod, |
| tpm_pkt_mod_bm_t pkt_mod_bm, |
| tpm_rule_action_t *rule_action) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_IPv4_ACL_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->src_port = src_port; |
| tpm_add_acl_rule->rule_num = rule_num; |
| tpm_add_acl_rule->parse_rule_bm = parse_rule_bm; |
| tpm_add_acl_rule->ipv4_acl_rule.parse_flags_bm = parse_flags_bm; |
| tpm_add_acl_rule->ipv4_acl_rule.pkt_mod_bm = pkt_mod_bm; |
| memcpy(&(tpm_add_acl_rule->ipv4_acl_rule.ipv4_key), (void*)ipv4_key, sizeof(tpm_ipv4_acl_key_t)); |
| memcpy(&(tpm_add_acl_rule->ipv4_acl_rule.pkt_frwd), (void*)pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&(tpm_add_acl_rule->ipv4_acl_rule.pkt_mod), (void*)pkt_mod, sizeof(tpm_pkt_mod_t)); |
| memcpy(&(tpm_add_acl_rule->ipv4_acl_rule.rule_action), (void*)rule_action, sizeof(tpm_rule_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv4_rule tpm_add_ipv4_rule_bounce |
| #else |
| #define _tpm_add_ipv4_rule tpm_add_ipv4_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_ipv4_rule_add |
| * |
| * DESCRIPTION: |
| * This function creates a IPV4 rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_ipv4_rule_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| ipv4ruleadd_owner=0, ipv4ruleadd_srcport, ipv4ruleadd_rulenum, ipv4ruleadd_parserulebm, ipv4ruleadd_parseflagsbm, |
| ipv4ruleadd_action, ipv4ruleadd_nextphase, ipv4ruleadd_frwdname, ipv4ruleadd_ipv4keyname, ipv4ruleadd_modbm, |
| ipv4ruleadd_modname, ipv4ruleadd_max |
| } ipv4ruleadd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| char srcport_str[20]; |
| char uc_srcport_str[20]; |
| int indx; |
| uint32_t src_port; |
| uint32_t rulenum; |
| uint32_t parserulebm; |
| uint32_t parseflagsbm; |
| uint32_t action; |
| uint32_t nextphase; |
| char nextphase_str[20]; |
| uint32_t modbm; |
| char ipv4keyname[20]; |
| char frwdname[20]; |
| char modname[20]; |
| int parsedargs; |
| int numparms; |
| // DB |
| tpmcfg_ipv4_key_entry_t *pdbipv4keyentry = 0; |
| tpmcfg_frwd_entry_t *pdbfrwdentry = 0; |
| tpmcfg_mod_entry_t *pdbmodentry = 0; |
| // Used in API call |
| tpm_rule_action_t rule_action; |
| tpm_pkt_frwd_t pkt_frwd; |
| tpm_pkt_mod_t pkt_mod; |
| tpm_ipv4_acl_key_t ipv4_acl; |
| uint32_t rule_idx; |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != ipv4ruleadd_max) |
| { |
| parm_error_completion(numparms, ipv4ruleadd_max, buf, sfs_help_ipv4_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %s %d 0x%x 0x%x 0x%x %s 0x%x %s %s %s", &ownerid, srcport_str, &rulenum, &parserulebm, &parseflagsbm, |
| &action, nextphase_str, &modbm, ipv4keyname, frwdname, modname); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rulenum[%d], parserulebm[0x%x], parseflagsbm[0x%x], action[0x%x], nextphase_str[%s], modbm[0x%x], ipv4keyname[%s], frwdname[%s], modname[%s]\n", |
| // len, parsedargs, ownerid, srcport_str, rulenum, parserulebm, parseflagsbm, action, nextphase_str, modbm, ipv4keyname, frwdname, modname); |
| |
| // Minimal help for src_port upper/lower case support |
| for (indx = 0; indx < strlen(srcport_str); indx++) uc_srcport_str[indx] = (char)toupper(srcport_str[indx]); |
| uc_srcport_str[strlen(srcport_str)] = 0; |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_srcport_value(uc_srcport_str, &src_port) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid src_port[%s]\n", srcport_str); |
| } |
| else if (get_phase_value(nextphase_str, &nextphase) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid next_phase[%s]\n", nextphase_str); |
| } |
| else if (((pdbipv4keyentry = find_tpm_ipv4_key_entry_by_name(ipv4keyname)) == 0) && strcmp(ipv4keyname, ipv4_key_empty_name) != 0) |
| { |
| printk(KERN_INFO "IPV4 key entry [%s] not found\n", ipv4keyname); |
| } |
| else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && strcmp(frwdname, frwd_empty_name) != 0) |
| { |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| } |
| else if (((pdbmodentry = find_tpm_mod_entry_by_name(modname)) == 0) && strcmp(modname, mod_empty_name) != 0) |
| { |
| printk(KERN_INFO "mod entry [%s] not found\n", modname); |
| } |
| else |
| { |
| rule_action.next_phase = nextphase; |
| rule_action.pkt_act = action; |
| |
| if (pdbipv4keyentry != 0) memcpy(&ipv4_acl, &pdbipv4keyentry->ipv4_acl, sizeof(tpm_ipv4_acl_key_t)); |
| else memset(&ipv4_acl, 0, sizeof(tpm_ipv4_acl_key_t)); |
| |
| if (pdbfrwdentry != 0) memcpy(&pkt_frwd, &pdbfrwdentry->frwd, sizeof(tpm_pkt_frwd_t)); |
| else memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if (pdbmodentry != 0) memcpy(&pkt_mod, &pdbmodentry->mod, sizeof(tpm_pkt_mod_t)); |
| else memset(&pkt_mod, 0, sizeof(tpm_pkt_mod_t)); |
| |
| if ((rc = _tpm_add_ipv4_rule(ownerid, |
| src_port, |
| rulenum, |
| &rule_idx, |
| parserulebm, |
| parseflagsbm, |
| &ipv4_acl, |
| &pkt_frwd, |
| &pkt_mod, |
| modbm, |
| &rule_action)) == TPM_RC_OK) |
| PR_RULE_IDX(rule_idx) |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_ipv4_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv4_mc_stream_bounce(uint32_t owner_id, |
| uint32_t stream_num, |
| tpm_mc_igmp_mode_t igmp_mode, |
| uint8_t mc_stream_pppoe, |
| uint16_t vid, |
| uint8_t ipv4_src_add[4], |
| uint8_t ipv4_dst_add[4], |
| uint8_t ignore_ipv4_src, |
| tpm_trg_port_type_t dest_port_bm) |
| { |
| tpm_ioctl_mc_rule_t *tpm_mc_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mc_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MC_STREAM_SECTION; |
| tpm_mc_rule->mc_cmd = MV_TPM_IOCTL_ADD_IPv4_MC_STREAM; |
| tpm_mc_rule->stream_num = stream_num; |
| tpm_mc_rule->igmp_mode = igmp_mode; |
| tpm_mc_rule->mc_stream_pppoe = mc_stream_pppoe; |
| tpm_mc_rule->vid = vid; |
| tpm_mc_rule->ipv4_mc.ignore_ipv4_src = ignore_ipv4_src; |
| tpm_mc_rule->dest_port_bm = dest_port_bm; |
| memcpy(&(tpm_mc_rule->ipv4_mc.ipv4_src_add[0]), ipv4_src_add, sizeof(uint8_t)*4); |
| memcpy(&(tpm_mc_rule->ipv4_mc.ipv4_dst_add[0]), ipv4_dst_add, sizeof(uint8_t)*4); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv4_mc_stream tpm_add_ipv4_mc_stream_bounce |
| #else |
| #define _tpm_add_ipv4_mc_stream tpm_add_ipv4_mc_stream |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_mc_ipv4_stream_add |
| * |
| * DESCRIPTION: |
| * This function creates a multicast IPV4 rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_mc_ipv4_stream_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| mcipv4add_owner=0, mcipv4add_stream, mcipv4add_mode, mcipv4add_pppoe, mcipv4add_vid, |
| mcipv4add_src_ip, mcipv4add_dst_ip, mcipv4add_ignore, mcipv4add_target_ports, mcipv4add_max |
| } mcipv4add_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t stream; |
| uint32_t mode; |
| char mc_pppoe_str[20]; |
| uint32_t mc_stream_pppoe; |
| uint32_t vid; |
| char srcip_str[30]; |
| char dstip_str[30]; |
| uint32_t temp_srcip[4]; |
| uint32_t temp_dstip[4]; |
| uint8_t srcip[4]; |
| uint8_t dstip[4]; |
| char ignore_str[20]; |
| uint32_t ignore; |
| uint32_t target_ports; |
| int parsedargs; |
| int numparms; |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != mcipv4add_max) |
| { |
| parm_error_completion(numparms, mcipv4add_max, buf, sfs_help_mc_ipvx_stream_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d %d %s %d %s %s %s 0x%x", |
| &ownerid, &stream, &mode, mc_pppoe_str, &vid, srcip_str, dstip_str, ignore_str, &target_ports); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], stream[%d], vid[%d], srcip_str[%s], dstip_str[%s], ignore_str[%s], target_ports[0x%x]\n", |
| // len, parsedargs, ownerid, stream, vid, srcip_str, dstip_str, ignore_str, target_ports); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_bool_value(mc_pppoe_str, &mc_stream_pppoe) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid ignore[%s]\n", ignore_str); |
| } |
| else if (parse_ipv4_address(srcip_str, temp_srcip) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid src_ip [%s]\n", srcip_str); |
| } |
| else if (parse_ipv4_address(dstip_str, temp_dstip) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid dst_ip [%s]\n", dstip_str); |
| } |
| else if (get_bool_value(ignore_str, &ignore) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid ignore[%s]\n", ignore_str); |
| } |
| else |
| { |
| int indx; |
| |
| for (indx = 0; indx < sizeof(srcip); indx++) |
| { |
| srcip[indx] = (uint8_t)temp_srcip[indx]; |
| dstip[indx] = (uint8_t)temp_dstip[indx]; |
| } |
| |
| if ((rc = _tpm_add_ipv4_mc_stream(ownerid, |
| stream, |
| mode, |
| (uint8_t)mc_stream_pppoe, |
| vid, |
| srcip, |
| dstip, |
| (uint8_t)ignore, |
| target_ports)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_ipv4_mc_stream failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv4_mc_stream_set_queue_bounce( |
| uint32_t owner_id, |
| uint32_t stream_num, |
| tpm_mc_igmp_mode_t igmp_mode, |
| uint8_t mc_stream_pppoe, |
| uint16_t vid, |
| uint8_t ipv4_src_add[4], |
| uint8_t ipv4_dst_add[4], |
| uint8_t ignore_ipv4_src, |
| uint16_t dest_queue, |
| tpm_trg_port_type_t dest_port_bm) |
| { |
| tpm_ioctl_mc_rule_t *tpm_mc_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mc_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MC_STREAM_SECTION; |
| tpm_mc_rule->mc_cmd = MV_TPM_IOCTL_ADD_IPv4_MC_STREAM_SET_QUEUE; |
| tpm_mc_rule->stream_num = stream_num; |
| tpm_mc_rule->igmp_mode = igmp_mode; |
| tpm_mc_rule->mc_stream_pppoe = mc_stream_pppoe; |
| tpm_mc_rule->vid = vid; |
| tpm_mc_rule->ipv4_mc.ignore_ipv4_src = ignore_ipv4_src; |
| tpm_mc_rule->dest_queue = dest_queue; |
| tpm_mc_rule->dest_port_bm = dest_port_bm; |
| memcpy(&(tpm_mc_rule->ipv4_mc.ipv4_src_add[0]), ipv4_src_add, sizeof(uint8_t)*4); |
| memcpy(&(tpm_mc_rule->ipv4_mc.ipv4_dst_add[0]), ipv4_dst_add, sizeof(uint8_t)*4); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv4_mc_stream_set_queue tpm_add_ipv4_mc_stream_set_queue_bounce |
| #else |
| #define _tpm_add_ipv4_mc_stream_set_queue tpm_add_ipv4_mc_stream_set_queue |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_mc_ipv4_stream_set_queue_add |
| * |
| * DESCRIPTION: |
| * This function creates a multicast IPV4 rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_mc_ipv4_stream_set_queue_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| mcipv4add_owner=0, mcipv4add_stream, mcipv4add_mode, mcipv4add_pppoe, mcipv4add_vid, |
| mcipv4add_src_ip, mcipv4add_dst_ip, mcipv4add_ignore, mcipv4add_target_ports, mcipv4add_target_queue, |
| mcipv4add_max |
| } mcipv4add_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t stream; |
| uint32_t mode; |
| char mc_pppoe_str[20]; |
| uint32_t mc_stream_pppoe; |
| uint32_t vid; |
| char srcip_str[30]; |
| char dstip_str[30]; |
| uint32_t temp_srcip[4]; |
| uint32_t temp_dstip[4]; |
| uint8_t srcip[4]; |
| uint8_t dstip[4]; |
| char ignore_str[20]; |
| uint32_t ignore; |
| uint32_t target_queue; |
| uint32_t target_ports; |
| int parsedargs; |
| int numparms; |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != mcipv4add_max) |
| { |
| parm_error_completion(numparms, mcipv4add_max, buf, sfs_help_mc_ipvx_stream_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d %d %s %d %s %s %s %d 0x%x", |
| &ownerid, &stream, &mode, mc_pppoe_str, &vid, srcip_str, dstip_str, ignore_str, &target_queue, &target_ports); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], stream[%d], vid[%d], srcip_str[%s], dstip_str[%s], ignore_str[%s], target_ports[0x%x]\n", |
| // len, parsedargs, ownerid, stream, vid, srcip_str, dstip_str, ignore_str, target_ports); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_bool_value(mc_pppoe_str, &mc_stream_pppoe) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid ignore[%s]\n", ignore_str); |
| } |
| else if (parse_ipv4_address(srcip_str, temp_srcip) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid src_ip [%s]\n", srcip_str); |
| } |
| else if (parse_ipv4_address(dstip_str, temp_dstip) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid dst_ip [%s]\n", dstip_str); |
| } |
| else if (get_bool_value(ignore_str, &ignore) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid ignore[%s]\n", ignore_str); |
| } |
| else |
| { |
| int indx; |
| |
| for (indx = 0; indx < sizeof(srcip); indx++) |
| { |
| srcip[indx] = (uint8_t)temp_srcip[indx]; |
| dstip[indx] = (uint8_t)temp_dstip[indx]; |
| } |
| |
| if ((rc = _tpm_add_ipv4_mc_stream_set_queue(ownerid, |
| stream, |
| mode, |
| (uint8_t)mc_stream_pppoe, |
| vid, |
| srcip, |
| dstip, |
| (uint8_t)ignore, |
| target_queue, |
| target_ports)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_ipv4_mc_stream_set_queue failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv6_mc_stream_set_queue_bounce(uint32_t owner_id, |
| uint32_t stream_num, |
| tpm_mc_igmp_mode_t igmp_mode, |
| uint8_t mc_stream_pppoe, |
| uint16_t vid, |
| uint8_t ipv6_src_add[16], |
| uint8_t ipv6_dst_add[16], |
| uint8_t ignore_ipv6_src, |
| uint16_t dest_queue, |
| tpm_trg_port_type_t dest_port_bm) |
| { |
| tpm_ioctl_mc_rule_t *tpm_mc_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mc_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MC_STREAM_SECTION; |
| tpm_mc_rule->mc_cmd = MV_TPM_IOCTL_ADD_IPv6_MC_STREAM_SET_QUEUE; |
| tpm_mc_rule->stream_num = stream_num; |
| tpm_mc_rule->igmp_mode = igmp_mode; |
| tpm_mc_rule->mc_stream_pppoe = mc_stream_pppoe; |
| tpm_mc_rule->vid = vid; |
| tpm_mc_rule->dest_port_bm = dest_port_bm; |
| tpm_mc_rule->dest_queue = dest_queue; |
| memcpy(&(tpm_mc_rule->ipv6_mc.ipv6_dst_add[0]), ipv6_dst_add, sizeof(uint8_t) * 16); |
| memcpy(&(tpm_mc_rule->ipv6_mc.ipv6_src_add[0]), ipv6_src_add, sizeof(uint8_t) * 16); |
| tpm_mc_rule->ipv6_mc.ignore_ipv6_src = ignore_ipv6_src; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv6_mc_stream_set_queue tpm_add_ipv6_mc_stream_set_queue_bounce |
| #else |
| #define _tpm_add_ipv6_mc_stream_set_queue tpm_add_ipv6_mc_stream_set_queue |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_mc_ipv6_stream_add_set_queue |
| * |
| * DESCRIPTION: |
| * This function creates a multicast ipv6 rule with destination queue |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_mc_ipv6_stream_set_queue_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| mcipv6add_owner=0, mcipv6add_stream, mcipv6add_mode, mcipv6add_pppoe, mcipv6add_vid, |
| mcipv6add_src_ip, mcipv6add_dst_ip, mcipv6add_ignor_src_ip, mcipv6add_target_queue, mcipv6add_target_ports, mcipv6add_max |
| } mcipv6add_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t stream; |
| uint32_t mode; |
| char mc_pppoe_str[20]; |
| uint32_t mc_stream_pppoe; |
| uint32_t vid; |
| char dstip_str[60]; |
| uint32_t temp_dstip[16]; |
| char srcip_str[60]; |
| uint32_t temp_srcip[16]; |
| uint8_t dstip[16]; |
| uint8_t srcip[16]; |
| uint32_t ignor_srcip; |
| char ignore_str[20]; |
| uint32_t target_ports; |
| uint32_t target_queue; |
| int parsedargs; |
| int numparms; |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != mcipv6add_max) |
| { |
| parm_error_completion(numparms, mcipv6add_max, buf, sfs_help_mc_ipvx_stream_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d %d %s %d %s %s %s %d 0x%x", |
| &ownerid, &stream, &mode, mc_pppoe_str, &vid, srcip_str, dstip_str, ignore_str, &target_queue, &target_ports); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], stream[%d], vid[%d], srcip_str[%s], " |
| "dstip_str[%s], ignor_srcip[%s], target_queue[%d], target_ports[0x%x]\n", |
| len, parsedargs, ownerid, stream, vid, srcip_str, dstip_str, ignore_str, target_queue, target_ports); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_bool_value(mc_pppoe_str, &mc_stream_pppoe) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid mc_pppoe_str[%s]\n", mc_pppoe_str); |
| } |
| else if (parse_ipv6_address(dstip_str, temp_dstip) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid dst_ip [%s]\n", dstip_str); |
| } |
| else if (parse_ipv6_address(srcip_str, temp_srcip) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid srcip_str [%s]\n", srcip_str); |
| } |
| else if (get_bool_value(ignore_str, &ignor_srcip) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid ignore[%s]\n", ignore_str); |
| } |
| else |
| { |
| int indx; |
| |
| for (indx = 0; indx < sizeof(dstip); indx++) |
| { |
| dstip[indx] = (uint8_t)temp_dstip[indx]; |
| srcip[indx] = (uint8_t)temp_srcip[indx]; |
| } |
| |
| if ((rc = _tpm_add_ipv6_mc_stream_set_queue(ownerid, |
| stream, |
| mode, |
| (uint8_t)mc_stream_pppoe, |
| vid, |
| srcip, |
| dstip, |
| ignor_srcip, |
| target_queue, |
| target_ports)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_ipv6_mc_stream_set_queue failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv6_mc_stream_bounce(uint32_t owner_id, |
| uint32_t stream_num, |
| tpm_mc_igmp_mode_t igmp_mode, |
| uint8_t mc_stream_pppoe, |
| uint16_t vid, |
| uint8_t ipv6_src_add[16], |
| uint8_t ipv6_dst_add[16], |
| uint8_t ignore_ipv6_src, |
| tpm_trg_port_type_t dest_port_bm) |
| { |
| tpm_ioctl_mc_rule_t *tpm_mc_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mc_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MC_STREAM_SECTION; |
| tpm_mc_rule->mc_cmd = MV_TPM_IOCTL_ADD_IPv6_MC_STREAM; |
| tpm_mc_rule->stream_num = stream_num; |
| tpm_mc_rule->igmp_mode = igmp_mode; |
| tpm_mc_rule->mc_stream_pppoe = mc_stream_pppoe; |
| tpm_mc_rule->vid = vid; |
| tpm_mc_rule->dest_port_bm = dest_port_bm; |
| memcpy(&(tpm_mc_rule->ipv6_mc.ipv6_dst_add[0]), ipv6_dst_add, sizeof(uint8_t) * 16); |
| memcpy(&(tpm_mc_rule->ipv6_mc.ipv6_src_add[0]), ipv6_src_add, sizeof(uint8_t) * 16); |
| tpm_mc_rule->ipv6_mc.ignore_ipv6_src = ignore_ipv6_src; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv6_mc_stream tpm_add_ipv6_mc_stream_bounce |
| #else |
| #define _tpm_add_ipv6_mc_stream tpm_add_ipv6_mc_stream |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_mc_ipv6_stream_add |
| * |
| * DESCRIPTION: |
| * This function creates a multicast ipv6 rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_mc_ipv6_stream_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| mcipv6add_owner=0, mcipv6add_stream, mcipv6add_mode, mcipv6add_pppoe, mcipv6add_vid, |
| mcipv6add_src_ip, mcipv6add_dst_ip, mcipv6add_ignor_src_ip, mcipv6add_target_ports, mcipv6add_max |
| } mcipv6add_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t stream; |
| uint32_t mode; |
| char mc_pppoe_str[20]; |
| uint32_t mc_stream_pppoe; |
| uint32_t vid; |
| char dstip_str[60]; |
| uint32_t temp_dstip[16]; |
| char srcip_str[60]; |
| uint32_t temp_srcip[16]; |
| uint8_t dstip[16]; |
| uint8_t srcip[16]; |
| uint32_t ignor_srcip; |
| char ignore_str[20]; |
| uint32_t target_ports; |
| int parsedargs; |
| int numparms; |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != mcipv6add_max) |
| { |
| parm_error_completion(numparms, mcipv6add_max, buf, sfs_help_mc_ipvx_stream_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d %d %s %d %s %s %s 0x%x", |
| &ownerid, &stream, &mode, mc_pppoe_str, &vid, srcip_str, dstip_str, ignore_str, &target_ports); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], stream[%d], vid[%d], srcip_str[%s], " |
| "dstip_str[%s], ignor_srcip[%s], target_ports[0x%x]\n", |
| len, parsedargs, ownerid, stream, vid, srcip_str, dstip_str, ignore_str, target_ports); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_bool_value(mc_pppoe_str, &mc_stream_pppoe) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid mc_pppoe_str[%s]\n", mc_pppoe_str); |
| } |
| else if (parse_ipv6_address(dstip_str, temp_dstip) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid dst_ip [%s]\n", dstip_str); |
| } |
| else if (parse_ipv6_address(srcip_str, temp_srcip) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid srcip_str [%s]\n", srcip_str); |
| } |
| else if (get_bool_value(ignore_str, &ignor_srcip) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid ignore[%s]\n", ignore_str); |
| } |
| else |
| { |
| int indx; |
| |
| for (indx = 0; indx < sizeof(dstip); indx++) |
| { |
| dstip[indx] = (uint8_t)temp_dstip[indx]; |
| srcip[indx] = (uint8_t)temp_srcip[indx]; |
| } |
| |
| if ((rc = _tpm_add_ipv6_mc_stream(ownerid, |
| stream, |
| mode, |
| (uint8_t)mc_stream_pppoe, |
| vid, |
| srcip, |
| dstip, |
| ignor_srcip, |
| target_ports)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_ipv6_mc_stream failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_set_port_igmp_frwd_mode_bounce(tpm_src_port_type_t src_port, |
| tpm_igmp_frwd_mode_t mode) |
| { |
| tpm_ioctl_igmp_t *tpm_igmp = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_igmp; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_IGMP_SECTION; |
| tpm_igmp->igmp_cmd = MV_TPM_IOCTL_IGMP_SET_PORT_FRWD_MODE; |
| tpm_igmp->src_port = src_port; |
| tpm_igmp->frwd_mode = mode; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_set_port_igmp_frwd_mode tpm_set_port_igmp_frwd_mode_bounce |
| #else |
| #define _tpm_set_port_igmp_frwd_mode tpm_set_port_igmp_frwd_mode |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_igmp_port_forward_mode_cfg |
| * |
| * DESCRIPTION: |
| * This function creates a multicast IPV4 rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_igmp_port_forward_mode_cfg (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| igmpfrwd_owner=0, igmpfrwd_src_port, igmpfrwd_mode, igmpfrwd_max |
| } igmpfrwd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; // NOTE: not used in API!! |
| char srcport_str[30]; |
| char uc_srcport_str[30]; |
| int indx; |
| uint32_t src_port; |
| char mode_str[30]; |
| uint32_t mode; |
| int parsedargs; |
| int numparms; |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != igmpfrwd_max) |
| { |
| parm_error_completion(numparms, igmpfrwd_max, buf, sfs_help_igmp_cfg); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %s %s", &ownerid, srcport_str, mode_str); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], mode_str[%s]\n", |
| // len, parsedargs, ownerid, srcport_str, mode_str); |
| |
| // Minimal help for src_port upper/lower case support |
| for (indx = 0; indx < strlen(srcport_str); indx++) uc_srcport_str[indx] = (char)toupper(srcport_str[indx]); |
| uc_srcport_str[strlen(srcport_str)] = 0; |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_igmp_srcport_value(uc_srcport_str, &src_port) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid src_port [%s]\n", srcport_str); |
| } |
| else if (get_igmp_mode_value(mode_str, &mode) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid mode [%s]\n", mode_str); |
| } |
| else |
| { |
| if ((rc = _tpm_set_port_igmp_frwd_mode(src_port, |
| mode)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_set_port_igmp_frwd_mode failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_set_igmp_cpu_rx_queue_bounce(uint32_t queue) |
| { |
| tpm_ioctl_igmp_t *tpm_igmp = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_igmp; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_IGMP_SECTION; |
| tpm_igmp->igmp_cmd = MV_TPM_IOCTL_IGMP_SET_CPU_RX_Q; |
| tpm_igmp->cpu_queue = queue; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_set_igmp_cpu_rx_queue tpm_set_igmp_cpu_rx_queue_bounce |
| #else |
| #define _tpm_set_igmp_cpu_rx_queue tpm_set_igmp_cpu_rx_queue |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_igmp_cpu_queue_cfg |
| * |
| * DESCRIPTION: |
| * This function configres the CPU queue for IGMP |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_igmp_cpu_queue_cfg (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| igmpcpuq_owner=0, igmpcpuq_queue, igmpcpuq_max |
| } igmpcpuq_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; // NOTE: not used in API!! |
| uint32_t que; |
| int parsedargs; |
| int numparms; |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != igmpcpuq_max) |
| { |
| parm_error_completion(numparms, igmpcpuq_max, buf, sfs_help_igmp_cfg); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &que); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], que[%d]\n", |
| // len, parsedargs, ownerid, que); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (que >= TPM_MAX_NUM_RX_QUEUE) // Hope this a good choice |
| { |
| printk(KERN_INFO "Invalid queue [%d]\n", que); |
| } |
| else |
| { |
| if ((rc = _tpm_set_igmp_cpu_rx_queue(que)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_set_igmp_cpu_rx_queue failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| /*Evan*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_set_igmp_proxy_sa_mac_bounce(uint8_t *sa_mac) |
| { |
| tpm_ioctl_igmp_t *tpm_igmp_set_sa_mac = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_igmp; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_IGMP_SECTION; |
| tpm_igmp_set_sa_mac->igmp_cmd = MV_TPM_IOCTL_SET_IGMP_PROXY_SA_MAC; |
| memcpy(tpm_igmp_set_sa_mac->sa_mac, (void *)sa_mac, 6); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_set_igmp_proxy_sa_mac tpm_set_igmp_proxy_sa_mac_bounce |
| #else |
| #define _tpm_set_igmp_proxy_sa_mac tpm_set_igmp_proxy_sa_mac |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_igmp_proxy_sa_mac |
| * |
| * DESCRIPTION: |
| * This function configures the sa_mac for IGMP proxy |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_igmp_proxy_sa_mac (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| igmpproxysa_owner=0, igmpproxysa_mac, igmpproxysa_max |
| } igmpproxysa_parm_indx_t; |
| |
| // shell line parsing |
| unsigned int ownerid, i; |
| uint8_t mac[6]; |
| uint32_t temp_mac[6]; |
| int parsedargs; |
| int numparms; |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| |
| numparms = count_parameters(buf); |
| if (numparms != igmpproxysa_max) |
| { |
| parm_error_completion(numparms, igmpproxysa_max, buf, sfs_help_igmp_cfg); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %02x:%02x:%02x:%02x:%02x:%02x", |
| &ownerid, &temp_mac[0], &temp_mac[1], &temp_mac[2], &temp_mac[3], &temp_mac[4], &temp_mac[5]); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], sa_mac[%02x:%02x:%02x:%02x:%02x:%02x]\n", |
| // len, parsedargs, ownerid, temp_mac[0], temp_mac[1], temp_mac[2], temp_mac[3], temp_mac[4], temp_mac[5]); |
| |
| if (parsedargs != 7) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, 7); |
| } |
| else |
| { |
| for (i=0;i<6;i++) |
| { |
| mac[i] = temp_mac[i]; |
| } |
| if ((rc = _tpm_set_igmp_proxy_sa_mac (mac)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_set_igmp_proxy_sa_mac failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_l2_rule_bounce(uint32_t owner_id, |
| uint32_t rule_idx) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_L2_ACL_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->rule_idx = rule_idx; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_l2_rule tpm_del_l2_rule_bounce |
| #else |
| #define _tpm_del_l2_rule tpm_del_l2_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_l2 |
| * |
| * DESCRIPTION: |
| * This function deletes a L2 HW rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_l2 (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| noruleaddl2_owner=0, noruleaddl2_ruleidx, noruleaddl2_max |
| } noruleaddl2_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t rule_num; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noruleaddl2_max) |
| { |
| parm_error_completion(numparms, noruleaddl2_max, buf, sfs_help_no_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &rule_num); |
| //printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], rule_idx[%d]\n", |
| // len, parsedargs, ownerid, rule_idx); |
| |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| tpmcfg_l2_prim_key_entry_t *pentry; |
| pentry = find_tpm_l2_prim_key_entry_by_owner_id_and_rule_num(ownerid, rule_num); |
| if (pentry != 0) { |
| if ((rc = _tpm_del_l2_rule(ownerid, pentry->rule_idx)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_del_l2_prim_rule failed, rc[%d] - %s\n", |
| __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| pentry->used = 0; |
| } |
| else |
| { |
| printk("%s: Table l2_rule does not have entry owner_id[%d], rule_num[%d]\n", |
| __FUNCTION__, ownerid, rule_num); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_l3_type_rule_bounce(uint32_t owner_id, |
| uint32_t rule_idx) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_L3_ACL_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->rule_idx = rule_idx; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_l3_type_rule tpm_del_l3_type_rule_bounce |
| #else |
| #define _tpm_del_l3_type_rule tpm_del_l3_type_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_l3 |
| * |
| * DESCRIPTION: |
| * This function deletes a L3 HW rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_l3 (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| noruleaddl3_owner=0, noruleaddl3_ruleidx, noruleaddl3_max |
| } noruleaddl3_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t rule_idx; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noruleaddl3_max) |
| { |
| parm_error_completion(numparms, noruleaddl3_max, buf, sfs_help_no_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &rule_idx); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rule_idx[%d], parserulebm[0x%x], keyname[%s]\n", |
| // len, parsedargs, ownerid, srcport_str, rule_idx, parserulebm, keyname); |
| |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = _tpm_del_l3_type_rule(ownerid, |
| rule_idx)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_del_l3_type_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ipv4_rule_bounce(uint32_t owner_id, |
| uint32_t rule_idx) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_IPv4_ACL_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->rule_idx = rule_idx; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_ipv4_rule tpm_del_ipv4_rule_bounce |
| #else |
| #define _tpm_del_ipv4_rule tpm_del_ipv4_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_ipv4 |
| * |
| * DESCRIPTION: |
| * This function deletes a IPV4 HW rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_ipv4 (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| noruleaddipv4_owner=0, noruleaddipv4_ruleidx, noruleaddipv4_max |
| } noruleaddipv4_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t rule_idx; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noruleaddipv4_max) |
| { |
| parm_error_completion(numparms, noruleaddipv4_max, buf, sfs_help_no_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", |
| &ownerid, &rule_idx); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rule_idx[%d], parserulebm[0x%x], keyname[%s]\n", |
| // len, parsedargs, ownerid, srcport_str, rule_idx, parserulebm, keyname); |
| |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = _tpm_del_ipv4_rule(ownerid, |
| rule_idx)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_del_ipv4_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ipv4_mc_stream_bounce(uint32_t owner_id, |
| uint32_t stream_num) |
| { |
| tpm_ioctl_mc_rule_t *tpm_mc_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mc_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MC_STREAM_SECTION; |
| tpm_mc_rule->mc_cmd = MV_TPM_IOCTL_DEL_IPv4_MC_STREAM; |
| tpm_mc_rule->owner_id = owner_id; |
| tpm_mc_rule->stream_num = stream_num; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_ipv4_mc_stream tpm_del_ipv4_mc_stream_bounce |
| #else |
| #define _tpm_del_ipv4_mc_stream tpm_del_ipv4_mc_stream |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_mc_stream_add_ipv4 |
| * |
| * DESCRIPTION: |
| * This function deletes a DSCP IPV6 HW rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_mc_stream_add_ipv4 (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| nostreamaddipv4_owner=0, nostreamaddipv4_ruleidx, nostreamaddipv4_max |
| } nostreamaddipv4_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t stream; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != nostreamaddipv4_max) |
| { |
| parm_error_completion(numparms, nostreamaddipv4_max, buf, sfs_help_no_mc_stream_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &stream); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], stream[%d]\n", len, parsedargs, ownerid, stream); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if ((rc = _tpm_del_ipv4_mc_stream(ownerid, |
| stream)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_del_ipv4_mc_stream failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ipv6_mc_stream_bounce(uint32_t owner_id, |
| uint32_t stream_num) |
| { |
| tpm_ioctl_mc_rule_t *tpm_mc_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mc_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MC_STREAM_SECTION; |
| tpm_mc_rule->mc_cmd = MV_TPM_IOCTL_DEL_IPv6_MC_STREAM; |
| tpm_mc_rule->owner_id = owner_id; |
| tpm_mc_rule->stream_num = stream_num; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_ipv6_mc_stream tpm_del_ipv6_mc_stream_bounce |
| #else |
| #define _tpm_del_ipv6_mc_stream tpm_del_ipv6_mc_stream |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_mc_stream_add_ipv6 |
| * |
| * DESCRIPTION: |
| * This function deletes a DSCP IPV6 HW rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_mc_stream_add_ipv6 (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| nostreamaddipv6_owner=0, nostreamaddipv6_ruleidx, nostreamaddipv6_max |
| } nostreamaddipv6_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t stream; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != nostreamaddipv6_max) |
| { |
| parm_error_completion(numparms, nostreamaddipv6_max, buf, sfs_help_no_mc_stream_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &stream); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], stream[%d]\n", len, parsedargs, ownerid, stream); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if ((rc = _tpm_del_ipv6_mc_stream(ownerid, |
| stream)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_del_ipv6_mc_stream failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| /*Evan*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_proc_set_enable_mtu_bounce(tpm_init_mtu_setting_enable_t enable) |
| { |
| tpm_ioctl_mtu_t *tpm_mtu_set = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_mtu_set; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MTU_SECTION; |
| tpm_mtu_set->mtu_setting_cmd = MV_TPM_IOCTL_SET_MTU_ADMIN; |
| tpm_mtu_set->enable = enable; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_proc_set_enable_mtu tpm_proc_set_enable_mtu_bounce |
| #else |
| #define _tpm_proc_set_enable_mtu tpm_db_set_mtu_enable |
| #endif |
| |
| void sfs_tpm_cfg_set_mtu_enable (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| mtu_enable=0, mtu_enable_max |
| } mtu_enable_indx_t; |
| /*shell line parsing*/ |
| int enable; |
| |
| int parsedargs; |
| int numparms; |
| |
| /*used in API call*/ |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != mtu_enable_max) |
| parm_error_completion(numparms, mtu_enable_max, buf, sfs_help_setup); |
| else { |
| /*get parameters*/ |
| parsedargs = sscanf(buf, "%d", &enable); |
| if (parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else if ((enable != 1) && (enable != 0)) |
| printk(KERN_INFO "Invalid enable[%d]\n", enable); |
| else { |
| if ((rc = _tpm_proc_set_enable_mtu(enable)) == TPM_RC_OK) |
| printk(KERN_INFO "OK\n"); |
| else |
| printk(KERN_INFO "%s: tpm_proc_set_enable_mtu failed, rc[%d] - %s\n", |
| __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| /*Evan*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_proc_set_mtu_bounce(uint32_t ipv4_or_ipv6, |
| uint32_t direction, |
| uint32_t mtu) |
| { |
| tpm_ioctl_mtu_t *tpm_mtu_set = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_mtu_set; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MTU_SECTION; |
| tpm_mtu_set->mtu_setting_cmd = MV_TPM_IOCTL_SET_MTU; |
| tpm_mtu_set->ethertype = ipv4_or_ipv6; |
| tpm_mtu_set->direction = direction; |
| tpm_mtu_set->mtu = mtu; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_proc_set_mtu tpm_proc_set_mtu_bounce |
| #else |
| #define _tpm_proc_set_mtu tpm_proc_set_mtu |
| #endif |
| |
| void sfs_tpm_cfg_set_mtu (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| mtu_ipv4_or_ipv6=0, mtu_direction, mtu_value, mtu_max |
| } mtu_indx_t; |
| // shell line parsing |
| uint32_t ipv4_or_ipv6; |
| uint32_t direction; |
| uint32_t mtu; |
| |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| tpm_setup_t setup; |
| |
| memset(&setup, 0, sizeof(tpm_setup_t)); |
| |
| numparms = count_parameters(buf); |
| if (numparms != mtu_max) |
| { |
| parm_error_completion(numparms, mtu_max, buf, sfs_help_setup); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d %d", &ipv4_or_ipv6, &direction, &mtu); |
| printk(KERN_INFO "ipv4_or_ipv6=%d, direction=%d. mtu[%d],\n", ipv4_or_ipv6, direction, mtu); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (ipv4_or_ipv6 >= 2) |
| { |
| printk(KERN_INFO "Invalid ipv4_or_ipv6[%d]\n", ipv4_or_ipv6); |
| } |
| else if (direction >= 2) |
| { |
| printk(KERN_INFO "Invalid direction[%d]\n", direction); |
| } |
| else |
| { |
| if ((rc = _tpm_proc_set_mtu(ipv4_or_ipv6, direction, mtu)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_proc_set_mtu failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| } |
| |
| /*Evan*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_proc_set_pppoe_mtu_bounce(uint32_t ipv4_or_ipv6, |
| uint32_t direction, |
| uint32_t pppoe_mtu) |
| { |
| tpm_ioctl_mtu_t *tpm_mtu_set = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_mtu_set; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MTU_SECTION; |
| tpm_mtu_set->mtu_setting_cmd = MV_TPM_IOCTL_SET_PPPOE_MTU; |
| tpm_mtu_set->ethertype = ipv4_or_ipv6; |
| tpm_mtu_set->direction = direction; |
| tpm_mtu_set->pppoe_mtu= pppoe_mtu; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_proc_set_pppoe_mtu tpm_proc_set_pppoe_mtu_bounce |
| #else |
| #define _tpm_proc_set_pppoe_mtu tpm_proc_set_pppoe_mtu |
| #endif |
| |
| |
| void sfs_tpm_cfg_set_pppoe_mtu (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| pppoe_mtu_ipv4_or_ipv6=0, pppoe_mtu_direction, pppoe_mtu_value, pppoe_mtu_max |
| } pppoe_mtu_indx_t; |
| // shell line parsing |
| uint32_t ipv4_or_ipv6; |
| uint32_t direction; |
| uint32_t pppoe_mtu; |
| |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| tpm_setup_t setup; |
| |
| memset(&setup, 0, sizeof(tpm_setup_t)); |
| |
| numparms = count_parameters(buf); |
| if (numparms != pppoe_mtu_max) |
| { |
| parm_error_completion(numparms, pppoe_mtu_max, buf, sfs_help_setup); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d %d", &ipv4_or_ipv6, &direction, &pppoe_mtu); |
| printk(KERN_INFO "ipv4_or_ipv6=%d, direction=%d. pppoe_mtu[%d],\n", ipv4_or_ipv6, direction, pppoe_mtu); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (ipv4_or_ipv6 >= 2) |
| { |
| printk(KERN_INFO "Invalid ipv4_or_ipv6[%d]\n", ipv4_or_ipv6); |
| } |
| else if (direction >= 2) |
| { |
| printk(KERN_INFO "Invalid direction[%d]\n", direction); |
| } |
| else |
| { |
| if ((rc = _tpm_proc_set_pppoe_mtu(ipv4_or_ipv6, direction, pppoe_mtu)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_proc_set_pppoe_mtu failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ipv6_gen_rule_bounce(uint32_t owner_id, |
| uint32_t rule_idx) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_IPV6_GEN_ACL_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->rule_idx = rule_idx; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_ipv6_gen_rule tpm_del_ipv6_gen_rule_bounce |
| #else |
| #define _tpm_del_ipv6_gen_rule tpm_del_ipv6_gen_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_ipv6_gen_acl |
| * |
| * DESCRIPTION: |
| * This function deletes a IPV6 HW gen ACL rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_ipv6_gen_acl (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| noipv6gen_owner=0, noipv6gen_ruleidx, noipv6gen_max |
| } noipv6genruleadd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t rule_idx; |
| int parsedargs; |
| int numparms; |
| // DB |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noipv6gen_max) |
| { |
| parm_error_completion(numparms, noipv6gen_max, buf, sfs_help_no_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &rule_idx); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], rule_idx[%d]\n", |
| len, parsedargs, ownerid, rule_idx); |
| |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = _tpm_del_ipv6_gen_rule(ownerid, |
| rule_idx)) == TPM_RC_OK) |
| PR_RESULT |
| else |
| { |
| printk(KERN_INFO "%s: tpm_del_ipv6_gen_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv6_gen_rule_bounce(uint32_t owner_id, |
| tpm_src_port_type_t src_port, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_parse_flags_t parse_flags_bm, |
| tpm_ipv6_gen_acl_key_t *ipv6_gen_key, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_pkt_mod_t *pkt_mod, |
| tpm_pkt_mod_bm_t pkt_mod_bm, |
| tpm_rule_action_t *rule_action) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_IPV6_GEN_ACL_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->src_port = src_port; |
| tpm_add_acl_rule->rule_num = rule_num; |
| tpm_add_acl_rule->parse_rule_bm = parse_rule_bm; |
| tpm_add_acl_rule->ipv6_gen_acl_rule.parse_flags_bm = parse_flags_bm; |
| tpm_add_acl_rule->ipv6_gen_acl_rule.pkt_mod_bm = pkt_mod_bm; |
| |
| memcpy(&(tpm_add_acl_rule->ipv6_gen_acl_rule.ipv6_gen_key), ipv6_gen_key, sizeof(tpm_ipv6_gen_acl_key_t)); |
| memcpy(&(tpm_add_acl_rule->ipv6_gen_acl_rule.pkt_frwd), pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&(tpm_add_acl_rule->ipv6_gen_acl_rule.pkt_mod), pkt_mod, sizeof(tpm_pkt_mod_t)); |
| memcpy(&(tpm_add_acl_rule->ipv6_gen_acl_rule.rule_action), rule_action, sizeof(tpm_rule_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv6_gen_rule tpm_add_ipv6_gen_rule_bounce |
| #else |
| #define _tpm_add_ipv6_gen_rule tpm_add_ipv6_gen_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_ipv6_gen_rule_add |
| * |
| * DESCRIPTION: |
| * This function create IPv6 general rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_ipv6_gen_rule_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| ipv6ruleadd_owner=0, ipv6ruleadd_srcport, ipv6ruleadd_rulenum, ipv6ruleadd_parserulebm, ipv6ruleadd_parseflagsbm, |
| ipv6ruleadd_action, ipv6ruleadd_nextphase, ipv6ruleadd_modbm, ipv6ruleadd_ipv6genkeyname, ipv6ruleadd_frwdname, |
| ipv6ruleadd_modname, ipv6ruleadd_max |
| } ipv4ruleadd_parm_indx_t; |
| |
| uint32_t owner_id; |
| tpm_src_port_type_t src_port; |
| uint32_t rule_num; |
| uint32_t rule_idx; |
| tpm_parse_fields_t parse_rule_bm; |
| tpm_parse_flags_t parse_flags_bm; |
| tpm_ipv6_gen_acl_key_t ipv6_gen_key; |
| tpm_pkt_frwd_t pkt_frwd; |
| tpm_pkt_mod_t pkt_mod; |
| tpm_pkt_mod_bm_t pkt_mod_bm; |
| tpm_rule_action_t rule_action; |
| |
| tpmcfg_ipv6_gen_key_entry_t *pdbipv6genkeyentry = 0; |
| tpmcfg_frwd_entry_t *pdbfrwdentry = 0; |
| tpmcfg_mod_entry_t *pdbmodentry = 0; |
| |
| tpm_error_code_t rc; |
| int indx; |
| int parsedargs; |
| int numparms; |
| uint32_t action; |
| uint32_t nextphase; |
| char srcport_str[20]; |
| char uc_srcport_str[20]; |
| char nextphase_str[20]; |
| char ipv6genkeyname[30]; |
| char frwdname[20]; |
| char modname[20]; |
| |
| |
| numparms = count_parameters(buf); |
| if (numparms != ipv6ruleadd_max) |
| { |
| parm_error_completion(numparms, ipv6ruleadd_max, buf, sfs_help_ipv6_gen_rule_add); |
| } |
| else |
| { |
| parsedargs = sscanf(buf, "%d %s %d 0x%x 0x%x 0x%x %s 0x%x %s %s %s", |
| &owner_id, srcport_str, &rule_num, &parse_rule_bm, &parse_flags_bm, |
| &action, nextphase_str, &pkt_mod_bm, ipv6genkeyname, frwdname, modname); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rulenum[%d], parserulebm[0x%x], parseflagsbm[0x%x], action[0x%x], nextphase_str[%s], modbm[0x%x], ipv6keyname[%s], frwdname[%s], modname[%s]\n", |
| len, parsedargs, owner_id, srcport_str, rule_num, parse_rule_bm, parse_flags_bm, action, nextphase_str, pkt_mod_bm, ipv6genkeyname, frwdname, modname); |
| |
| for (indx = 0; indx < strlen(srcport_str); indx++) |
| { |
| uc_srcport_str[indx] = (char)toupper(srcport_str[indx]); |
| } |
| uc_srcport_str[strlen(srcport_str)] = 0; |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_srcport_value(uc_srcport_str, &src_port) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid src_port[%s]\n", srcport_str); |
| } |
| else if (get_phase_value(nextphase_str, &nextphase) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid next_phase[%s]\n", nextphase_str); |
| } |
| else if (((pdbipv6genkeyentry = find_tpm_ipv6_gen_key_entry_by_name(ipv6genkeyname)) == 0) && \ |
| strcmp(ipv6genkeyname, ipv6_gen_key_empty_name) != 0) |
| { |
| printk(KERN_INFO "IPV4 key entry [%s] not found\n", ipv6genkeyname); |
| } |
| else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && \ |
| strcmp(frwdname, frwd_empty_name) != 0) |
| { |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| } |
| else if (((pdbmodentry = find_tpm_mod_entry_by_name(modname)) == 0) && \ |
| strcmp(modname, mod_empty_name) != 0) |
| { |
| printk(KERN_INFO "mod entry [%s] not found\n", modname); |
| } |
| else |
| { |
| rule_action.next_phase = nextphase; |
| rule_action.pkt_act = action; |
| |
| if (pdbipv6genkeyentry != 0) |
| memcpy(&ipv6_gen_key, &pdbipv6genkeyentry->ipv6gen_acl, sizeof(tpm_ipv6_gen_acl_key_t)); |
| else |
| memset(&ipv6_gen_key, 0, sizeof(tpm_ipv6_gen_acl_key_t)); |
| |
| if (pdbfrwdentry != 0) |
| memcpy(&pkt_frwd, &pdbfrwdentry->frwd, sizeof(tpm_pkt_frwd_t)); |
| else |
| memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if (pdbmodentry != 0) |
| memcpy(&pkt_mod, &pdbmodentry->mod, sizeof(tpm_pkt_mod_t)); |
| else |
| memset(&pkt_mod, 0, sizeof(tpm_pkt_mod_t)); |
| |
| if (TPM_RC_OK == (rc = _tpm_add_ipv6_gen_rule(owner_id, |
| src_port, |
| rule_num, |
| &rule_idx, |
| parse_rule_bm, |
| parse_flags_bm, |
| &ipv6_gen_key, |
| &pkt_frwd, |
| &pkt_mod, |
| pkt_mod_bm, |
| &rule_action)) ) |
| PR_RULE_IDX(rule_idx) |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_ipv6_gen_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| /*Evan*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_oam_epon_add_channel_bounce(uint32_t owner_id, |
| uint32_t cpu_rx_queue, |
| tpm_trg_port_type_t llid_num) |
| { |
| tpm_ioctl_mng_ch_t *tpm_oam_epon_chan = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mng_channel; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MNG_SECTION; |
| tpm_oam_epon_chan->mng_cmd = MV_TPM_IOCTL_ADD_OAM_CHNL; |
| tpm_oam_epon_chan->tpm_ioctl_oam_ch.owner_id = owner_id; |
| tpm_oam_epon_chan->tpm_ioctl_oam_ch.cpu_rx_queue = cpu_rx_queue; |
| tpm_oam_epon_chan->tpm_ioctl_oam_ch.llid_num = llid_num; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_oam_epon_add_channel tpm_oam_epon_add_channel_bounce |
| #else |
| #define _tpm_oam_epon_add_channel tpm_oam_epon_add_channel |
| #endif |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_oam_channel |
| * |
| * DESCRIPTION: |
| * This function creates OAM channel HW rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_oam_channel (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| oam_owner=0, oam_rxq, oam_llid, oam_max |
| } oam_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t rx_q; |
| uint32_t llid; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != oam_max) |
| { |
| parm_error_completion(numparms, oam_max, buf, sfs_help_oam_omci_channel); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d 0x%x", &ownerid, &rx_q, &llid); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], rxq[%d], llid[0x%x]\n", len, parsedargs, ownerid, rx_q, llid); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if ((rc = _tpm_oam_epon_add_channel (ownerid, |
| rx_q, |
| llid)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_oam_epon_add_channel failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| /*Evan*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_omci_add_channel_bounce(uint32_t owner_id, |
| tpm_gem_port_key_t gem_port, |
| uint32_t cpu_rx_queue, |
| tpm_trg_port_type_t tcont_num, |
| uint32_t cpu_tx_queue) |
| { |
| tpm_ioctl_mng_ch_t *tpm_omci_gpon_chan = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mng_channel; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MNG_SECTION; |
| tpm_omci_gpon_chan->mng_cmd = MV_TPM_IOCTL_ADD_OMCI_CHNL; |
| tpm_omci_gpon_chan->tpm_ioctl_omci_ch.owner_id = owner_id; |
| tpm_omci_gpon_chan->tpm_ioctl_omci_ch.gem_port = gem_port; |
| tpm_omci_gpon_chan->tpm_ioctl_omci_ch.cpu_rx_queue = cpu_rx_queue; |
| tpm_omci_gpon_chan->tpm_ioctl_omci_ch.tcont_num = tcont_num; |
| tpm_omci_gpon_chan->tpm_ioctl_omci_ch.cpu_tx_queue = cpu_tx_queue; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_omci_add_channel tpm_omci_add_channel_bounce |
| #else |
| #define _tpm_omci_add_channel tpm_omci_add_channel |
| #endif |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_omci_channel |
| * |
| * DESCRIPTION: |
| * This function creates creates an OMCI channel HW rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_omci_channel (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| omci_owner=0, omci_gemport, omci_rxq, omci_txq, omci_tcont, omci_max |
| } omci_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t gemport; |
| uint32_t rx_q; |
| uint32_t tx_q; |
| uint32_t tcont; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != omci_max) |
| { |
| parm_error_completion(numparms, omci_max, buf, sfs_help_oam_omci_channel); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d %d %d 0x%x", &ownerid, &gemport, &rx_q, &tx_q, &tcont); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], gemport[%d], rx_q[%d], tx_q[%d], tcont[0x%x]\n", |
| // len, parsedargs, ownerid, gemport, rx_q, tx_q, tcont); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (gemport >= 255) |
| { |
| printk(KERN_INFO "invalid gemport[%d]\n", gemport); |
| } |
| else |
| { |
| if ((rc = _tpm_omci_add_channel (ownerid, |
| (uint16_t)gemport, |
| rx_q, |
| tcont, |
| tx_q)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_omci_add_channel failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| /*Evan*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_oam_epon_del_channel_bounce(uint32_t owner_id) |
| { |
| tpm_ioctl_mng_ch_t *tpm_oam_epon_chan = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mng_channel; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MNG_SECTION; |
| tpm_oam_epon_chan->mng_cmd = MV_TPM_IOCTL_DEL_OAM_CHNL; |
| tpm_oam_epon_chan->tpm_ioctl_oam_ch.owner_id = owner_id; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_oam_epon_del_channel tpm_oam_epon_del_channel_bounce |
| #else |
| #define _tpm_oam_epon_del_channel tpm_oam_epon_del_channel |
| #endif |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_oam_channel |
| * |
| * DESCRIPTION: |
| * This function deletes OAM channel HW rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_oam_channel (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| nooam_owner=0, nooam_max |
| } oam_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| |
| if (numparms == 1 && buf[0] == '?') |
| { |
| #ifdef CONFIG_MV_TPM_SYSFS_HELP |
| char helpbuf[1000]; |
| int helpbuf_len; |
| |
| helpbuf_len = sfs_help_no_oam_omci_channel(helpbuf); |
| print_help_buffer(helpbuf, helpbuf_len); |
| #else |
| printk(KERN_INFO "Parse problem: parameters expected/found %d/%d\n", nooam_max, numparms); |
| #endif |
| } |
| else if (numparms != 1) |
| { |
| printk(KERN_INFO "Parse problem: parameters expected/found %d/%d\n", nooam_max, numparms); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d", &ownerid); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d]\n", len, parsedargs, ownerid); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if ((rc = _tpm_oam_epon_del_channel (ownerid)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_oam_epon_del_channel failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| /*Evan*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_omci_del_channel_bounce(uint32_t owner_id) |
| { |
| tpm_ioctl_mng_ch_t *tpm_omci_gpon_chan = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mng_channel; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MNG_SECTION; |
| tpm_omci_gpon_chan->mng_cmd = MV_TPM_IOCTL_DEL_OMCI_CHNL; |
| tpm_omci_gpon_chan->tpm_ioctl_omci_ch.owner_id = owner_id; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_omci_del_channel tpm_omci_del_channel_bounce |
| #else |
| #define _tpm_omci_del_channel tpm_omci_del_channel |
| #endif |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_omci_channel |
| * |
| * DESCRIPTION: |
| * This function creates creates an OMCI channel HW rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_omci_channel (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| noomci_owner=0, noomci_max |
| } noomci__parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| |
| if (numparms == 1 && buf[0] == '?') |
| { |
| #ifdef CONFIG_MV_TPM_SYSFS_HELP |
| char helpbuf[1000]; |
| int helpbuf_len; |
| |
| helpbuf_len = sfs_help_no_oam_omci_channel(helpbuf); |
| print_help_buffer(helpbuf, helpbuf_len); |
| #else |
| printk(KERN_INFO "Parse problem: parameters expected/found %d/%d\n", noomci_max, numparms); |
| #endif |
| } |
| else if (numparms != 1) |
| { |
| printk(KERN_INFO "Parse problem: parameters expected/found %d/%d\n", noomci_max, numparms); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d ", &ownerid); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d]\n", len, parsedargs, ownerid); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if ((rc = _tpm_omci_del_channel (ownerid)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_omci_del_channel failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_setup |
| * |
| * DESCRIPTION: |
| * This function initializes tpm module |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_setup (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| /*setup_ponype=0, */setup_filename=0, setup_max |
| } setup_parm_indx_t; |
| // shell line parsing |
| /*uint32_t pon_type;*/ |
| char filename[XML_FILE_PATH_LENGTH]; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| tpm_setup_t setup; |
| |
| memset(&setup, 0, sizeof(tpm_setup_t)); |
| |
| numparms = count_parameters(buf); |
| if (numparms != setup_max) |
| { |
| parm_error_completion(numparms, setup_max, buf, sfs_help_setup); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%s", filename); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], level[%d]\n", len, parsedargs, ownerid, level); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| /*else if (pon_type >= TPM_NONE) |
| { |
| printk(KERN_INFO "Invalid pon_type[%d]\n", pon_type); |
| }*/ |
| else |
| { |
| /*setup.pon_type = pon_type;*/ |
| if (strcmp(filename, "default")) |
| { |
| strcpy(setup.xml_file_path, filename); |
| } |
| if ((rc = module_tpmSetup(&setup)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: module_tpmSetup failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_mib_reset_bounce(uint32_t owner_id, |
| uint32_t level) |
| { |
| tpm_ioctl_mib_reset_t *tpm_mib_reset_param = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mib_reset_param; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_RESET_SECTION; |
| tpm_mib_reset_param->owner_id = owner_id; |
| tpm_mib_reset_param->reset_level = level; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_mib_reset tpm_mib_reset_bounce |
| #else |
| #define _tpm_mib_reset tpm_mib_reset |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_mib_reset |
| * |
| * DESCRIPTION: |
| * This function creates does a MIB reset |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_mib_reset (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| mibreset_owner=0, mibreset_gemport, mibreset_max |
| } mibreset_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t level; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != mibreset_max) |
| { |
| parm_error_completion(numparms, mibreset_max, buf, sfs_help_mib_reset); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &level); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], level[%d]\n", len, parsedargs, ownerid, level); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (level > TPM_ENUM_MAX_RESET_LEVEL) |
| { |
| printk(KERN_INFO "Invalid level[%d]\n", level); |
| } |
| else |
| { |
| if ((rc = _tpm_mib_reset(ownerid, |
| level)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_mib_reset failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_set_active_wan_bounce(uint32_t owner_id, |
| tpm_gmacs_enum_t active_wan) |
| { |
| tpm_ioctl_set_active_wan_t *tpm_set_active_wan_param = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_set_active_wan_param; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_SET_ACTIVE_WAN_SECTION; |
| tpm_set_active_wan_param->owner_id = owner_id; |
| tpm_set_active_wan_param->active_wan = active_wan; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_set_active_wan tpm_set_active_wan_bounce |
| #else |
| #define _tpm_set_active_wan tpm_set_active_wan |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_set_active_wan |
| * |
| * DESCRIPTION: |
| * This function sets active wan port |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_active_wan (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| activewan_owner=0, activewan_active_wan, activewan_max |
| } activewan_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| tpm_gmacs_enum_t active_wan; |
| |
| numparms = count_parameters(buf); |
| if (numparms != activewan_max) |
| { |
| parm_error_completion(numparms, activewan_max, buf, sfs_help_set_active_wan); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &active_wan); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], active_wan_int[%d]\n", |
| // len, parsedargs, ownerid, active_wan); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (active_wan >= TPM_MAX_NUM_GMACS) |
| { |
| printk(KERN_INFO "Invalid active_wan[%d]\n", active_wan); |
| } |
| else |
| { |
| if ((rc = _tpm_set_active_wan(ownerid, |
| active_wan)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_set_active_wan failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_hot_swap_profile_bounce(uint32_t owner_id, |
| tpm_eth_complex_profile_t profile_id) |
| { |
| tpm_ioctl_hot_swap_profile_t *tpm_hot_swap_profile_param = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_hot_swap_profile_param; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_HOT_SWAP_PROFILE_SECTION; |
| tpm_hot_swap_profile_param->owner_id = owner_id; |
| tpm_hot_swap_profile_param->profile_id = profile_id; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_hot_swap_profile tpm_hot_swap_profile_bounce |
| #else |
| #define _tpm_hot_swap_profile tpm_hot_swap_profile |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_hot_swap_profile |
| * |
| * DESCRIPTION: |
| * This function swap profile in run time |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_hot_swap_profile (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| hotswap_owner=0, hotswap_profile_id, hotswap_max |
| } hotswap_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| uint32_t profile_id; |
| |
| numparms = count_parameters(buf); |
| if (numparms != hotswap_max) |
| { |
| parm_error_completion(numparms, hotswap_max, buf, sfs_help_hot_swap_profile); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &profile_id); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], profile_id_int[%d]\n", |
| // len, parsedargs, ownerid, profile_id); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = _tpm_hot_swap_profile(ownerid, |
| profile_id)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_hot_swap_profile failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_set_port_hwf_admin_bounce(uint32_t owner_id, |
| tpm_gmacs_enum_t port, |
| uint8_t txp, |
| uint8_t enable) |
| { |
| tpm_ioctl_set_port_hwf_admin_t *tpm_set_port_hwf_admin_param = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_set_port_hwf_admin_param; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_SET_PORT_HWF_ADMIN_SECTION; |
| tpm_set_port_hwf_admin_param->owner_id = owner_id; |
| tpm_set_port_hwf_admin_param->port = port; |
| tpm_set_port_hwf_admin_param->txp = txp; |
| tpm_set_port_hwf_admin_param->enable = enable; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_set_port_hwf_admin tpm_set_port_hwf_admin_bounce |
| #else |
| #define _tpm_set_port_hwf_admin tpm_proc_hwf_admin_set |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_set_port_hwf_admin |
| * |
| * DESCRIPTION: |
| * This function set port hwf enable/disable |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_port_hwf_admin (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| setporthwfadmin_owner=0, setporthwfadmin_port, setporthwfadmin_txp, |
| setporthwfadmin_enable, setporthwfadmin_max |
| } setporthwfadmin_parm_indx_t; |
| // shell line parsing |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| uint32_t ownerid; |
| tpm_gmacs_enum_t port; |
| uint32_t txp; |
| uint32_t enable; |
| |
| numparms = count_parameters(buf); |
| if (numparms != setporthwfadmin_max) |
| { |
| parm_error_completion(numparms, setporthwfadmin_max, buf, sfs_help_set_port_hwf_admin); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d %d %d", &ownerid, &port, &txp, &enable); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], port[%d], txp[%d], enable[%d]\n", |
| // len, parsedargs, ownerid, port, txp, enable); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = _tpm_set_port_hwf_admin(port, txp, enable)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_set_port_hwf_admin failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_erase_section |
| * |
| * DESCRIPTION: |
| * This function erases a section per an application group. |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_erase_section(const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| section_owner_id=0, section_api_type, erase_section_max |
| } erase_section_parm_indx_t; |
| /*shell line parsing*/ |
| uint32_t ownerid; |
| uint32_t api_type; |
| int parsedargs; |
| int numparms; |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != erase_section_max) |
| parm_error_completion(numparms, erase_section_max, buf, sfs_help_erase_section); |
| else { |
| /*get parameters*/ |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &api_type); |
| if(parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else if (api_type > TPM_MAX_API_TYPES) |
| printk(KERN_INFO "Invalid api type[%d]\n", api_type); |
| else { |
| if ((rc = tpm_erase_section(ownerid, api_type)) == TPM_RC_OK) |
| printk(KERN_INFO "OK\n"); |
| else |
| printk(KERN_INFO "%s: tpm_erase_section failed, rc[%d] - %s\n", |
| __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_cpu_wan_loopback_bounce(uint32_t owner_id, |
| tpm_pkt_frwd_t *pkt_frwd, |
| uint32_t *mod_idx) |
| { |
| tpm_ioctl_cpu_lpbk_t *tpm_ioctl_cpu_lpbk = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_cpu_lpbk; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_CPU_LPBK_SECTION; |
| tpm_ioctl_cpu_lpbk->cpu_lpbk_cmd = MV_TPM_IOCTL_ADD_CPU_WAN_LPBK; |
| tpm_ioctl_cpu_lpbk->owner_id = owner_id; |
| memcpy(&(tpm_ioctl_cpu_lpbk->pkt_frwd), pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_cpu_wan_loopback tpm_add_cpu_wan_loopback_bounce |
| #else |
| #define _tpm_add_cpu_wan_loopback tpm_add_cpu_wan_loopback |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_add_cpu_lpbk |
| * |
| * DESCRIPTION: |
| * This function adds CPU WAN loopback |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_add_cpu_lpbk (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| lpbk_owner=0, lpbk_port, lpbk_que, lpbk_gem, lpbk_max |
| } lpbk_parm_indx_t; |
| uint32_t ownerid; |
| uint32_t temp_port; |
| uint32_t temp_que; |
| uint32_t temp_gem; |
| int parsedargs; |
| int numparms; |
| tpm_error_code_t rc; |
| tpm_pkt_frwd_t frwd_entry; |
| uint32_t mod_idx; |
| |
| numparms = count_parameters(buf); |
| if (numparms != lpbk_max) |
| { |
| parm_error_completion(numparms, lpbk_max, buf, sfs_help_cfg_cpu_lpbk); |
| } |
| else |
| { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d 0x%x %d %d", &ownerid, &temp_port, &temp_que, &temp_gem); |
| /* |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%s] temp_port[0x%x],temp_que[%d],temp_gem[%d]\n", |
| len, parsedargs, ownerid, temp_port, temp_que, temp_gem); |
| */ |
| if (temp_que > 7) |
| { |
| printk(KERN_INFO "Invalid queue [%d]\n", temp_que); |
| } |
| else if (temp_gem > 4095) |
| { |
| printk(KERN_INFO "Invalid gem port [%d]\n", temp_gem); |
| } |
| else |
| { |
| frwd_entry.trg_port = (tpm_trg_port_type_t)temp_port; |
| frwd_entry.trg_queue = (uint8_t)temp_que; |
| frwd_entry.gem_port = (uint16_t)temp_gem; |
| |
| rc = _tpm_add_cpu_wan_loopback(TPM_MOD_OWNER_TPM, &frwd_entry, &mod_idx); |
| if(TPM_RC_OK != rc) |
| { |
| printk(KERN_ERR "Failed to call tpm_add_cpu_wan_loopback, ret_code[%d]\n", rc); |
| } |
| else |
| { |
| printk(KERN_ERR "Call tpm_add_cpu_wan_loopback successfully, mod_idx[%d]\n", mod_idx); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_cpu_wan_loopback_bounce(uint32_t owner_id, |
| tpm_pkt_frwd_t *pkt_frwd) |
| { |
| tpm_ioctl_cpu_lpbk_t *tpm_ioctl_cpu_lpbk = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_cpu_lpbk; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_CPU_LPBK_SECTION; |
| tpm_ioctl_cpu_lpbk->cpu_lpbk_cmd = MV_TPM_IOCTL_DEL_CPU_WAN_LPBK; |
| tpm_ioctl_cpu_lpbk->owner_id = owner_id; |
| memcpy(&(tpm_ioctl_cpu_lpbk->pkt_frwd), pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_cpu_wan_loopback tpm_del_cpu_wan_loopback_bounce |
| #else |
| #define _tpm_del_cpu_wan_loopback tpm_del_cpu_wan_loopback |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_del_cpu_lpbk |
| * |
| * DESCRIPTION: |
| * This function delete CPU WAN loopback |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_del_cpu_lpbk (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| lpbk_owner=0, lpbk_port, lpbk_que, lpbk_gem, lpbk_max |
| } lpbk_parm_indx_t; |
| uint32_t ownerid; |
| uint32_t temp_port; |
| uint32_t temp_que; |
| uint32_t temp_gem; |
| int parsedargs; |
| int numparms; |
| tpm_error_code_t rc; |
| tpm_pkt_frwd_t frwd_entry; |
| |
| numparms = count_parameters(buf); |
| if (numparms != lpbk_max) |
| { |
| parm_error_completion(numparms, lpbk_max, buf, sfs_help_cfg_cpu_lpbk); |
| } |
| else |
| { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d 0x%x %d %d", &ownerid, &temp_port, &temp_que, &temp_gem); |
| /* |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%s] temp_port[0x%x],temp_que[%d],temp_gem[%d]\n", |
| len, parsedargs, ownerid, temp_port, temp_que, temp_gem); |
| */ |
| if (temp_que > 7) |
| { |
| printk(KERN_INFO "Invalid queue [%d]\n", temp_que); |
| } |
| else if (temp_gem > 4095) |
| { |
| printk(KERN_INFO "Invalid gem port [%d]\n", temp_gem); |
| } |
| else |
| { |
| frwd_entry.trg_port = (tpm_trg_port_type_t)temp_port; |
| frwd_entry.trg_queue = (uint8_t)temp_que; |
| frwd_entry.gem_port = (uint16_t)temp_gem; |
| |
| rc = _tpm_del_cpu_wan_loopback(TPM_MOD_OWNER_TPM, &frwd_entry); |
| if(TPM_RC_OK != rc) |
| { |
| printk(KERN_ERR "Failed to call tpm_del_cpu_wan_loopback, ret_code[%d]\n", rc); |
| } |
| else |
| { |
| printk(KERN_ERR "Call tpm_del_cpu_wan_loopback successfully\n"); |
| } |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_dump_cpu_lpbk |
| * |
| * DESCRIPTION: |
| * This function dumps all valid CPU WAN loopback entries from DB |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_dump_cpu_lpbk (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| lpbk_owner=0, lpbk_max |
| } lpbk_parm_indx_t; |
| uint32_t ownerid; |
| int parsedargs; |
| int numparms; |
| |
| numparms = count_parameters(buf); |
| if (numparms != lpbk_max) |
| { |
| parm_error_completion(numparms, lpbk_max, buf, sfs_help_cfg_cpu_lpbk); |
| } |
| else |
| { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d", &ownerid); |
| /* |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%s]\n", |
| len, parsedargs, ownerid); |
| */ |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| tpm_print_cpu_lpbk_entry(); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_get_lu_entry |
| * |
| * DESCRIPTION: |
| * This function dumps least used PnC entries |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_get_lu_entry (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| age_owner_id=0, age_api_group, age_lu_num, age_lu_reset, age_max |
| } age_parm_indx_t; |
| uint32_t owner_id; |
| uint32_t api_group; |
| uint32_t lu_num; |
| uint32_t lu_reset; |
| int parsed_args_num; |
| int param_num; |
| |
| param_num = count_parameters(buf); |
| if (param_num != age_max) |
| { |
| parm_error_completion(param_num, age_max, buf, sfs_help_cfg_age_count); |
| } |
| else |
| { |
| /* Get parameters */ |
| parsed_args_num = sscanf(buf, "%d %d %d %d", &owner_id, &api_group, &lu_num, &lu_reset); |
| /* |
| printk(KERN_INFO "len=%d, parsed_args_num[%d], ownerid[%d], api_group[%d], lu_num[%d], lu_reset[%d]\n", |
| len, parsed_args_num, owner_id, api_group, lu_num, lu_reset); |
| */ |
| |
| if (parsed_args_num != param_num) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsed_args_num, param_num); |
| } |
| else |
| { |
| if((lu_num <= 0) || ( lu_num > TPM_MAX_LU_ENTRY_NUM)) |
| { |
| printk(KERN_INFO "lu_num[%d] is illegal, allowed lu_num[1~%d]\n", lu_num, TPM_MAX_LU_ENTRY_NUM); |
| return; |
| } |
| |
| tpm_print_tcam_lu_entry(owner_id, api_group, lu_num, lu_reset); |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_get_pnc_all_hit_counters_bounce(uint32_t owner_id, |
| tpm_api_type_t api_type, |
| uint32_t high_thresh_pkts, |
| uint8_t counters_reset, |
| uint16_t *valid_counters, |
| tpm_api_entry_count_t *count_array) |
| { |
| tpm_ioctl_pnc_hit_cnt_t *tpm_ioctl_pnc_hit_cnt = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_pnc_hit_cnt; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_AGE_COUNT_SECTION; |
| tpm_ioctl_pnc_hit_cnt->age_count_cmd = MV_TPM_IOCTL_GET_ALL_HIT_COUNTERS; |
| tpm_ioctl_pnc_hit_cnt->owner_id = owner_id; |
| tpm_ioctl_pnc_hit_cnt->api_type = api_type; |
| tpm_ioctl_pnc_hit_cnt->high_thresh_pkts = high_thresh_pkts; |
| tpm_ioctl_pnc_hit_cnt->counter_reset = counters_reset; |
| tpm_ioctl_pnc_hit_cnt->valid_counters = *valid_counters; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_get_pnc_all_hit_counters tpm_get_pnc_all_hit_counters_bounce |
| #define _tpm_print_pnc_all_hit_counters(a,b,c,d,e,f) |
| #else |
| #define _tpm_get_pnc_all_hit_counters tpm_get_pnc_all_hit_counters |
| #define _tpm_print_pnc_all_hit_counters(a,b,c,d,e,f) tpm_print_pnc_all_hit_counters(a,b,c,d,e,f) |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_get_pnc_all_hit_counters |
| * |
| * DESCRIPTION: |
| * This function prints all pnc hit counters per API type masking out |
| * high counter values according to high_thresh_pkts |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_get_pnc_all_hit_counters (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| age_owner_id=0, age_api_type, age_high_thresh_pkts, age_counters_reset, age_valid_counters, age_max |
| } age_parm_indx_t; |
| uint32_t owner_id; |
| uint32_t api_type; |
| uint32_t high_thresh_pkts; |
| uint32_t counters_reset; |
| uint32_t valid_counters; |
| int parsed_args_num; |
| int param_num; |
| tpm_error_code_t ret_code; |
| tpm_api_entry_count_t count_array[CONFIG_MV_PNC_TCAM_LINES]; |
| |
| param_num = count_parameters(buf); |
| if (param_num != age_max) |
| { |
| parm_error_completion(param_num, age_max, buf, sfs_help_cfg_age_count); |
| } |
| else |
| { |
| /* Get parameters */ |
| parsed_args_num = sscanf(buf, "%d %d %d %d %d", &owner_id, &api_type, &high_thresh_pkts, |
| &counters_reset, &valid_counters); |
| |
| if (parsed_args_num != param_num) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsed_args_num, param_num); |
| } |
| else |
| { |
| ret_code = _tpm_get_pnc_all_hit_counters(owner_id, |
| api_type, |
| high_thresh_pkts, |
| counters_reset, |
| (uint16_t*)&valid_counters, |
| &(count_array[0])); |
| |
| if (TPM_RC_OK == ret_code) |
| { |
| _tpm_print_pnc_all_hit_counters(owner_id, |
| api_type, high_thresh_pkts, |
| (uint8_t)counters_reset, |
| valid_counters, |
| &(count_array[0])); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: _tpm_get_pnc_all_hit_counters failed, rc[%d] - %s\n", |
| __FUNCTION__, ret_code, get_tpm_err_str(ret_code)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_set_pnc_counter_mask_bounce(uint32_t owner_id, |
| tpm_api_type_t api_type, |
| uint32_t rule_idx, |
| uint32_t lu_rule_mask) |
| { |
| tpm_ioctl_age_count_t *tpm_ioctl_age_count = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_age_count; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_AGE_COUNT_SECTION; |
| tpm_ioctl_age_count->age_count_cmd = MV_TPM_IOCTL_SET_LU_COUNT_MASK; |
| tpm_ioctl_age_count->owner_id = owner_id; |
| tpm_ioctl_age_count->api_type = api_type; |
| tpm_ioctl_age_count->rule_idx = rule_idx; |
| tpm_ioctl_age_count->lu_rule_mask = lu_rule_mask; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_set_pnc_counter_mask tpm_set_pnc_counter_mask_bounce |
| #else |
| #define _tpm_set_pnc_counter_mask tpm_set_pnc_counter_mask |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_count_mask |
| * |
| * DESCRIPTION: |
| * This function sets count mask |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_count_mask (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| age_owner_id=0, age_api_group, age_rule_idx, age_lu_rule_mask, age_max |
| } age_parm_indx_t; |
| uint32_t owner_id; |
| uint32_t api_group; |
| uint32_t rule_idx; |
| uint32_t lu_rule_mask; |
| int parsed_args_num; |
| int param_num; |
| tpm_error_code_t ret_code; |
| |
| param_num = count_parameters(buf); |
| if (param_num != age_max) |
| { |
| parm_error_completion(param_num, age_max, buf, sfs_help_cfg_age_count); |
| } |
| else |
| { |
| /* Get parameters */ |
| parsed_args_num = sscanf(buf, "%d %d %d %d", &owner_id, &api_group, &rule_idx, &lu_rule_mask); |
| /* |
| printk(KERN_INFO "len=%d, parsed_args_num[%d], ownerid[%d], api_group[%d], rule_idx[%d], lu_rule_mask[%d]\n", |
| len, parsed_args_num, owner_id, api_group, rule_idx, lu_rule_mask); |
| */ |
| |
| if (parsed_args_num != param_num) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsed_args_num, param_num); |
| } |
| else |
| { |
| if ((ret_code = _tpm_set_pnc_counter_mask(owner_id, |
| api_group, |
| rule_idx, |
| lu_rule_mask)) == TPM_RC_OK) |
| PR_RESULT |
| else |
| printk(KERN_INFO "%s: tpm_set_pnc_counter_mask failed, rc[%d] - %s\n", __FUNCTION__, |
| ret_code, get_tpm_err_str(ret_code)); |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_get_pnc_hit_count_bounce(uint32_t owner_id, |
| tpm_api_type_t api_type, |
| uint32_t rule_idx, |
| uint8_t hit_reset, |
| uint32_t *hit_count) |
| { |
| tpm_ioctl_age_count_t *tpm_ioctl_age_count = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_age_count; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_AGE_COUNT_SECTION; |
| tpm_ioctl_age_count->age_count_cmd = MV_TPM_IOCTL_GET_HIT_COUNT; |
| tpm_ioctl_age_count->owner_id = owner_id; |
| tpm_ioctl_age_count->api_type = api_type; |
| tpm_ioctl_age_count->rule_idx = rule_idx; |
| tpm_ioctl_age_count->hit_reset = hit_reset; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_get_pnc_hit_count tpm_get_pnc_hit_count_bounce |
| #else |
| #define _tpm_get_pnc_hit_count tpm_get_pnc_hit_count |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_get_hit_count |
| * |
| * DESCRIPTION: |
| * This function sets count mask |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_get_hit_count (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| age_owner_id=0, age_api_group, age_rule_idx, age_hit_reset, age_max |
| } age_parm_indx_t; |
| uint32_t owner_id; |
| uint32_t api_group; |
| uint32_t rule_idx; |
| int parsed_args_num; |
| int param_num; |
| uint32_t hit_count = 0; |
| uint32_t hit_reset; |
| tpm_error_code_t ret_code; |
| |
| param_num = count_parameters(buf); |
| if (param_num != age_max) |
| { |
| parm_error_completion(param_num, age_max, buf, sfs_help_cfg_age_count); |
| } |
| else |
| { |
| /* Get parameters */ |
| parsed_args_num = sscanf(buf, "%d %d %d %d", &owner_id, &api_group, &rule_idx, &hit_reset); |
| /* |
| printk(KERN_INFO "len=%d, parsed_args_num[%d], ownerid[%d], range_id[%d], rule_idx[%d]\n", |
| len, parsed_args_num, owner_id, range_id, rule_idx); |
| */ |
| if (parsed_args_num != param_num) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsed_args_num, param_num); |
| } |
| else |
| { |
| if ((ret_code = _tpm_get_pnc_hit_count(owner_id, |
| api_group, |
| rule_idx, |
| (uint8_t)hit_reset, |
| &hit_count)) == TPM_RC_OK) |
| PR_HIT_COUNT(hit_count) |
| else |
| printk(KERN_INFO "%s: tpm_get_pnc_hit_count failed, rc[%d] - %s\n", __FUNCTION__, |
| ret_code, get_tpm_err_str(ret_code)); |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_set_pnc_lu_threshold_bounce(uint32_t owner_id, |
| tpm_api_type_t api_type, |
| uint32_t lu_thresh_pkts) |
| { |
| tpm_ioctl_age_count_t *tpm_ioctl_age_count = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_age_count; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_AGE_COUNT_SECTION; |
| tpm_ioctl_age_count->age_count_cmd = MV_TPM_IOCTL_SET_LU_THESHOLD; |
| tpm_ioctl_age_count->owner_id = owner_id; |
| tpm_ioctl_age_count->api_type = api_type; |
| tpm_ioctl_age_count->lu_thresh_pkts = lu_thresh_pkts; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_set_pnc_lu_threshold tpm_set_pnc_lu_threshold_bounce |
| #else |
| #define _tpm_set_pnc_lu_threshold tpm_set_pnc_lu_threshold |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_lu_thresh |
| * |
| * DESCRIPTION: |
| * This function sets count mask |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_lu_thresh (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| age_owner_id=0, age_api_group, age_lu_thresh_pkts, age_max |
| } age_parm_indx_t; |
| uint32_t owner_id; |
| uint32_t api_group; |
| uint32_t lu_thresh_pkts; |
| int parsed_args_num; |
| int param_num; |
| tpm_error_code_t ret_code; |
| |
| param_num = count_parameters(buf); |
| if (param_num != age_max) |
| { |
| parm_error_completion(param_num, age_max, buf, sfs_help_cfg_age_count); |
| } |
| else |
| { |
| /* Get parameters */ |
| parsed_args_num = sscanf(buf, "%d %d %d", &owner_id, &api_group, &lu_thresh_pkts); |
| /* |
| printk(KERN_INFO "len=%d, parsed_args_num[%d], ownerid[%d], api_group[%d], rule_idx[%d]\n", |
| len, parsed_args_num, owner_id, api_group, rule_idx); |
| */ |
| |
| if (parsed_args_num != param_num) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsed_args_num, param_num); |
| } |
| else |
| { |
| if ((ret_code = _tpm_set_pnc_lu_threshold(owner_id, |
| api_group, |
| lu_thresh_pkts)) == TPM_RC_OK) |
| PR_RESULT |
| else |
| printk(KERN_INFO "%s: tpm_set_pnc_lu_threshold failed, rc[%d] - %s\n", __FUNCTION__, |
| ret_code, get_tpm_err_str(ret_code)); |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_reset_pnc_age_group_bounce(uint32_t owner_id, |
| tpm_api_type_t api_type) |
| { |
| tpm_ioctl_age_count_t *tpm_ioctl_age_count = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_age_count; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_AGE_COUNT_SECTION; |
| tpm_ioctl_age_count->age_count_cmd = MV_TPM_IOCTL_RESET_COUNT_GROUP; |
| tpm_ioctl_age_count->owner_id = owner_id; |
| tpm_ioctl_age_count->api_type = api_type; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_reset_pnc_age_group tpm_reset_pnc_age_group_bounce |
| #else |
| #define _tpm_reset_pnc_age_group tpm_reset_pnc_age_group |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_reset_age_group |
| * |
| * DESCRIPTION: |
| * This function sets count mask |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_reset_age_group (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| age_owner_id=0, age_api_group, age_max |
| } age_parm_indx_t; |
| uint32_t owner_id; |
| uint32_t api_group; |
| int parsed_args_num; |
| int param_num; |
| tpm_error_code_t ret_code; |
| |
| param_num = count_parameters(buf); |
| if (param_num != age_max) |
| { |
| parm_error_completion(param_num, age_max, buf, sfs_help_cfg_age_count); |
| } |
| else |
| { |
| /* Get parameters */ |
| parsed_args_num = sscanf(buf, "%d %d", &owner_id, &api_group); |
| /* |
| printk(KERN_INFO "len=%d, parsed_args_num[%d], ownerid[%d], api_group[%d]\n", |
| len, parsed_args_num, owner_id, api_group); |
| */ |
| |
| if (parsed_args_num != param_num) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsed_args_num, param_num); |
| } |
| else |
| { |
| if ((ret_code = _tpm_reset_pnc_age_group(owner_id, |
| api_group)) == TPM_RC_OK) |
| PR_RESULT |
| else |
| printk(KERN_INFO "%s: tpm_reset_pnc_age_group failed, rc[%d] - %s\n", __FUNCTION__, |
| ret_code, get_tpm_err_str(ret_code)); |
| } |
| } |
| } |
| |
| |
| /*Evan*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_tm_set_wan_q_ingr_rate_lim_bounce(uint32_t owner_id, |
| uint32_t queue_id, |
| uint32_t rate_limit_val, |
| uint32_t bucket_size) |
| { |
| tpm_ioctl_tm_tm_t *tpm_tm_tm_set = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_tm_tm; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_PP_TM_SECTION; |
| tpm_tm_tm_set->pp_tm_cmd = MV_TPM_IOCTL_TM_SET_WAN_QUE_INGR_RATE_LIMIT; |
| tpm_tm_tm_set->owner_id = owner_id; |
| tpm_tm_tm_set->queue_id = queue_id; |
| tpm_tm_tm_set->rate_limit_val = rate_limit_val; |
| tpm_tm_tm_set->bucket_size = bucket_size; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| |
| tpm_error_code_t tpm_tm_set_wan_queue_egr_rate_lim_bounce(uint32_t owner_id, |
| tpm_trg_port_type_t sched_ent, |
| uint32_t queue_id, |
| uint32_t rate_limit_val, |
| uint32_t bucket_size) |
| { |
| tpm_ioctl_tm_tm_t *tpm_tm_tm_set = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_tm_tm; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_PP_TM_SECTION; |
| tpm_tm_tm_set->pp_tm_cmd = MV_TPM_IOCTL_TM_SET_WAN_QUE_EGR_RATE_LIMIT; |
| tpm_tm_tm_set->owner_id = owner_id; |
| tpm_tm_tm_set->sched_ent = sched_ent; |
| tpm_tm_tm_set->queue_id = queue_id; |
| tpm_tm_tm_set->rate_limit_val = rate_limit_val; |
| tpm_tm_tm_set->bucket_size = bucket_size; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| |
| #define _tpm_tm_set_wan_q_ingr_rate_lim tpm_tm_set_wan_q_ingr_rate_lim_bounce |
| #define _tpm_tm_set_wan_queue_egr_rate_lim tpm_tm_set_wan_queue_egr_rate_lim_bounce |
| #else |
| #define _tpm_tm_set_wan_q_ingr_rate_lim tpm_tm_set_wan_q_ingr_rate_lim |
| #define _tpm_tm_set_wan_queue_egr_rate_lim tpm_tm_set_wan_queue_egr_rate_lim |
| #endif |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_rate_limit_queue_set |
| * |
| * DESCRIPTION: |
| * This function sets rate limit on queue |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_rate_limit_queue_set (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| qratelim_owner=0, qratelim_direction, qratelim_if, qratelim_que, qratelim_rate_limit, qratelim_bucket_size, qratelim_max |
| } qratelim_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| char direction_str[20]; |
| uint32_t direction; |
| char entity_str[20]; |
| char uc_entity_str[20]; |
| int indx; |
| uint32_t entity; |
| uint32_t que; |
| uint32_t rate_limit; |
| uint32_t bucket_size; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != qratelim_max) |
| { |
| parm_error_completion(numparms, qratelim_max, buf, sfs_help_rate_limit); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %s %s %d %d %d", &ownerid, direction_str, entity_str, &que, &rate_limit, &bucket_size); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], direction_str[%s], entity_str[%s], que[%d], rate_limit[%d], bucket_size[%d]\n", |
| // len, parsedargs, ownerid, direction_str, entity_str, que, rate_limit, bucket_size); |
| |
| // Minimal help for src_port upper/lower case support |
| for (indx = 0; indx < strlen(entity_str); indx++) uc_entity_str[indx] = (char)toupper(entity_str[indx]); |
| uc_entity_str[strlen(entity_str)] = 0; |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_direction_value(direction_str, &direction) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid direction[%s]\n", direction_str); |
| } |
| else if (get_sched_entity_value(uc_entity_str, &entity) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid sched_entity[%s] %s\n", entity_str, uc_entity_str); |
| } |
| else if ((direction == TPM_UPSTREAM && que >= TPM_MAX_NUM_TX_QUEUE) || |
| (direction == TPM_DOWNSTREAM && que >= TPM_MAX_NUM_RX_QUEUE)) |
| { |
| printk(KERN_INFO "Invalid queue[%d]\n", que); |
| } |
| else |
| { |
| if (direction == TPM_DOWNSTREAM) |
| { |
| if ((rc = _tpm_tm_set_wan_q_ingr_rate_lim (ownerid, |
| // entity, |
| que, |
| rate_limit, |
| bucket_size)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_tm_set_wan_q_ingr_rate_lim failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| else |
| { |
| if ((rc = _tpm_tm_set_wan_queue_egr_rate_lim (ownerid, |
| entity, |
| que, |
| rate_limit, |
| bucket_size)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_tm_set_wan_queue_egr_rate_lim failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| } |
| |
| /*Evan*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_tm_set_wan_ingr_queue_sched_bounce(uint32_t owner_id, |
| tpm_pp_sched_type_t sched_mode, |
| uint8_t queue_id, |
| uint16_t wrr_weight) |
| { |
| tpm_ioctl_tm_tm_t *tpm_tm_tm_set = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_tm_tm; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_PP_TM_SECTION; |
| tpm_tm_tm_set->pp_tm_cmd = MV_TPM_IOCTL_TM_SET_WAN_INGR_QUE_SCHED; |
| tpm_tm_tm_set->owner_id = owner_id; |
| tpm_tm_tm_set->pp_sched_mode = sched_mode; |
| tpm_tm_tm_set->queue_id = queue_id; |
| tpm_tm_tm_set->wrr_weight = wrr_weight; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| |
| tpm_error_code_t tpm_tm_set_wan_egr_queue_sched_bounce(uint32_t owner_id, |
| tpm_trg_port_type_t sched_ent, |
| tpm_pp_sched_type_t sched_mode, |
| uint8_t queue_id, |
| uint16_t wrr_weight) |
| { |
| tpm_ioctl_tm_tm_t *tpm_tm_tm_set = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_tm_tm; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_PP_TM_SECTION; |
| tpm_tm_tm_set->pp_tm_cmd = MV_TPM_IOCTL_TM_SET_WAN_EGR_QUE_SCHED; |
| tpm_tm_tm_set->owner_id = owner_id; |
| tpm_tm_tm_set->sched_ent = sched_ent; |
| tpm_tm_tm_set->pp_sched_mode = sched_mode; |
| tpm_tm_tm_set->queue_id = queue_id; |
| tpm_tm_tm_set->wrr_weight = wrr_weight; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| |
| #define _tpm_tm_set_wan_ingr_queue_sched tpm_tm_set_wan_ingr_queue_sched_bounce |
| #define _tpm_tm_set_wan_egr_queue_sched tpm_tm_set_wan_egr_queue_sched_bounce |
| #else |
| #define _tpm_tm_set_wan_ingr_queue_sched tpm_tm_set_wan_ingr_queue_sched |
| #define _tpm_tm_set_wan_egr_queue_sched tpm_tm_set_wan_egr_queue_sched |
| #endif |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_scheduling_mode_queue_set |
| * |
| * DESCRIPTION: |
| * This function configures queue operation mode (per IF, per direction) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_scheduling_mode_queue_set (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| sched_owner=0, sched_direction, sched_if, sched_que, sched_rate_limit, sched_bucket_size, sched_max |
| } sched_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| char direction_str[20]; |
| uint32_t direction; |
| char entity_str[20]; |
| char uc_entity_str[20]; |
| int indx; |
| uint32_t entity; |
| char mode_str[20]; |
| uint32_t mode; |
| uint32_t que; |
| uint32_t wrr_weight; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != sched_max) |
| { |
| parm_error_completion(numparms, sched_max, buf, sfs_help_rate_limit); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %s %s %s %d %d", &ownerid, direction_str, entity_str, mode_str, &que, &wrr_weight); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], direction_str[%s], entity_str[%s], mode[%s], que[%d], wrr_weight[%d]\n", |
| // len, parsedargs, ownerid, direction_str, entity_str, mode_str, que, wrr_weight); |
| |
| // Minimal help for src_port upper/lower case support |
| for (indx = 0; indx < strlen(entity_str); indx++) uc_entity_str[indx] = (char)toupper(entity_str[indx]); |
| uc_entity_str[strlen(entity_str)] = 0; |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_direction_value(direction_str, &direction) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid direction[%s]\n", direction_str); |
| } |
| else if (get_sched_entity_value(uc_entity_str, &entity) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid sched_entity[%s] %s\n", entity_str, uc_entity_str); |
| } |
| else if (get_scheduling_mode_value(mode_str, &mode) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid mode[%s]\n", mode_str); |
| } |
| else if ((direction == TPM_UPSTREAM && que >= TPM_MAX_NUM_TX_QUEUE) || |
| (direction == TPM_DOWNSTREAM && que >= TPM_MAX_NUM_RX_QUEUE)) |
| { |
| printk(KERN_INFO "Invalid queue[%d]\n", que); |
| } |
| else |
| { |
| if (direction == TPM_DOWNSTREAM) |
| { |
| if ((rc = _tpm_tm_set_wan_ingr_queue_sched (ownerid, |
| mode, |
| que, |
| wrr_weight)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_tm_set_wan_ingr_queue_sched failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| else |
| { |
| if ((rc = _tpm_tm_set_wan_egr_queue_sched (ownerid, |
| entity, |
| mode, |
| que, |
| wrr_weight)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_tm_set_wan_egr_queue_sched failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| } |
| |
| /*Evan*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_tm_set_wan_ingr_rate_lim_bounce(uint32_t owner_id, |
| uint32_t rate_limit_val, |
| uint32_t bucket_size) |
| { |
| tpm_ioctl_tm_tm_t *tpm_tm_tm_set = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_tm_tm; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_PP_TM_SECTION; |
| tpm_tm_tm_set->pp_tm_cmd = MV_TPM_IOCTL_TM_SET_WAN_INGR_RATE_LIMIT; |
| tpm_tm_tm_set->owner_id = owner_id; |
| tpm_tm_tm_set->rate_limit_val = rate_limit_val; |
| tpm_tm_tm_set->bucket_size = bucket_size; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| |
| tpm_error_code_t tpm_tm_set_wan_sched_egr_rate_lim_bounce(uint32_t owner_id, |
| tpm_trg_port_type_t sched_ent, |
| uint32_t rate_limit_val, |
| uint32_t bucket_size) |
| { |
| tpm_ioctl_tm_tm_t *tpm_tm_tm_set = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_tm_tm; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_PP_TM_SECTION; |
| tpm_tm_tm_set->pp_tm_cmd = MV_TPM_IOCTL_TM_SET_WAN_SCHED_EGR_RATE_LIMIT; |
| tpm_tm_tm_set->owner_id = owner_id; |
| tpm_tm_tm_set->sched_ent = sched_ent; |
| tpm_tm_tm_set->rate_limit_val = rate_limit_val; |
| tpm_tm_tm_set->bucket_size = bucket_size; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| |
| #define _tpm_tm_set_wan_ingr_rate_lim tpm_tm_set_wan_ingr_rate_lim_bounce |
| #define _tpm_tm_set_wan_sched_egr_rate_lim tpm_tm_set_wan_sched_egr_rate_lim_bounce |
| #else |
| #define _tpm_tm_set_wan_ingr_rate_lim tpm_tm_set_wan_ingr_rate_lim |
| #define _tpm_tm_set_wan_sched_egr_rate_lim tpm_tm_set_wan_sched_egr_rate_lim |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_rate_limit_if_set |
| * |
| * DESCRIPTION: |
| * This function sets rate limit on interface |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_rate_limit_if_set (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| entratelim_owner=0, entratelim_direction, entratelim_if, entratelim_rate_limit, entratelim_bucket_size, entratelim_max |
| } entratelim_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| char direction_str[20]; |
| uint32_t direction; |
| char entity_str[20]; |
| char uc_entity_str[20]; |
| int indx; |
| uint32_t entity; |
| uint32_t rate_limit; |
| uint32_t bucket_size; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != entratelim_max) |
| { |
| parm_error_completion(numparms, entratelim_max, buf, sfs_help_rate_limit); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %s %s %d %d", &ownerid, direction_str, entity_str, &rate_limit, &bucket_size); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], direction_str[%s], entity_str[%s], rate_limit[%d], bucket_size[%d]\n", |
| // len, parsedargs, ownerid, direction_str, entity_str, rate_limit, bucket_size); |
| |
| // Minimal help for src_port upper/lower case support |
| for (indx = 0; indx < strlen(entity_str); indx++) uc_entity_str[indx] = (char)toupper(entity_str[indx]); |
| uc_entity_str[strlen(entity_str)] = 0; |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_direction_value(direction_str, &direction) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid direction[%s]\n", direction_str); |
| } |
| else if (get_sched_entity_value(uc_entity_str, &entity) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid sched_entity[%s]\n", entity_str); |
| } |
| else |
| { |
| if (direction == TPM_DOWNSTREAM) |
| { |
| if ((rc = _tpm_tm_set_wan_ingr_rate_lim (ownerid, |
| rate_limit, |
| bucket_size)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_tm_set_wan_ingr_rate_lim failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| else |
| { |
| if ((rc = _tpm_tm_set_wan_sched_egr_rate_lim (ownerid, |
| entity, |
| rate_limit, |
| bucket_size)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_tm_set_wan_sched_egr_rate_lim failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_tm_set_gmac0_ingr_rate_lim_bounce(uint32_t owner_id, |
| uint32_t rate_limit_val, |
| uint32_t bucket_size) |
| { |
| tpm_ioctl_tm_tm_t *tpm_tm_tm_set = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_tm_tm; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_PP_TM_SECTION; |
| tpm_tm_tm_set->pp_tm_cmd = MV_TPM_IOCTL_TM_SET_GMAC0_INGR_RATE_LIMIT; |
| tpm_tm_tm_set->owner_id = owner_id; |
| tpm_tm_tm_set->rate_limit_val = rate_limit_val; |
| tpm_tm_tm_set->bucket_size = bucket_size; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| |
| #define _tpm_tm_set_gmac0_ingr_rate_lim tpm_tm_set_gmac0_ingr_rate_lim_bounce |
| #else |
| #define _tpm_tm_set_gmac0_ingr_rate_lim tpm_tm_set_gmac0_ingr_rate_lim |
| #endif |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_gmac0_ingr_rate_limit |
| * |
| * DESCRIPTION: |
| * This function sets rate limit on queue |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_gmac0_ingr_rate_limit(const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| qratelim_owner=0, qratelim_rate_limit, qratelim_bucket_size, qratelim_max |
| } qratelim_parm_indx_t; |
| /* shell line parsing */ |
| uint32_t ownerid; |
| uint32_t rate_limit; |
| uint32_t bucket_size; |
| int parsedargs; |
| int numparms; |
| /* Used in API call */ |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != qratelim_max) { |
| parm_error_completion(numparms, qratelim_max, buf, sfs_help_rate_limit); |
| } else { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d %d %d", &ownerid, &rate_limit, &bucket_size); |
| if (parsedargs != numparms) { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } else { |
| if ((rc = _tpm_tm_set_gmac0_ingr_rate_lim(ownerid, |
| rate_limit, |
| bucket_size)) == TPM_RC_OK) |
| printk(KERN_INFO "OK\n"); |
| else |
| printk(KERN_INFO "%s: tpm_tm_set_gmac0_ingr_rate_lim failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv6_dip_rule_bounce(uint32_t owner_id, |
| tpm_src_port_type_t src_port, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_parse_flags_t parse_flags_bm, |
| tpm_ipv6_addr_key_t *ipv6_dip_key, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_pkt_mod_t *pkt_mod, |
| tpm_pkt_mod_bm_t pkt_mod_bm, |
| tpm_rule_action_t *rule_action) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_IPV6_DIP_ACL_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->src_port = src_port; |
| tpm_add_acl_rule->rule_num = rule_num; |
| tpm_add_acl_rule->parse_rule_bm = parse_rule_bm; |
| tpm_add_acl_rule->ipv6_dip_acl_rule.parse_flags_bm = parse_flags_bm; |
| tpm_add_acl_rule->ipv6_dip_acl_rule.pkt_mod_bm = pkt_mod_bm; |
| |
| memcpy(&(tpm_add_acl_rule->ipv6_dip_acl_rule.ipv6_dip_key), ipv6_dip_key, sizeof(tpm_ipv6_addr_key_t)); |
| memcpy(&(tpm_add_acl_rule->ipv6_dip_acl_rule.pkt_frwd), pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&(tpm_add_acl_rule->ipv6_dip_acl_rule.pkt_mod), pkt_mod, sizeof(tpm_pkt_mod_t)); |
| memcpy(&(tpm_add_acl_rule->ipv6_dip_acl_rule.rule_action), rule_action, sizeof(tpm_rule_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv6_dip_rule tpm_add_ipv6_dip_rule_bounce |
| #else |
| #define _tpm_add_ipv6_dip_rule tpm_add_ipv6_dip_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_ipv6_dip_acl_rule_add |
| * |
| * DESCRIPTION: |
| * This function creates a IPV6 DIP rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_ipv6_dip_acl_rule_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| ipv6ruleadd_owner=0, ipv6ruleadd_srcport, ipv6ruleadd_rulenum, ipv6ruleadd_parserulebm, ipv6ruleadd_parseflagsbm, |
| ipv6ruleadd_action, ipv6ruleadd_nextphase, ipv6ruleadd_modbm, ipv6ruleadd_ipv6dipkeyname, ipv6ruleadd_frwdname, |
| ipv6ruleadd_modname, ipv6dipruleadd_max |
| } ipv6dipruleadd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| char srcport_str[20]; |
| char uc_srcport_str[20]; |
| int indx; |
| uint32_t src_port; |
| unsigned int rulenum; |
| unsigned int parserulebm; |
| unsigned int parseflagsbm; |
| unsigned int action; |
| unsigned int nextphase; |
| char nextphase_str[20]; |
| unsigned int modbm; |
| char ipv6keyname[30]; |
| char frwdname[20]; |
| char modname[20]; |
| int parsedargs; |
| int numparms; |
| // DB |
| tpmcfg_ipv6_dip_key_entry_t *pdbipv6keyentry = 0; |
| tpm_ipv6_addr_key_t ipv6AddrKey; |
| tpmcfg_frwd_entry_t *pdbfrwdentry = 0; |
| tpmcfg_mod_entry_t *pdbmodentry = 0; |
| // Used in API call |
| tpm_rule_action_t rule_action; |
| tpm_pkt_frwd_t pkt_frwd; |
| tpm_pkt_mod_t pkt_mod; |
| //tpm_ipv6_acl_key_t ipv6_acl; |
| uint32_t rule_idx; |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != ipv6dipruleadd_max) |
| { |
| parm_error_completion(numparms, ipv6dipruleadd_max, buf, sys_help_ipv6_dip_acl_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %s %d 0x%x 0x%x 0x%x %s 0x%x %s %s %s", |
| &ownerid, srcport_str, &rulenum, &parserulebm, &parseflagsbm, &action, |
| nextphase_str, &modbm, ipv6keyname, frwdname, modname); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rulenum[%d], parserulebm[0x%x], parseflagsbm[0x%x], action[0x%x], nextphase_str[%s], modbm[0x%x], ipv6keyname[%s], frwdname[%s], modname[%s]\n", |
| len, parsedargs, ownerid, srcport_str, rulenum, parserulebm, parseflagsbm, action, nextphase_str, modbm, ipv6keyname, frwdname, modname); |
| |
| // Minimal help for src_port upper/lower case support |
| for (indx = 0; indx < strlen(srcport_str); indx++) uc_srcport_str[indx] = (char)toupper(srcport_str[indx]); |
| uc_srcport_str[strlen(srcport_str)] = 0; |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_srcport_value(uc_srcport_str, &src_port) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid src_port[%s]\n", srcport_str); |
| } |
| else if (get_phase_value(nextphase_str, &nextphase) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid next_phase[%s]\n", nextphase_str); |
| } |
| else if (((pdbipv6keyentry = find_tpm_ipv6_dip_key_entry_by_name(ipv6keyname)) == 0) && strcmp(ipv6keyname, ipv6_dip_key_empty_name) != 0) |
| { |
| printk(KERN_INFO "IPV6 key entry [%s] not found\n", ipv6keyname); |
| } |
| else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && strcmp(frwdname, frwd_empty_name) != 0) |
| { |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| } |
| else if (((pdbmodentry = find_tpm_mod_entry_by_name(modname)) == 0) && strcmp(modname, mod_empty_name) != 0) |
| { |
| printk(KERN_INFO "mod entry [%s] not found\n", modname); |
| } |
| else |
| { |
| rule_action.next_phase = nextphase; |
| rule_action.pkt_act = action; |
| |
| if (pdbipv6keyentry != 0) |
| { |
| memcpy(&(ipv6AddrKey.ipv6_ip_add), &(pdbipv6keyentry->ipv6_addr.ipv6_ip_add), sizeof(pdbipv6keyentry->ipv6_addr.ipv6_ip_add)); |
| memcpy(&(ipv6AddrKey.ipv6_ip_add_mask), &(pdbipv6keyentry->ipv6_addr.ipv6_ip_add_mask), sizeof(pdbipv6keyentry->ipv6_addr.ipv6_ip_add_mask)); |
| } |
| else memset(&ipv6AddrKey, 0, sizeof(ipv6AddrKey)); |
| |
| if (pdbfrwdentry != 0) memcpy(&pkt_frwd, &pdbfrwdentry->frwd, sizeof(tpm_pkt_frwd_t)); |
| else memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if (pdbmodentry != 0) memcpy(&pkt_mod, &pdbmodentry->mod, sizeof(tpm_pkt_mod_t)); |
| else memset(&pkt_mod, 0, sizeof(tpm_pkt_mod_t)); |
| |
| if ((rc = _tpm_add_ipv6_dip_rule(ownerid, |
| src_port, |
| rulenum, |
| &rule_idx, |
| parserulebm, |
| parseflagsbm, |
| &ipv6AddrKey, |
| &pkt_frwd, |
| &pkt_mod, |
| modbm, |
| &rule_action)) == TPM_RC_OK) |
| PR_RULE_IDX(rule_idx) |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_ipv6_dip_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ipv6_dip_rule_bounce(uint32_t owner_id, |
| uint32_t rule_idx) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_IPV6_DIP_ACL_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->rule_idx = rule_idx; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_ipv6_dip_rule tpm_del_ipv6_dip_rule_bounce |
| #else |
| #define _tpm_del_ipv6_dip_rule tpm_del_ipv6_dip_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_ipv6_dip |
| * |
| * DESCRIPTION: |
| * This function deletes a IPV6 HW rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_ipv6_dip (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| noruleaddipv6_owner=0, noruleaddipv6_ruleidx, noruleaddipv6_max |
| } noruleaddipv6_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t rule_idx; |
| // uint32_t parserulebm; |
| // char keyname[20]; |
| int parsedargs; |
| int numparms; |
| // DB |
| // tpmcfg_ipv6_dip_key_entry_t *pdbipv6keyentry = 0; |
| //Used in API call |
| //tpm_ipv6_acl_key_t ipv6_acl; |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noruleaddipv6_max) |
| { |
| parm_error_completion(numparms, noruleaddipv6_max, buf, sfs_help_no_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| // Zeev |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &rule_idx); |
| // parsedargs = sscanf(buf, "%d %s %d 0x%x %s", |
| // &ownerid, srcport_str, &rule_idx, &parserulebm, keyname); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rule_idx[%d], parserulebm[0x%x], keyname[%s]\n", |
| // len, parsedargs, ownerid, srcport_str, rule_idx, parserulebm, keyname); |
| |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| // else if ((pdbipv6keyentry = find_tpm_ipv6_dip_key_entry_by_name(keyname)) == 0) |
| // { |
| // printk(KERN_INFO "key entry [%s] not found\n", keyname); |
| // } |
| else |
| { |
| //memcpy(&ipv6_acl, &pdbipv6keyentry->ipv6_acl, sizeof(tpm_ipv6_acl_key_t)); |
| |
| if ((rc = _tpm_del_ipv6_dip_rule(ownerid, |
| rule_idx)) == TPM_RC_OK) |
| PR_RESULT |
| else |
| { |
| printk(KERN_INFO "%s: tpm_del_ipv6_dip_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv6_l4_ports_rule_bounce(uint32_t owner_id, |
| tpm_src_port_type_t src_port, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_parse_flags_t parse_flags_bm, |
| tpm_l4_ports_key_t *l4_key, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_pkt_mod_t *pkt_mod, |
| tpm_pkt_mod_bm_t pkt_mod_bm, |
| tpm_rule_action_t *rule_action) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_IPV6_L4_PORTS_ACL_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->src_port = src_port; |
| tpm_add_acl_rule->rule_num = rule_num; |
| tpm_add_acl_rule->parse_rule_bm = parse_rule_bm; |
| tpm_add_acl_rule->ipv6_l4_ports_acl_rule.parse_flags_bm = parse_flags_bm; |
| tpm_add_acl_rule->ipv6_l4_ports_acl_rule.pkt_mod_bm = pkt_mod_bm; |
| |
| memcpy(&(tpm_add_acl_rule->ipv6_l4_ports_acl_rule.l4_key), l4_key, sizeof(tpm_l4_ports_key_t)); |
| memcpy(&(tpm_add_acl_rule->ipv6_l4_ports_acl_rule.pkt_frwd), pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&(tpm_add_acl_rule->ipv6_l4_ports_acl_rule.pkt_mod), pkt_mod, sizeof(tpm_pkt_mod_t)); |
| memcpy(&(tpm_add_acl_rule->ipv6_l4_ports_acl_rule.rule_action), rule_action, sizeof(tpm_rule_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv6_l4_ports_rule tpm_add_ipv6_l4_ports_rule_bounce |
| #else |
| #define _tpm_add_ipv6_l4_ports_rule tpm_add_ipv6_l4_ports_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_ipv6_l4_ports_acl_rule_add |
| * |
| * DESCRIPTION: |
| * This function adds a IPV6 HW L4 ports ACL rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_ipv6_l4_ports_acl_rule_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| ipv6l4ports_owner=0, ipv6l4ports_srcport, ipv6l4ports_rulenum, ipv6l4ports_parserulebm, ipv6l4ports_parseflagsbm, |
| ipv6l4ports_action, ipv6l4ports_next_phase, ipv6l4ports_src_port, ipv6l4ports_dst_port, ipv6l4ports_modbm, |
| ipv6l4ports_frwdname, ipv6l4ports_modname, ipv6l4ports_max |
| } ipv6l4ports_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| char srcport_str[20]; |
| char uc_srcport_str[20]; |
| int indx; |
| uint32_t src_port; |
| unsigned int rulenum; |
| unsigned int parserulebm; |
| unsigned int parseflagsbm; |
| |
| uint32_t temp_l4_src_port; |
| uint32_t temp_l4_dst_port; |
| |
| char frwdname[20]; |
| |
| char modname[20]; |
| unsigned int modbm; |
| |
| unsigned int action; |
| unsigned int nextphase; |
| char nextphase_str[20]; |
| |
| int parsedargs; |
| int numparms; |
| // DB |
| tpmcfg_frwd_entry_t *pdbfrwdentry = 0; |
| tpmcfg_mod_entry_t *pdbmodentry = 0; |
| // Used in API call |
| tpm_l4_ports_key_t l4_key; |
| tpm_rule_action_t rule_action; |
| tpm_pkt_frwd_t pkt_frwd; |
| tpm_pkt_mod_t pkt_mod; |
| uint32_t rule_idx; |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != ipv6l4ports_max) |
| { |
| parm_error_completion(numparms, ipv6l4ports_max, buf, sfs_help_ipv6_l4_ports_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %s %d 0x%x 0x%x 0x%x %s %d %d 0x%x %s %s", |
| &ownerid, srcport_str, &rulenum, &parserulebm, &parseflagsbm, &action, nextphase_str, |
| &temp_l4_src_port, &temp_l4_dst_port, &modbm, frwdname, modname); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rulenum[%d], parserulebm[0x%x], parseflagsbm[0x%x], action[0x%x], nextphase_str[%s], l4_src_port[%d], l4_dst_port[%d], modbm[0x%x], frwdname[%s], modname[%s]\n", |
| len, parsedargs, ownerid, srcport_str, rulenum, parserulebm, parseflagsbm, action, nextphase_str, temp_l4_src_port, temp_l4_dst_port, modbm, frwdname, modname); |
| |
| // Minimal help for src_port upper/lower case support |
| for (indx = 0; indx < strlen(srcport_str); indx++) uc_srcport_str[indx] = (char)toupper(srcport_str[indx]); |
| uc_srcport_str[strlen(srcport_str)] = 0; |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_srcport_value(uc_srcport_str, &src_port) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid src_port[%s]\n", srcport_str); |
| } |
| else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && strcmp(frwdname, frwd_empty_name) != 0) |
| { |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| } |
| else if (((pdbmodentry = find_tpm_mod_entry_by_name(modname)) == 0) && strcmp(modname, mod_empty_name) != 0) |
| { |
| printk(KERN_INFO "mod entry [%s] not found\n", modname); |
| } |
| else if (get_phase_value(nextphase_str, &nextphase) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid next_phase[%s]\n", nextphase_str); |
| } |
| else |
| { |
| rule_action.next_phase = nextphase; |
| rule_action.pkt_act = action; |
| |
| l4_key.l4_dst_port = (uint16_t)temp_l4_dst_port; |
| l4_key.l4_src_port = (uint16_t)temp_l4_src_port; |
| |
| if (pdbfrwdentry != 0) memcpy(&pkt_frwd, &pdbfrwdentry->frwd, sizeof(tpm_pkt_frwd_t)); |
| else memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if (pdbmodentry != 0) memcpy(&pkt_mod, &pdbmodentry->mod, sizeof(tpm_pkt_mod_t)); |
| else memset(&pkt_mod, 0, sizeof(tpm_pkt_mod_t)); |
| |
| if ((rc = _tpm_add_ipv6_l4_ports_rule(ownerid, |
| src_port, |
| rulenum, |
| &rule_idx, |
| parserulebm, |
| parseflagsbm, |
| &l4_key, |
| &pkt_frwd, |
| &pkt_mod, |
| modbm, |
| &rule_action)) == TPM_RC_OK) |
| PR_RULE_IDX(rule_idx) |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_ipv6_l4_ports_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ipv6_l4_ports_rule_bounce(uint32_t owner_id, |
| uint32_t rule_idx) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_IPV6_L4_PORTS_ACL_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->rule_idx = rule_idx; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_ipv6_l4_ports_rule tpm_del_ipv6_l4_ports_rule_bounce |
| #else |
| #define _tpm_del_ipv6_l4_ports_rule tpm_del_ipv6_l4_ports_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_ipv6_l4_ports_acl |
| * |
| * DESCRIPTION: |
| * This function deletes a IPV6 HW L4 ports ACL rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_ipv6_l4_ports_acl (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| noipv6l4ports_owner=0, noipv6l4ports_ruleidx, noipv6l4ports_max |
| } noipv6l4portsruleadd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t rule_idx; |
| int parsedargs; |
| int numparms; |
| // DB |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noipv6l4ports_max) |
| { |
| parm_error_completion(numparms, noipv6l4ports_max, buf, sfs_help_no_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &rule_idx); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], rule_idx[%d]\n", |
| len, parsedargs, ownerid, rule_idx); |
| |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = _tpm_del_ipv6_l4_ports_rule(ownerid, |
| rule_idx)) == TPM_RC_OK) |
| PR_RESULT |
| else |
| { |
| printk(KERN_INFO "%s: tpm_del_ipv6_l4_ports_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv6_nh_rule_bounce(uint32_t owner_id, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| tpm_parse_flags_t parse_flags_bm, |
| tpm_nh_iter_t nh_iter, |
| uint32_t nh, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_rule_action_t *rule_action) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_IPV6_NH_ACL_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->rule_num = rule_num; |
| tpm_add_acl_rule->parse_rule_bm = parse_flags_bm; |
| tpm_add_acl_rule->ipv6_nh_acl_rule.nh_iter = nh_iter; |
| tpm_add_acl_rule->ipv6_nh_acl_rule.nh = nh; |
| memcpy(&(tpm_add_acl_rule->ipv6_nh_acl_rule.pkt_frwd), pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&(tpm_add_acl_rule->ipv6_nh_acl_rule.rule_action), rule_action, sizeof(tpm_rule_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv6_nh_rule tpm_add_ipv6_nh_rule_bounce |
| #else |
| #define _tpm_add_ipv6_nh_rule tpm_add_ipv6_nh_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_ipv6_nh_acl_rule_add |
| * |
| * DESCRIPTION: |
| * This function adds a IPV6 HW NH (Next Header) ACL rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_ipv6_nh_acl_rule_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| ipv6nh_owner=0, ipv6nh_rulenum, ipv6nh_parseflagsbm, ipv6nh_action, ipv6nh_nextphase, ipv6nh_nhiter, |
| ipv6nh_nh, ipv6nh_frwdname, ipv6nh_max |
| } ipv6nhruleadd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| unsigned int rulenum; |
| unsigned int parseflagsbm; |
| unsigned int nh_iter; |
| unsigned int nh; |
| unsigned int action; |
| unsigned int nextphase; |
| char nextphase_str[20]; |
| int parsedargs; |
| int numparms; |
| // DB |
| char frwdname[20]; |
| tpmcfg_frwd_entry_t *pdbfrwdentry = 0; |
| // Used in API call |
| tpm_rule_action_t rule_action; |
| tpm_pkt_frwd_t pkt_frwd; |
| uint32_t rule_idx; |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != ipv6nh_max) |
| { |
| parm_error_completion(numparms, ipv6nh_max, buf, sfs_help_ipv6_nh_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d 0x%x 0x%x %s %d 0x%x %s", |
| &ownerid, &rulenum, &parseflagsbm, &action, nextphase_str, &nh_iter, &nh, frwdname); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], rulenum[%d], parseflagsbm[0x%x], action[0x%x], nextphase_str[%s], nh_iter[%d], nh[0x%x], frwdname[%s]\n", |
| len, parsedargs, ownerid, rulenum, parseflagsbm, action, nextphase_str, nh_iter, nh, frwdname); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && strcmp(frwdname, frwd_empty_name) != 0) |
| { |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| } |
| else if (get_phase_value(nextphase_str, &nextphase) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid next_phase[%s]\n", nextphase_str); |
| } |
| else |
| { |
| rule_action.next_phase = nextphase; |
| rule_action.pkt_act = action; |
| |
| if (pdbfrwdentry != 0) memcpy(&pkt_frwd, &pdbfrwdentry->frwd, sizeof(tpm_pkt_frwd_t)); |
| else memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if ((rc = _tpm_add_ipv6_nh_rule(ownerid, |
| rulenum, |
| &rule_idx, |
| parseflagsbm, |
| nh_iter, |
| nh, |
| &pkt_frwd, |
| &rule_action)) == TPM_RC_OK) |
| PR_RULE_IDX(rule_idx) |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_ipv6_nh_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ipv6_nh_rule_bounce(uint32_t owner_id, |
| uint32_t rule_idx) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_IPV6_NH_ACL_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->rule_idx = rule_idx; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_ipv6_nh_rule tpm_del_ipv6_nh_rule_bounce |
| #else |
| #define _tpm_del_ipv6_nh_rule tpm_del_ipv6_nh_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_ipv6_nh_acl |
| * |
| * DESCRIPTION: |
| * This function deletes a IPV6 HW nh_acl rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_ipv6_nh_acl (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| noipv6nh_owner=0, noipv6nh_ruleidx, noipv6nh_max |
| } noipv6nhruleadd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t rule_idx; |
| int parsedargs; |
| int numparms; |
| // DB |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noipv6nh_max) |
| { |
| parm_error_completion(numparms, noipv6nh_max, buf, sfs_help_no_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &rule_idx); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], rule_idx[%d]\n",len, parsedargs, ownerid, rule_idx); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = _tpm_del_ipv6_nh_rule(ownerid, |
| rule_idx)) == TPM_RC_OK) |
| PR_RESULT |
| else |
| { |
| printk(KERN_INFO "%s: tpm_del_ipv6_nh_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ctc_cm_acl_rule_bounce(uint32_t owner_id, |
| tpm_src_port_type_t src_port, |
| uint32_t precedence, |
| tpm_parse_fields_t l2_parse_rule_bm, |
| tpm_parse_fields_t ipv4_parse_rule_bm, |
| tpm_l2_acl_key_t *l2_key, |
| tpm_ipv4_acl_key_t *ipv4_key, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_pkt_action_t *pkt_act, |
| uint32_t pbits) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_CTC_CM_ACL_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->src_port = src_port; |
| tpm_add_acl_rule->ctc_cm_acl_rule.precedence = precedence; |
| tpm_add_acl_rule->ctc_cm_acl_rule.l2_parse_rule_bm = l2_parse_rule_bm; |
| tpm_add_acl_rule->ctc_cm_acl_rule.ipv4_parse_rule_bm = ipv4_parse_rule_bm; |
| tpm_add_acl_rule->ctc_cm_acl_rule.p_bits = pbits; |
| |
| memcpy(&(tpm_add_acl_rule->ctc_cm_acl_rule.l2_key), l2_key, sizeof(tpm_l2_acl_key_t)); |
| memcpy(&(tpm_add_acl_rule->ctc_cm_acl_rule.ipv4_key), ipv4_key, sizeof(tpm_ipv4_acl_key_t)); |
| memcpy(&(tpm_add_acl_rule->ctc_cm_acl_rule.pkt_frwd), pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&(tpm_add_acl_rule->ctc_cm_acl_rule.pkt_act), pkt_act, sizeof(tpm_pkt_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ctc_cm_acl_rule tpm_add_ctc_cm_acl_rule_bounce |
| #else |
| #define _tpm_add_ctc_cm_acl_rule tpm_add_ctc_cm_acl_rule |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_ctc_cm_rule_add |
| * |
| * DESCRIPTION: |
| * This function adds a CnM ACL rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_ctc_cm_rule_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| cnmruleadd_owner=0, cnmruleadd_srcport, cnmruleadd_precedence, cnmruleadd_l2parserulebm, |
| cnmruleadd_ipv4parserulebm, cnmruleadd_action, cnmruleadd_l2keyname, cnmruleadd_ipv4keyname, |
| cnmruleadd_frwdname, cnmruleadd_pbits, cnmruleadd_max |
| } cnmruleadd_parm_indx_t; |
| /*shell line parsing*/ |
| uint32_t owner_id; |
| char srcport_str[20]; |
| char uc_srcport_str[20]; |
| int indx; |
| tpm_src_port_type_t src_port; |
| uint32_t precedence; |
| tpm_parse_fields_t l2_parse_rule_bm; |
| tpm_parse_fields_t ipv4_parse_rule_bm; |
| char l2keyname[20]; |
| tpm_l2_acl_key_t l2_key; |
| char ipv4keyname[20]; |
| tpm_ipv4_acl_key_t ipv4_key; |
| char frwdname[20]; |
| tpm_pkt_frwd_t pkt_frwd; |
| tpm_pkt_action_t action; |
| uint32_t pbits; |
| int parsedargs; |
| int numparms; |
| /*DB*/ |
| tpmcfg_l2_key_entry_t *pdbl2keyentry = NULL; |
| tpmcfg_ipv4_key_entry_t *pdbipv4keyentry = NULL; |
| tpmcfg_frwd_entry_t *pdbfrwdentry = NULL; |
| |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != cnmruleadd_max) { |
| parm_error_completion(numparms, cnmruleadd_max, buf, sfs_help_ctc_cm_rule_add); |
| } else { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d %s %d 0x%x 0x%x 0x%x %s %s %s %d", &owner_id, srcport_str, &precedence, |
| &l2_parse_rule_bm, &ipv4_parse_rule_bm, &action, l2keyname, ipv4keyname, frwdname, &pbits); |
| |
| for (indx = 0; indx < strlen(srcport_str); indx++) uc_srcport_str[indx] = (char)toupper(srcport_str[indx]); |
| uc_srcport_str[strlen(srcport_str)] = 0; |
| |
| if (parsedargs != numparms) { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } else if (get_srcport_value(uc_srcport_str, &src_port) == GT_FALSE) { |
| printk(KERN_INFO "Invalid src_port[%s]\n", srcport_str); |
| } else if (((pdbl2keyentry = find_tpm_l2_key_entry_by_name(l2keyname)) == 0) && strcmp(l2keyname, l2_key_empty_name) != 0) { |
| printk(KERN_INFO "L2 key entry [%s] not found\n", l2keyname); |
| } else if (((pdbipv4keyentry = find_tpm_ipv4_key_entry_by_name(ipv4keyname)) == 0) && strcmp(ipv4keyname, ipv4_key_empty_name) != 0) { |
| printk(KERN_INFO "IPV4 key entry [%s] not found\n", ipv4keyname); |
| } else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && strcmp(frwdname, frwd_empty_name)!= 0) { |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| } else { |
| if (pdbl2keyentry != NULL) |
| memcpy(&l2_key, &(pdbl2keyentry->l2_acl), sizeof(tpm_l2_acl_key_t)); |
| else |
| memset(&l2_key, 0, sizeof(tpm_l2_acl_key_t)); |
| |
| if (pdbipv4keyentry != NULL) |
| memcpy(&ipv4_key, &(pdbipv4keyentry->ipv4_acl), sizeof(tpm_ipv4_acl_key_t)); |
| else |
| memset(&ipv4_key, 0, sizeof(tpm_ipv4_acl_key_t)); |
| |
| if (pdbfrwdentry != NULL) |
| memcpy(&pkt_frwd, &(pdbfrwdentry->frwd), sizeof(tpm_pkt_frwd_t)); |
| else |
| memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if ((rc = _tpm_add_ctc_cm_acl_rule(owner_id, |
| src_port, |
| precedence, |
| l2_parse_rule_bm, |
| ipv4_parse_rule_bm, |
| &l2_key, |
| &ipv4_key, |
| &pkt_frwd, |
| action, |
| pbits)) == TPM_RC_OK) |
| printk(KERN_INFO "OK. precedence = %d\n", precedence); |
| else |
| printk(KERN_INFO "%s: tpm_add_ctc_cm_acl_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| |
| } |
| } |
| |
| } |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ctc_cm_ipv6_acl_rule_bounce(uint32_t owner_id, |
| tpm_src_port_type_t src_port, |
| uint32_t precedence, |
| tpm_parse_fields_t ipv6_parse_rule_bm, |
| tpm_ipv4_acl_key_t *ipv6_key, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_pkt_action_t *pkt_act, |
| uint32_t pbits) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_CTC_CM_ACL_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->src_port = src_port; |
| tpm_add_acl_rule->ctc_cm_acl_rule.precedence = precedence; |
| tpm_add_acl_rule->ctc_cm_acl_rule.ipv6_parse_rule_bm = ipv6_parse_rule_bm; |
| tpm_add_acl_rule->ctc_cm_acl_rule.p_bits = pbits; |
| |
| memcpy(&(tpm_add_acl_rule->ctc_cm_acl_rule.ipv6_key), ipv6_key, sizeof(tpm_ipv6_acl_key_t)); |
| memcpy(&(tpm_add_acl_rule->ctc_cm_acl_rule.pkt_frwd), pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&(tpm_add_acl_rule->ctc_cm_acl_rule.pkt_act), pkt_act, sizeof(tpm_pkt_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ctc_cm_ipv6_acl_rule tpm_add_ctc_cm_ipv6_acl_rule_bounce |
| #else |
| #define _tpm_add_ctc_cm_ipv6_acl_rule tpm_add_ctc_cm_ipv6_acl_rule |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_ctc_cm_ipv6_rule_add |
| * |
| * DESCRIPTION: |
| * This function adds a CnM IPv6 ACL rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_ctc_cm_ipv6_rule_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| cnmruleadd_owner=0, cnmruleadd_srcport, cnmruleadd_precedence, |
| cnmruleadd_ipv6parserulebm, cnmruleadd_action, cnmruleadd_ipv6keyname, |
| cnmruleadd_frwdname, cnmruleadd_pbits, cnmruleipv6add_max |
| } cnmruleadd_parm_indx_t; |
| /*shell line parsing*/ |
| uint32_t owner_id; |
| char srcport_str[20]; |
| char uc_srcport_str[20]; |
| int indx; |
| tpm_src_port_type_t src_port; |
| uint32_t precedence; |
| tpm_parse_fields_t ipv6_parse_rule_bm; |
| char ipv6keyname[20]; |
| tpm_ipv6_acl_key_t ipv6_key; |
| char frwdname[20]; |
| tpm_pkt_frwd_t pkt_frwd; |
| tpm_pkt_action_t action; |
| uint32_t pbits; |
| int parsedargs; |
| int numparms; |
| /*DB*/ |
| tpmcfg_ipv6_key_entry_t *pdbipv6keyentry = NULL; |
| tpmcfg_frwd_entry_t *pdbfrwdentry = NULL; |
| |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != cnmruleipv6add_max) { |
| parm_error_completion(numparms, cnmruleipv6add_max, buf, sfs_help_ctc_cm_rule_add); |
| } else { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d %s %d 0x%x 0x%x %s %s %d", &owner_id, srcport_str, &precedence, |
| &ipv6_parse_rule_bm, &action, ipv6keyname, frwdname, &pbits); |
| |
| for (indx = 0; indx < strlen(srcport_str); indx++) uc_srcport_str[indx] = (char)toupper(srcport_str[indx]); |
| uc_srcport_str[strlen(srcport_str)] = 0; |
| |
| if (parsedargs != numparms) { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } else if (get_srcport_value(uc_srcport_str, &src_port) == GT_FALSE) { |
| printk(KERN_INFO "Invalid src_port[%s]\n", srcport_str); |
| } else if (((pdbipv6keyentry = find_tpm_ipv6_key_entry_by_name(ipv6keyname)) == 0) && strcmp(ipv6keyname, ipv6_key_empty_name) != 0) { |
| printk(KERN_INFO "ipv6 key entry [%s] not found\n", ipv6keyname); |
| } else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && strcmp(frwdname, frwd_empty_name)!= 0) { |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| } else { |
| if (pdbipv6keyentry != NULL) |
| memcpy(&ipv6_key, &(pdbipv6keyentry->ipv6_acl), sizeof(tpm_ipv6_acl_key_t)); |
| else |
| memset(&ipv6_key, 0, sizeof(tpm_ipv6_acl_key_t)); |
| |
| if (pdbfrwdentry != NULL) |
| memcpy(&pkt_frwd, &(pdbfrwdentry->frwd), sizeof(tpm_pkt_frwd_t)); |
| else |
| memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if ((rc = _tpm_add_ctc_cm_ipv6_acl_rule(owner_id, |
| src_port, |
| precedence, |
| ipv6_parse_rule_bm, |
| &ipv6_key, |
| &pkt_frwd, |
| action, |
| pbits)) == TPM_RC_OK) |
| printk(KERN_INFO "OK. precedence = %d\n", precedence); |
| else |
| printk(KERN_INFO "%s: tpm_add_ctc_cm_acl_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| |
| } |
| } |
| |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ctc_cm_acl_rule_bounce(uint32_t owner_id, |
| tpm_src_port_type_t src_port, |
| uint32_t precedence) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_CTC_CM_ACL_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->src_port = src_port; |
| tpm_del_acl_rule->precedence = precedence; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| |
| } |
| #define _tpm_del_ctc_cm_acl_rule tpm_del_ctc_cm_acl_rule_bounce |
| #else |
| #define _tpm_del_ctc_cm_acl_rule tpm_del_ctc_cm_acl_rule |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_ctc_cm_acl |
| * |
| * DESCRIPTION: |
| * This function deletes a ctc CnM HW acl rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_ctc_cm_acl(const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| noctccm_owner=0, noctccm_srcport, noctccm_precedence, noctccm_max |
| } noctccmruleadd_parm_indx_t; |
| /*shell line parsing*/ |
| uint32_t owner_id; |
| char srcport_str[20]; |
| char uc_srcport_str[20]; |
| tpm_src_port_type_t src_port; |
| uint32_t precedence; |
| int parsedargs; |
| int numparms; |
| int indx; |
| |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noctccm_max) { |
| parm_error_completion(numparms, noctccm_max, buf, sfs_help_no_rule_add); |
| } else { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d %s %d", &owner_id, srcport_str, &precedence); |
| |
| for (indx = 0; indx < strlen(srcport_str); indx++) uc_srcport_str[indx] = (char)toupper(srcport_str[indx]); |
| uc_srcport_str[strlen(srcport_str)] = 0; |
| |
| if (parsedargs != numparms) { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } else if (get_srcport_value(uc_srcport_str, &src_port) == GT_FALSE) { |
| printk(KERN_INFO "Invalid src_port[%s]\n", srcport_str); |
| } else { |
| if ((rc = _tpm_del_ctc_cm_acl_rule(owner_id, |
| src_port, |
| precedence)) == TPM_RC_OK) |
| PR_RESULT |
| else |
| printk(KERN_INFO "%s: tpm_del_ctc_cm_acl_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_updt_ipv4_mc_stream_bounce(uint32_t owner_id, |
| uint32_t stream_num, |
| tpm_trg_port_type_t dest_port_bm) |
| { |
| tpm_ioctl_mc_rule_t *tpm_mc_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mc_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MC_STREAM_SECTION; |
| tpm_mc_rule->mc_cmd = MV_TPM_IOCTL_MOD_IPv4_MC_STREAM; |
| tpm_mc_rule->stream_num = stream_num; |
| tpm_mc_rule->dest_port_bm = dest_port_bm; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_updt_ipv4_mc_stream tpm_updt_ipv4_mc_stream_bounce |
| #else |
| #define _tpm_updt_ipv4_mc_stream tpm_updt_ipv4_mc_stream |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_mc_ipv4_stream_update |
| * |
| * DESCRIPTION: |
| * This function updates a IPv4 multicast stream |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_mc_ipv4_stream_update (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| ipv4strupdt_owner=0, ipv4strupdt_stream_num, ipv4strupdt_dest_port_bm, ipv4strupdt_max |
| } noipv6nhruleadd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t stream_num; |
| uint32_t dest_port_bm; |
| int parsedargs; |
| int numparms; |
| // DB |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != ipv4strupdt_max) |
| { |
| parm_error_completion(numparms, ipv4strupdt_max, buf, sfs_help_mc_ipvx_stream_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d 0x%x", &ownerid, &stream_num, &dest_port_bm); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], stream_num[%d], dest_port_bm[0x%x]\n", |
| len, parsedargs, ownerid, stream_num, dest_port_bm); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = _tpm_updt_ipv4_mc_stream(ownerid, |
| stream_num, |
| dest_port_bm)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK.\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_updt_ipv4_mc_stream failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_updt_ipv6_mc_stream_bounce(uint32_t owner_id, |
| uint32_t stream_num, |
| tpm_trg_port_type_t dest_port_bm) |
| { |
| tpm_ioctl_mc_rule_t *tpm_mc_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_mc_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_MC_STREAM_SECTION; |
| tpm_mc_rule->mc_cmd = MV_TPM_IOCTL_MOD_IPv6_MC_STREAM; |
| tpm_mc_rule->stream_num = stream_num; |
| tpm_mc_rule->dest_port_bm = dest_port_bm; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_updt_ipv6_mc_stream tpm_updt_ipv6_mc_stream_bounce |
| #else |
| #define _tpm_updt_ipv6_mc_stream tpm_updt_ipv6_mc_stream |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_mc_ipv6_stream_update |
| * |
| * DESCRIPTION: |
| * This function updates a ipv6 multicast stream |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_mc_ipv6_stream_update (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| ipv6strupdt_owner=0, ipv6strupdt_stream_num, ipv6strupdt_dest_port_bm, ipv6strupdt_max |
| } noipv6nhruleadd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t stream_num; |
| uint32_t dest_port_bm; |
| int parsedargs; |
| int numparms; |
| // DB |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != ipv6strupdt_max) |
| { |
| parm_error_completion(numparms, ipv6strupdt_max, buf, sfs_help_mc_ipvx_stream_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d 0x%x", &ownerid, &stream_num, &dest_port_bm); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], stream_num[%d], dest_port_bm[0x%x]\n", |
| len, parsedargs, ownerid, stream_num, dest_port_bm); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = _tpm_updt_ipv6_mc_stream(ownerid, |
| stream_num, |
| dest_port_bm)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK.\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_updt_ipv6_mc_stream failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| void sfs_tpm_cfg_set_mc_vid_key_reset (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| mcvidkeyreset_owner=0, mcvidkeyreset_max |
| } mcvidkeyreset_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| int parsedargs; |
| int numparms; |
| |
| numparms = count_parameters(buf); |
| if (numparms != mcvidkeyreset_max) |
| { |
| parm_error_completion(numparms, mcvidkeyreset_max, buf, sfs_help_igmp_cfg); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d", &ownerid); |
| printk(KERN_INFO "parsedargs=%d. ownerid[%d]\n", parsedargs, ownerid); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| tpm_reset_mc_vid_key (); |
| printk(KERN_INFO "OK.\n"); |
| } |
| } |
| } |
| |
| void sfs_tpm_cfg_set_mc_vid_key_set (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| mcvidkeyset_src_port=0, mcvidkeyset_mc_uni_xlate_mode, mcvidkeyset_mc_uni_xlate_vid, mcvidkeyset_max |
| } mcvidkeyset_parm_indx_t; |
| // shell line parsing |
| char srcport_str[30]; |
| char uc_srcport_str[30]; |
| uint32_t src_port; |
| uint32_t mc_uni_xlate_mode; |
| uint32_t mc_uni_xlate_vid; |
| int parsedargs; |
| int numparms; |
| int indx; |
| |
| numparms = count_parameters(buf); |
| if (numparms != mcvidkeyset_max) |
| { |
| parm_error_completion(numparms, mcvidkeyset_max, buf, sfs_help_igmp_cfg); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%s %d %d", srcport_str, &mc_uni_xlate_mode, &mc_uni_xlate_vid); |
| printk(KERN_INFO "len=%d, parsedargs=%d. src_port[%s], mc_uni_xlate_mode[%d], mc_uni_xlate_vid[%d]\n", |
| len, parsedargs, srcport_str, mc_uni_xlate_mode, mc_uni_xlate_vid); |
| |
| for (indx = 0; indx < strlen(srcport_str); indx++) uc_srcport_str[indx] = (char)toupper(srcport_str[indx]); |
| uc_srcport_str[strlen(srcport_str)] = 0; |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (get_srcport_value(uc_srcport_str, &src_port) == GT_FALSE) |
| { |
| printk(KERN_INFO "Invalid src_port [%s]\n", srcport_str); |
| } |
| else |
| { |
| if ( GT_TRUE == tpm_set_mc_vid_key (src_port, |
| mc_uni_xlate_mode, |
| mc_uni_xlate_vid) ) |
| { |
| printk(KERN_INFO "OK.\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_set_mc_vid_key failed\n", __FUNCTION__); |
| } |
| } |
| } |
| } |
| void sfs_tpm_cfg_set_mc_vid_cfg_set (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| mcvidcfgset_owner=0, mcvidcfgset_mc_vid, mcvidcfgset_max |
| } mcvidcfgset_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t mc_vid; |
| int parsedargs; |
| int numparms; |
| |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != mcvidcfgset_max) |
| { |
| parm_error_completion(numparms, mcvidcfgset_max, buf, sfs_help_igmp_cfg); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &mc_vid); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], mc_vid[%d]\n", |
| len, parsedargs, ownerid, mc_vid); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = tpm_set_mc_vid_cfg (mc_vid)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK.\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_set_mc_vid_cfg failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| void sfs_tpm_cfg_send_genquery_to_uni (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| sendgenquerytouni_target_ports=0, sendgenquerytouni_packet_num, sendgenquerytouni_max |
| } sendgenquerytouni_parm_indx_t; |
| // shell line parsing |
| uint32_t packet_num; |
| uint32_t target_ports; |
| int parsedargs; |
| int numparms; |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != sendgenquerytouni_max) |
| { |
| parm_error_completion(numparms, sendgenquerytouni_max, buf, sfs_help_send_genquery_to_uni); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "0x%x %d ", &target_ports, &packet_num); |
| printk(KERN_INFO "len=%d, parsedargs=%d. target_ports[0x%x]. packet_num[%d]\n", |
| len, parsedargs, target_ports, packet_num); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| rc = tpm_proc_send_genquery_to_uni(target_ports, packet_num); |
| if (TPM_RC_OK == rc) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_send_genquery_to_uni failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv6_gen_5t_rule_bounce(uint32_t owner_id, |
| tpm_dir_t src_dir, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_parse_flags_t parse_flags_bm, |
| tpm_l4_ports_key_t *l4_key, |
| tpm_ipv6_gen_acl_key_t *ipv6_gen_key, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_pkt_mod_t *pkt_mod, |
| tpm_pkt_mod_bm_t pkt_mod_bm, |
| tpm_rule_action_t *rule_action) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_IPV6_GEN_5T_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->src_dir = src_dir; |
| tpm_add_acl_rule->rule_num = rule_num; |
| tpm_add_acl_rule->parse_rule_bm = parse_rule_bm; |
| tpm_add_acl_rule->ipv6_gen_5t_rule.parse_flags_bm = parse_flags_bm; |
| tpm_add_acl_rule->ipv6_gen_5t_rule.pkt_mod_bm = pkt_mod_bm; |
| |
| memcpy(&tpm_add_acl_rule->ipv6_gen_5t_rule.l4_key, l4_key, sizeof(tpm_l4_ports_key_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_gen_5t_rule.ipv6_gen_key, ipv6_gen_key, sizeof(tpm_ipv6_gen_acl_key_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_gen_5t_rule.pkt_frwd, pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_gen_5t_rule.pkt_mod, pkt_mod, sizeof(tpm_pkt_mod_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_gen_5t_rule.rule_action, rule_action, sizeof(tpm_rule_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv6_gen_5t_rule tpm_add_ipv6_gen_5t_rule_bounce |
| #else |
| #define _tpm_add_ipv6_gen_5t_rule tpm_add_ipv6_gen_5t_rule |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_ipv6_gen_rule_add |
| * |
| * DESCRIPTION: |
| * This function create IPv6 general rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_ipv6_gen_5t_rule_add(const char *buf, size_t len) |
| { |
| typedef enum { |
| ipv6ruleadd_owner=0, ipv6ruleadd_srcdir, ipv6ruleadd_rulenum, ipv6ruleadd_parserulebm, ipv6ruleadd_parseflagsbm, |
| ipv6ruleadd_action, ipv6ruleadd_nextphase, ipv6ruleadd_modbm, ipv6ruleadd_ipv6l4keyname, ipv6ruleadd_ipv6genkeyname, |
| ipv6ruleadd_frwdname,ipv6ruleadd_modname, ipv6ruleadd_max |
| } ipv4ruleadd_parm_indx_t; |
| |
| uint32_t owner_id; |
| tpm_dir_t src_dir; |
| uint32_t rule_num; |
| uint32_t rule_idx; |
| tpm_parse_fields_t parse_rule_bm; |
| tpm_parse_flags_t parse_flags_bm; |
| tpm_l4_ports_key_t l4_key; |
| tpm_ipv6_gen_acl_key_t ipv6_gen_key; |
| tpm_pkt_frwd_t pkt_frwd; |
| tpm_pkt_mod_t pkt_mod; |
| tpm_pkt_mod_bm_t pkt_mod_bm; |
| tpm_rule_action_t rule_action; |
| |
| tpmcfg_ipv6_l4_ports_key_entry_t *pdbipv6l4keyentry = 0; |
| tpmcfg_ipv6_gen_key_entry_t *pdbipv6genkeyentry = 0; |
| tpmcfg_frwd_entry_t *pdbfrwdentry = 0; |
| tpmcfg_mod_entry_t *pdbmodentry = 0; |
| |
| tpm_error_code_t rc; |
| int indx; |
| int parsedargs; |
| int numparms; |
| uint32_t action; |
| uint32_t nextphase; |
| char srcdir_str[20]; |
| char uc_srcdir_str[20]; |
| char nextphase_str[20]; |
| char ipv6l4keyname[30]; |
| char ipv6genkeyname[30]; |
| char frwdname[20]; |
| char modname[20]; |
| |
| |
| numparms = count_parameters(buf); |
| if (numparms != ipv6ruleadd_max) |
| parm_error_completion(numparms, ipv6ruleadd_max, buf, sfs_help_ipv6_gen_5t_rule_add); |
| else { |
| parsedargs = sscanf(buf, "%d %s %d 0x%x 0x%x 0x%x %s 0x%x %s %s %s %s", |
| &owner_id, srcdir_str, &rule_num, &parse_rule_bm, &parse_flags_bm, |
| &action, nextphase_str, &pkt_mod_bm, ipv6l4keyname, ipv6genkeyname, frwdname, modname); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rulenum[%d], parserulebm[0x%x], parseflagsbm[0x%x], action[0x%x], nextphase_str[%s], modbm[0x%x], ipv6l4keyname[%s], ipv6genkeyname[%s], frwdname[%s], modname[%s]\n", |
| len, parsedargs, owner_id, srcdir_str, rule_num, parse_rule_bm, parse_flags_bm, action, nextphase_str, pkt_mod_bm, ipv6l4keyname, ipv6genkeyname, frwdname, modname); |
| |
| for (indx = 0; indx < strlen(srcdir_str); indx++) |
| uc_srcdir_str[indx] = (char)toupper(srcdir_str[indx]); |
| |
| uc_srcdir_str[strlen(srcdir_str)] = 0; |
| |
| if (parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else if (get_srcdir_value(uc_srcdir_str, &src_dir) == GT_FALSE) |
| printk(KERN_INFO "Invalid src_port[%s]\n", srcdir_str); |
| else if (get_phase_value(nextphase_str, &nextphase) == GT_FALSE) |
| printk(KERN_INFO "Invalid next_phase[%s]\n", nextphase_str); |
| else if (((pdbipv6l4keyentry = find_tpm_ipv6_l4_ports_key_entry_by_name(ipv6l4keyname)) == 0) && \ |
| strcmp(ipv6l4keyname, ipv6_l4_key_empty_name) != 0) |
| printk(KERN_INFO "L4 ports key entry [%s] not found\n", ipv6genkeyname); |
| else if (((pdbipv6genkeyentry = find_tpm_ipv6_gen_key_entry_by_name(ipv6genkeyname)) == 0) && \ |
| strcmp(ipv6genkeyname, ipv6_gen_key_empty_name) != 0) |
| printk(KERN_INFO "IPV6 gen key entry [%s] not found\n", ipv6genkeyname); |
| else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && \ |
| strcmp(frwdname, frwd_empty_name) != 0) |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| else if (((pdbmodentry = find_tpm_mod_entry_by_name(modname)) == 0) && \ |
| strcmp(modname, mod_empty_name) != 0) |
| printk(KERN_INFO "mod entry [%s] not found\n", modname); |
| else { |
| rule_action.next_phase = nextphase; |
| rule_action.pkt_act = action; |
| |
| if (pdbipv6l4keyentry != 0) |
| memcpy(&l4_key, &pdbipv6l4keyentry->l4_ports, sizeof(tpm_l4_ports_key_t)); |
| else |
| memset(&l4_key, 0, sizeof(tpm_l4_ports_key_t)); |
| |
| if (pdbipv6genkeyentry != 0) |
| memcpy(&ipv6_gen_key, &pdbipv6genkeyentry->ipv6gen_acl, sizeof(tpm_ipv6_gen_acl_key_t)); |
| else |
| memset(&ipv6_gen_key, 0, sizeof(tpm_ipv6_gen_acl_key_t)); |
| |
| if (pdbfrwdentry != 0) |
| memcpy(&pkt_frwd, &pdbfrwdentry->frwd, sizeof(tpm_pkt_frwd_t)); |
| else |
| memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if (pdbmodentry != 0) |
| memcpy(&pkt_mod, &pdbmodentry->mod, sizeof(tpm_pkt_mod_t)); |
| else |
| memset(&pkt_mod, 0, sizeof(tpm_pkt_mod_t)); |
| |
| if (TPM_RC_OK == (rc = _tpm_add_ipv6_gen_5t_rule(owner_id, |
| src_dir, |
| rule_num, |
| &rule_idx, |
| parse_rule_bm, |
| parse_flags_bm, |
| &l4_key, |
| &ipv6_gen_key, |
| &pkt_frwd, |
| &pkt_mod, |
| pkt_mod_bm, |
| &rule_action)) ) |
| PR_RULE_IDX(rule_idx) |
| else |
| printk(KERN_INFO "%s: tpm_add_ipv6_gen_5t_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ipv6_gen_5t_rule_bounce(uint32_t owner_id, |
| uint32_t rule_idx) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_IPV6_GEN_5T_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->rule_idx = rule_idx; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_ipv6_gen_5t_rule tpm_del_ipv6_gen_5t_rule_bounce |
| #else |
| #define _tpm_del_ipv6_gen_5t_rule tpm_del_ipv6_gen_5t_rule |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_ipv6_gen_5t |
| * |
| * DESCRIPTION: |
| * This function deletes a IPV6 HW gen ACL rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_ipv6_gen_5t(const char *buf, size_t len) |
| { |
| typedef enum { |
| noipv6gen_owner=0, noipv6gen_ruleidx, noipv6gen_max |
| } noipv6genruleadd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t rule_idx; |
| int parsedargs; |
| int numparms; |
| // DB |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noipv6gen_max) |
| parm_error_completion(numparms, noipv6gen_max, buf, sfs_help_no_rule_add); |
| else { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &rule_idx); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], rule_idx[%d]\n", |
| len, parsedargs, ownerid, rule_idx); |
| |
| |
| if (parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else { |
| if ((rc = _tpm_del_ipv6_gen_5t_rule(ownerid, rule_idx)) == TPM_RC_OK) |
| PR_RESULT |
| else |
| printk(KERN_INFO "%s: tpm_del_ipv6_gen_5t_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv6_dip_5t_rule_bounce(uint32_t owner_id, |
| tpm_dir_t src_dir, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_parse_flags_t parse_flags_bm, |
| tpm_l4_ports_key_t *l4_key, |
| tpm_ipv6_gen_acl_key_t *ipv6_gen_key, |
| tpm_ipv6_addr_key_t *ipv6_dip_key, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_pkt_mod_t *pkt_mod, |
| tpm_pkt_mod_bm_t pkt_mod_bm, |
| tpm_rule_action_t *rule_action) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_IPV6_DIP_5T_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->src_dir = src_dir; |
| tpm_add_acl_rule->rule_num = rule_num; |
| tpm_add_acl_rule->parse_rule_bm = parse_rule_bm; |
| tpm_add_acl_rule->ipv6_dip_5t_rule.parse_flags_bm = parse_flags_bm; |
| tpm_add_acl_rule->ipv6_dip_5t_rule.pkt_mod_bm = pkt_mod_bm; |
| |
| memcpy(&tpm_add_acl_rule->ipv6_dip_5t_rule.l4_key, l4_key, sizeof(tpm_l4_ports_key_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_dip_5t_rule.ipv6_gen_key, ipv6_gen_key, sizeof(tpm_ipv6_gen_acl_key_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_dip_5t_rule.ipv6_dip_key, ipv6_dip_key, sizeof(tpm_ipv6_addr_key_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_dip_5t_rule.pkt_frwd, pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_dip_5t_rule.pkt_mod, pkt_mod, sizeof(tpm_pkt_mod_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_dip_5t_rule.rule_action, rule_action, sizeof(tpm_rule_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv6_dip_5t_rule tpm_add_ipv6_dip_5t_rule_bounce |
| #else |
| #define _tpm_add_ipv6_dip_5t_rule tpm_add_ipv6_dip_5t_rule |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_ipv6_dip_5t_rule_add |
| * |
| * DESCRIPTION: |
| * This function create IPv6 general rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_ipv6_dip_5t_rule_add(const char *buf, size_t len) |
| { |
| typedef enum { |
| ipv6ruleadd_owner=0, ipv6ruleadd_srcdir, ipv6ruleadd_rulenum, ipv6ruleadd_parserulebm, ipv6ruleadd_parseflagsbm, |
| ipv6ruleadd_action, ipv6ruleadd_nextphase, ipv6ruleadd_modbm, ipv6ruleadd_ipv6l4keyname, ipv6ruleadd_ipv6genkeyname, |
| ipv6ruleadd_ipv6dipkeyname, ipv6ruleadd_frwdname,ipv6ruleadd_modname, ipv6ruleadd_max |
| } ipv4ruleadd_parm_indx_t; |
| |
| uint32_t owner_id; |
| tpm_dir_t src_dir; |
| uint32_t rule_num; |
| uint32_t rule_idx; |
| tpm_parse_fields_t parse_rule_bm; |
| tpm_parse_flags_t parse_flags_bm; |
| tpm_l4_ports_key_t l4_key; |
| tpm_ipv6_gen_acl_key_t ipv6_gen_key; |
| tpm_ipv6_addr_key_t ipv6_dip_key; |
| tpm_pkt_frwd_t pkt_frwd; |
| tpm_pkt_mod_t pkt_mod; |
| tpm_pkt_mod_bm_t pkt_mod_bm; |
| tpm_rule_action_t rule_action; |
| |
| tpmcfg_ipv6_l4_ports_key_entry_t *pdbipv6l4keyentry = 0; |
| tpmcfg_ipv6_gen_key_entry_t *pdbipv6genkeyentry = 0; |
| tpmcfg_ipv6_dip_key_entry_t *pdbipv6dipkeyentry = 0; |
| tpmcfg_frwd_entry_t *pdbfrwdentry = 0; |
| tpmcfg_mod_entry_t *pdbmodentry = 0; |
| |
| tpm_error_code_t rc; |
| int indx; |
| int parsedargs; |
| int numparms; |
| uint32_t action; |
| uint32_t nextphase; |
| char srcdir_str[20]; |
| char uc_srcdir_str[20]; |
| char nextphase_str[20]; |
| char ipv6l4keyname[30]; |
| char ipv6genkeyname[30]; |
| char ipv6dipkeyname[30]; |
| char frwdname[20]; |
| char modname[20]; |
| |
| |
| numparms = count_parameters(buf); |
| if (numparms != ipv6ruleadd_max) |
| parm_error_completion(numparms, ipv6ruleadd_max, buf, sfs_help_ipv6_dip_5t_rule_add); |
| else { |
| parsedargs = sscanf(buf, "%d %s %d 0x%x 0x%x 0x%x %s 0x%x %s %s %s %s %s", |
| &owner_id, srcdir_str, &rule_num, &parse_rule_bm, &parse_flags_bm, |
| &action, nextphase_str, &pkt_mod_bm, ipv6l4keyname, ipv6genkeyname, |
| ipv6dipkeyname, frwdname, modname); |
| printk("len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rulenum[%d], "\ |
| "parserulebm[0x%x], parseflagsbm[0x%x], action[0x%x], nextphase_str[%s], modbm[0x%x], "\ |
| "ipv6l4keyname[%s], ipv6genkeyname[%s], ipv6dipkeyname[%s], frwdname[%s], modname[%s]\n", |
| len, parsedargs, owner_id, srcdir_str, rule_num, |
| parse_rule_bm, parse_flags_bm, action, nextphase_str, pkt_mod_bm, |
| ipv6l4keyname, ipv6genkeyname, ipv6dipkeyname, frwdname, modname); |
| |
| for (indx = 0; indx < strlen(srcdir_str); indx++) |
| uc_srcdir_str[indx] = (char)toupper(srcdir_str[indx]); |
| |
| uc_srcdir_str[strlen(srcdir_str)] = 0; |
| |
| if (parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else if (get_srcdir_value(uc_srcdir_str, &src_dir) == GT_FALSE) |
| printk(KERN_INFO "Invalid src_port[%s]\n", srcdir_str); |
| else if (get_phase_value(nextphase_str, &nextphase) == GT_FALSE) |
| printk(KERN_INFO "Invalid next_phase[%s]\n", nextphase_str); |
| else if (((pdbipv6l4keyentry = find_tpm_ipv6_l4_ports_key_entry_by_name(ipv6l4keyname)) == 0) && \ |
| strcmp(ipv6l4keyname, ipv6_l4_key_empty_name) != 0) |
| printk(KERN_INFO "L4 ports key entry [%s] not found\n", ipv6l4keyname); |
| else if (((pdbipv6genkeyentry = find_tpm_ipv6_gen_key_entry_by_name(ipv6genkeyname)) == 0) && \ |
| strcmp(ipv6genkeyname, ipv6_gen_key_empty_name) != 0) |
| printk(KERN_INFO "IPV6 gen key entry [%s] not found\n", ipv6genkeyname); |
| else if (((pdbipv6dipkeyentry = find_tpm_ipv6_dip_key_entry_by_name(ipv6dipkeyname)) == 0) && \ |
| strcmp(ipv6dipkeyname, ipv6_dip_key_empty_name) != 0) |
| printk(KERN_INFO "IPV6 dip key entry [%s] not found\n", ipv6dipkeyname); |
| else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && \ |
| strcmp(frwdname, frwd_empty_name) != 0) |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| else if (((pdbmodentry = find_tpm_mod_entry_by_name(modname)) == 0) && \ |
| strcmp(modname, mod_empty_name) != 0) |
| printk(KERN_INFO "mod entry [%s] not found\n", modname); |
| else { |
| rule_action.next_phase = nextphase; |
| rule_action.pkt_act = action; |
| |
| if (pdbipv6l4keyentry != 0) |
| memcpy(&l4_key, &pdbipv6l4keyentry->l4_ports, sizeof(tpm_l4_ports_key_t)); |
| else |
| memset(&l4_key, 0, sizeof(tpm_l4_ports_key_t)); |
| |
| if (pdbipv6genkeyentry != 0) |
| memcpy(&ipv6_gen_key, &pdbipv6genkeyentry->ipv6gen_acl, sizeof(tpm_ipv6_gen_acl_key_t)); |
| else |
| memset(&ipv6_gen_key, 0, sizeof(tpm_ipv6_gen_acl_key_t)); |
| |
| if (pdbipv6dipkeyentry != 0) |
| memcpy(&ipv6_dip_key, &pdbipv6dipkeyentry->ipv6_addr, sizeof(tpm_ipv6_addr_key_t)); |
| else |
| memset(&ipv6_dip_key, 0, sizeof(tpm_ipv6_addr_key_t)); |
| |
| if (pdbfrwdentry != 0) |
| memcpy(&pkt_frwd, &pdbfrwdentry->frwd, sizeof(tpm_pkt_frwd_t)); |
| else |
| memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if (pdbmodentry != 0) |
| memcpy(&pkt_mod, &pdbmodentry->mod, sizeof(tpm_pkt_mod_t)); |
| else |
| memset(&pkt_mod, 0, sizeof(tpm_pkt_mod_t)); |
| |
| if (TPM_RC_OK == (rc = _tpm_add_ipv6_dip_5t_rule(owner_id, |
| src_dir, |
| rule_num, |
| &rule_idx, |
| parse_rule_bm, |
| parse_flags_bm, |
| &l4_key, |
| &ipv6_gen_key, |
| &ipv6_dip_key, |
| &pkt_frwd, |
| &pkt_mod, |
| pkt_mod_bm, |
| &rule_action)) ) |
| PR_RULE_IDX(rule_idx) |
| else |
| printk(KERN_INFO "%s: tpm_add_ipv6_dip_5t_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ipv6_dip_5t_rule_bounce(uint32_t owner_id, |
| uint32_t rule_idx) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_IPV6_DIP_5T_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->rule_idx = rule_idx; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_ipv6_dip_5t_rule tpm_del_ipv6_dip_5t_rule_bounce |
| #else |
| #define _tpm_del_ipv6_dip_5t_rule tpm_del_ipv6_dip_5t_rule |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_ipv6_dip_5t |
| * |
| * DESCRIPTION: |
| * This function deletes a IPV6 HW gen ACL rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_ipv6_dip_5t(const char *buf, size_t len) |
| { |
| typedef enum { |
| noipv6dip_owner=0, noipv6dip_ruleidx, noipv6dip_max |
| } noipv6dipruleadd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t rule_idx; |
| int parsedargs; |
| int numparms; |
| // DB |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noipv6dip_max) |
| parm_error_completion(numparms, noipv6dip_max, buf, sfs_help_no_rule_add); |
| else { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &rule_idx); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], rule_idx[%d]\n", |
| len, parsedargs, ownerid, rule_idx); |
| |
| |
| if (parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else { |
| if ((rc = _tpm_del_ipv6_dip_5t_rule(ownerid, rule_idx)) == TPM_RC_OK) |
| PR_RESULT |
| else |
| printk(KERN_INFO "%s: tpm_del_ipv6_dip_5t_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ipv6_l4_ports_5t_rule_bounce(uint32_t owner_id, |
| tpm_dir_t src_dir, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_parse_flags_t parse_flags_bm, |
| tpm_l4_ports_key_t *l4_key, |
| tpm_pkt_frwd_t *pkt_frwd, |
| tpm_pkt_mod_t *pkt_mod, |
| tpm_pkt_mod_bm_t pkt_mod_bm, |
| tpm_rule_action_t *rule_action) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_IPV6_L4_PORTS_5T_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->src_dir = src_dir; |
| tpm_add_acl_rule->rule_num = rule_num; |
| tpm_add_acl_rule->parse_rule_bm = parse_rule_bm; |
| tpm_add_acl_rule->ipv6_l4_ports_5t_rule.parse_flags_bm = parse_flags_bm; |
| tpm_add_acl_rule->ipv6_l4_ports_5t_rule.pkt_mod_bm = pkt_mod_bm; |
| |
| memcpy(&tpm_add_acl_rule->ipv6_l4_ports_5t_rule.l4_key, l4_key, sizeof(tpm_l4_ports_key_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_l4_ports_5t_rule.pkt_frwd, pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_l4_ports_5t_rule.pkt_mod, pkt_mod, sizeof(tpm_pkt_mod_t)); |
| memcpy(&tpm_add_acl_rule->ipv6_l4_ports_5t_rule.rule_action, rule_action, sizeof(tpm_rule_action_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ipv6_l4_ports_5t_rule tpm_add_ipv6_l4_ports_5t_rule_bounce |
| #else |
| #define _tpm_add_ipv6_l4_ports_5t_rule tpm_add_ipv6_l4_ports_5t_rule |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_ipv6_l4_ports_5t_rule_add |
| * |
| * DESCRIPTION: |
| * This function create IPv6 general rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_ipv6_l4_ports_5t_rule_add(const char *buf, size_t len) |
| { |
| typedef enum { |
| ipv6ruleadd_owner=0, ipv6ruleadd_srcdir, ipv6ruleadd_rulenum, ipv6ruleadd_parserulebm, ipv6ruleadd_parseflagsbm, |
| ipv6ruleadd_action, ipv6ruleadd_nextphase, ipv6ruleadd_modbm, ipv6ruleadd_ipv6l4keyname, ipv6ruleadd_frwdname, |
| ipv6ruleadd_modname, ipv6ruleadd_max |
| } ipv4ruleadd_parm_indx_t; |
| |
| uint32_t owner_id; |
| tpm_dir_t src_dir; |
| uint32_t rule_num; |
| uint32_t rule_idx; |
| tpm_parse_fields_t parse_rule_bm; |
| tpm_parse_flags_t parse_flags_bm; |
| tpm_l4_ports_key_t l4_key; |
| tpm_pkt_frwd_t pkt_frwd; |
| tpm_pkt_mod_t pkt_mod; |
| tpm_pkt_mod_bm_t pkt_mod_bm; |
| tpm_rule_action_t rule_action; |
| |
| tpmcfg_ipv6_l4_ports_key_entry_t *pdbipv6l4keyentry = 0; |
| tpmcfg_frwd_entry_t *pdbfrwdentry = 0; |
| tpmcfg_mod_entry_t *pdbmodentry = 0; |
| |
| tpm_error_code_t rc; |
| int indx; |
| int parsedargs; |
| int numparms; |
| uint32_t action; |
| uint32_t nextphase; |
| char srcdir_str[20]; |
| char uc_srcdir_str[20]; |
| char nextphase_str[20]; |
| char ipv6l4keyname[30]; |
| char frwdname[20]; |
| char modname[20]; |
| |
| |
| numparms = count_parameters(buf); |
| if (numparms != ipv6ruleadd_max) |
| parm_error_completion(numparms, ipv6ruleadd_max, buf, sfs_help_ipv6_l4_ports_5t_rule_add); |
| else { |
| parsedargs = sscanf(buf, "%d %s %d 0x%x 0x%x 0x%x %s 0x%x %s %s %s", |
| &owner_id, srcdir_str, &rule_num, &parse_rule_bm, &parse_flags_bm, |
| &action, nextphase_str, &pkt_mod_bm, ipv6l4keyname, frwdname, modname); |
| printk("len=%d, parsedargs=%d. ownerid[%d], srcport_str[%s], rulenum[%d], "\ |
| "parserulebm[0x%x], parseflagsbm[0x%x], action[0x%x], nextphase_str[%s], "\ |
| "modbm[0x%x], ipv6l4keyname[%s], frwdname[%s], modname[%s]\n", |
| len, parsedargs, owner_id, srcdir_str, rule_num, |
| parse_rule_bm, parse_flags_bm, action, nextphase_str, |
| pkt_mod_bm, ipv6l4keyname, frwdname, modname); |
| |
| for (indx = 0; indx < strlen(srcdir_str); indx++) |
| uc_srcdir_str[indx] = (char)toupper(srcdir_str[indx]); |
| |
| uc_srcdir_str[strlen(srcdir_str)] = 0; |
| |
| if (parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else if (get_srcdir_value(uc_srcdir_str, &src_dir) == GT_FALSE) |
| printk(KERN_INFO "Invalid src_port[%s]\n", srcdir_str); |
| else if (get_phase_value(nextphase_str, &nextphase) == GT_FALSE) |
| printk(KERN_INFO "Invalid next_phase[%s]\n", nextphase_str); |
| else if (((pdbipv6l4keyentry = find_tpm_ipv6_l4_ports_key_entry_by_name(ipv6l4keyname)) == 0) && \ |
| strcmp(ipv6l4keyname, ipv6_l4_key_empty_name) != 0) |
| printk(KERN_INFO "L4 ports key entry [%s] not found\n", ipv6l4keyname); |
| else if (((pdbfrwdentry = find_tpm_pkt_frwd_entry_by_name(frwdname)) == 0) && \ |
| strcmp(frwdname, frwd_empty_name) != 0) |
| printk(KERN_INFO "frwd entry [%s] not found\n", frwdname); |
| else if (((pdbmodentry = find_tpm_mod_entry_by_name(modname)) == 0) && \ |
| strcmp(modname, mod_empty_name) != 0) |
| printk(KERN_INFO "mod entry [%s] not found\n", modname); |
| else { |
| rule_action.next_phase = nextphase; |
| rule_action.pkt_act = action; |
| |
| if (pdbipv6l4keyentry != 0) |
| memcpy(&l4_key, &pdbipv6l4keyentry->l4_ports, sizeof(tpm_l4_ports_key_t)); |
| else |
| memset(&l4_key, 0, sizeof(tpm_l4_ports_key_t)); |
| |
| if (pdbfrwdentry != 0) |
| memcpy(&pkt_frwd, &pdbfrwdentry->frwd, sizeof(tpm_pkt_frwd_t)); |
| else |
| memset(&pkt_frwd, 0, sizeof(tpm_pkt_frwd_t)); |
| |
| if (pdbmodentry != 0) |
| memcpy(&pkt_mod, &pdbmodentry->mod, sizeof(tpm_pkt_mod_t)); |
| else |
| memset(&pkt_mod, 0, sizeof(tpm_pkt_mod_t)); |
| |
| if (TPM_RC_OK == (rc = _tpm_add_ipv6_l4_ports_5t_rule(owner_id, |
| src_dir, |
| rule_num, |
| &rule_idx, |
| parse_rule_bm, |
| parse_flags_bm, |
| &l4_key, |
| &pkt_frwd, |
| &pkt_mod, |
| pkt_mod_bm, |
| &rule_action)) ) |
| PR_RULE_IDX(rule_idx) |
| else |
| printk(KERN_INFO "%s: tpm_add_ipv6_l4_ports_5t_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ipv6_l4_ports_5t_rule_bounce(uint32_t owner_id, |
| uint32_t rule_idx) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_IPV6_DIP_5T_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->rule_idx = rule_idx; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_ipv6_l4_ports_5t_rule tpm_del_ipv6_l4_ports_5t_rule_bounce |
| #else |
| #define _tpm_del_ipv6_l4_ports_5t_rule tpm_del_ipv6_l4_ports_5t_rule |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_ipv6_l4_ports_5t |
| * |
| * DESCRIPTION: |
| * This function deletes a IPV6 HW gen ACL rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_ipv6_l4_ports_5t(const char *buf, size_t len) |
| { |
| typedef enum { |
| noipv6l4_owner=0, noipv6l4_ruleidx, noipv6l4_max |
| } noipv6l4ruleadd_parm_indx_t; |
| // shell line parsing |
| unsigned int ownerid; |
| uint32_t rule_idx; |
| int parsedargs; |
| int numparms; |
| // DB |
| // Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noipv6l4_max) |
| parm_error_completion(numparms, noipv6l4_max, buf, sfs_help_no_rule_add); |
| else { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &rule_idx); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], rule_idx[%d]\n", |
| len, parsedargs, ownerid, rule_idx); |
| |
| |
| if (parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else { |
| if ((rc = _tpm_del_ipv6_l4_ports_5t_rule(ownerid, rule_idx)) == TPM_RC_OK) |
| PR_RESULT |
| else |
| printk(KERN_INFO "%s: tpm_del_ipv6_l4_ports_5t_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| /*tpm self check*/ |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_rule_self_check_bounce(uint32_t owner_id,uint32_t level) |
| { |
| tpm_ioctl_tpm_check_t *tpm_check_param = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_check_param; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_TPM_CHECK_SECTION; |
| tpm_check_param->owner_id = owner_id; |
| tpm_check_param->check_level = level; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_rule_self_check tpm_rule_self_check_bounce |
| #else |
| #define _tpm_rule_self_check tpm_rule_self_check |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_rule_self_check |
| * |
| * DESCRIPTION: |
| * This function creates does a tpm rule check |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_rule_self_check (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| tpm_self_check_owner=0, tpm_self_check_level, tpm_self_check_max |
| } tpm_check_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t level; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != tpm_self_check_max) { |
| parm_error_completion(numparms, tpm_self_check_max, buf, sfs_help_mib_reset); |
| } else { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &level); |
| |
| if (parsedargs != numparms) { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } else if (level > TPM_ENUM_MAX_CHECK_LEVEL) { |
| printk(KERN_INFO "Invalid level[%d]\n", level); |
| } else { |
| if ((rc = _tpm_rule_self_check(ownerid, level)) != TPM_RC_OK) { |
| printk(KERN_INFO "%s: tpm_rule_self_check failed, rc[%d] - %s\n", |
| __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_flush_vtu_bounce(uint32_t owner_id) |
| { |
| tpm_ioctl_flush_vtu_t *tpm_flush_vtu = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_flush_vtu; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_FLUSH_VTU_SECTION; |
| tpm_flush_vtu->owner_id = owner_id; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_flush_vtu tpm_flush_vtu_bounce |
| #else |
| #define _tpm_flush_vtu tpm_flush_vtu |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_flush_vtu |
| * |
| * DESCRIPTION: |
| * This function flush vtu of the switch |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_flush_vtu (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| flush_vtu_owner=0, flush_vtu_max |
| } flush_vtu_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != flush_vtu_max) |
| { |
| parm_error_completion(numparms, flush_vtu_max, buf, sfs_help_flush_vtu); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d", &ownerid); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d]\n", len, parsedargs, ownerid); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = _tpm_flush_vtu(ownerid)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_flush_vtu failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_flush_atu_bounce(uint32_t owner_id, tpm_flush_atu_type_t flush_type, uint16_t db_num) |
| { |
| tpm_ioctl_flush_atu_t *tpm_flush_atu = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ioctl_flush_atu; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_FLUSH_ATU_SECTION; |
| tpm_flush_atu->owner_id = owner_id; |
| tpm_flush_atu->flush_type = flush_type; |
| tpm_flush_atu->db_num = db_num; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_flush_atu tpm_flush_atu_bounce |
| #else |
| #define _tpm_flush_atu tpm_flush_atu |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_flush_atu |
| * |
| * DESCRIPTION: |
| * This function flush atu of the switch |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_flush_atu (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| flush_atu_owner=0, flush_atu_type, flush_atu_dbnum, flush_atu_max |
| } flush_atu_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t flush_type; |
| uint32_t db_num; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != flush_atu_max) |
| { |
| parm_error_completion(numparms, flush_atu_max, buf, sfs_help_flush_atu); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d %d", &ownerid, &flush_type, &db_num); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], flush_type[%d], db_num[%d]\n", |
| // len, parsedargs, ownerid, flush_type, db_num); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (flush_type > TPM_FLUSH_ATU_DYNAMIC) |
| { |
| printk(KERN_INFO "Invalid flush_type[%d]\n", flush_type); |
| } |
| else |
| { |
| if ((rc = _tpm_flush_atu(ownerid, flush_type, db_num)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_flush_atu failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_ctc_cm_set_ipv6_parse_win_bounce(uint32_t owner_id, tpm_ctc_cm_ipv6_parse_win_t ipv6_parse_window) |
| { |
| tpm_ioctl_ipv6_parse_window_t *ipv6_parse_window = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_ipv6_parse_window; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_SET_IPV6_CM_PARSE_WIN_SECTION; |
| ipv6_parse_window->owner_id = owner_id; |
| ipv6_parse_window->ipv6_parse_window = ipv6_parse_window; |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_ctc_cm_set_ipv6_parse_win tpm_ctc_cm_set_ipv6_parse_win_bounce |
| #else |
| #define _tpm_ctc_cm_set_ipv6_parse_win tpm_ctc_cm_set_ipv6_parse_win |
| #endif |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_mac_learn_rule_bounce(uint32_t owner_id, tpm_l2_acl_key_t *src_mac_addr) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_MAC_LEARN_ACL_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| memcpy(&(tpm_add_acl_rule->l2_acl_rule.l2_key), (void*)src_mac_addr, sizeof(tpm_l2_acl_key_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_mac_learn_rule tpm_add_mac_learn_rule_bounce |
| #else |
| #define _tpm_add_mac_learn_rule tpm_add_mac_learn_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_ctc_cm_set_ipv6_parse_win |
| * |
| * DESCRIPTION: |
| * This function set_ipv6_parse_win |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_ctc_cm_set_ipv6_parse_win (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| ctc_cm_set_ipv6_parse_win_owner=0, ctc_cm_set_ipv6_parse_win, ctc_cm_set_ipv6_parse_win_max |
| } ctc_cm_set_ipv6_parse_win_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t ipv6_parse_win; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != ctc_cm_set_ipv6_parse_win_max) |
| { |
| parm_error_completion(numparms, ctc_cm_set_ipv6_parse_win_max, buf, sfs_help_ctc_cm_set_ipv6_parse_win); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &ipv6_parse_win); |
| // printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], ipv6_parse_win[%d]\n", |
| // len, parsedargs, ownerid, db_num); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (ipv6_parse_win > TPM_CTC_CM_IPv6_SECOND_24B) |
| { |
| printk(KERN_INFO "Invalid ipv6_parse_win[%d]\n", ipv6_parse_win); |
| } |
| else |
| { |
| if ((rc = _tpm_ctc_cm_set_ipv6_parse_win(ownerid, (tpm_ctc_cm_ipv6_parse_win_t)ipv6_parse_win)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_ctc_cm_set_ipv6_parse_win failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_mac_learn_rule_add |
| * |
| * DESCRIPTION: |
| * This function creates a L2 mac learn rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_mac_learn_rule_add(const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| mac_learn_add_owner=0, mac_learn_add_l2keyname, mac_learn_add_max |
| } mac_learn_add_parm_indx_t; |
| /* shell line parsing */ |
| uint32_t ownerid; |
| char l2keyname[20]; |
| int parsedargs; |
| int numparms; |
| /* DB */ |
| tpmcfg_l2_key_entry_t *pdbl2keyentry = 0; |
| |
| /* Used in API call */ |
| tpm_l2_acl_key_t l2_acl; |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != mac_learn_add_max) { |
| parm_error_completion(numparms, mac_learn_add_max, buf, sfs_help_mac_learn_rule_add); |
| } else { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d %s", &ownerid, l2keyname); |
| |
| if (parsedargs != numparms) { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } else if (((pdbl2keyentry = find_tpm_l2_key_entry_by_name(l2keyname)) == 0)) { |
| printk(KERN_INFO "L2 MAC addr key entry [%s] not found\n", l2keyname); |
| return; |
| } else { |
| memcpy(&l2_acl, &pdbl2keyentry->l2_acl, sizeof(tpm_l2_acl_key_t)); |
| if ((rc = _tpm_add_mac_learn_rule(ownerid, &l2_acl)) == TPM_RC_OK) |
| printk("OK\n"); |
| else |
| printk(KERN_INFO "%s: tpm_add_mac_learn_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_mac_learn_rule_bounce(uint32_t owner_id, tpm_l2_acl_key_t *src_mac_addr) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_MAC_LEARN_ACL_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| memcpy(&(tpm_del_acl_rule->l2_key), (void*)src_mac_addr, sizeof(tpm_l2_acl_key_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_mac_learn_rule tpm_del_mac_learn_rule_bounce |
| #else |
| #define _tpm_del_mac_learn_rule tpm_del_mac_learn_rule |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_mac_learn |
| * |
| * DESCRIPTION: |
| * This function deletes a L2 mac learn rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_mac_learn(const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| noruleadd_maclearn_owner=0, noruleadd_maclearn_l2keyname, noruleadd_maclearn_max |
| } noruleadd_maclearn_parm_indx_t; |
| /* shell line parsing */ |
| uint32_t ownerid; |
| int parsedargs; |
| int numparms; |
| char l2keyname[20]; |
| tpmcfg_l2_key_entry_t *pdbl2keyentry = 0; |
| /* Used in API call */ |
| tpm_l2_acl_key_t l2_acl; |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noruleadd_maclearn_max) { |
| parm_error_completion(numparms, noruleadd_maclearn_max, buf, sfs_help_no_rule_add); |
| } else { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d %s", &ownerid, l2keyname); |
| |
| if (parsedargs != numparms) { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } else if (((pdbl2keyentry = find_tpm_l2_key_entry_by_name(l2keyname)) == 0)) { |
| printk(KERN_INFO "L2 MAC addr key entry [%s] not found\n", l2keyname); |
| return; |
| } else { |
| memcpy(&l2_acl, &pdbl2keyentry->l2_acl, sizeof(tpm_l2_acl_key_t)); |
| if ((rc = _tpm_del_mac_learn_rule(ownerid, &l2_acl)) == TPM_RC_OK) |
| printk(KERN_INFO "OK\n"); |
| else |
| printk(KERN_INFO "%s: tpm_del_mac_learn_rule failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_mac_learn_default_rule_act_set_bounce(uint32_t owner_id, tpm_unknown_mac_conf_t mac_conf) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_SET_MAC_LEARN_DEFAULT_ACTION; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->l2_acl_rule.mac_conf = mac_conf; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_mac_learn_default_rule_act_set tpm_mac_learn_default_rule_act_set_bounce |
| #else |
| #define _tpm_mac_learn_default_rule_act_set tpm_mac_learn_default_rule_act_set |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_mac_learn_default_rule_action |
| * |
| * DESCRIPTION: |
| * This function set the action for mac learn default rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_mac_learn_default_rule_action(const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| default_rule_action_owner=0, default_rule_action_act, default_rule_action_max |
| } default_rule_action_parm_indx_t; |
| /* shell line parsing */ |
| uint32_t ownerid; |
| int parsedargs; |
| int numparms; |
| tpm_unknown_mac_conf_t mac_conf; |
| /* Used in API call */ |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != default_rule_action_max) { |
| parm_error_completion(numparms, default_rule_action_max, buf, sfs_help_mac_learn_def_act_set); |
| } else { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d %x", &ownerid, &mac_conf); |
| |
| if (parsedargs != numparms) { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } else { |
| if ((rc = _tpm_mac_learn_default_rule_act_set(ownerid, mac_conf)) == TPM_RC_OK) |
| printk(KERN_INFO "OK\n"); |
| else |
| printk(KERN_INFO "%s: tpm_mac_learn_default_rule_act_set failed, rc[%d] - %s\n", __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_fc |
| * |
| * DESCRIPTION: |
| * This function configures SW flow control |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_fc(const char *buf, size_t len) |
| { |
| typedef enum { |
| fc_thresh_high = 0, |
| fc_thresh_low, |
| fc_port, |
| fc_tgt_port, |
| fc_tx_port, |
| fc_tx_queue, |
| fc_max |
| } fc_parm_indx_t; |
| /* shell line parsing */ |
| tpm_fc_cfg_t cfg; |
| int parsedargs; |
| int numparms; |
| |
| numparms = count_parameters(buf); |
| if (numparms != fc_max) |
| parm_error_completion(numparms, fc_max, buf, sfs_help_rate_limit); |
| else { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d %d %d %d %d %d", |
| &cfg.thresh_high, &cfg.thresh_low, |
| &cfg.port, &cfg.tx_port, &cfg.tx_queue, &cfg.tgt_port); |
| |
| if (parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else { |
| tpm_fc_set_config(&cfg); |
| printk(KERN_INFO "OK\n"); |
| |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_fc_period |
| * |
| * DESCRIPTION: |
| * This function configures SW flow control engine minitoring period |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_fc_period(const char *buf, size_t len) |
| { |
| typedef enum { |
| fc_period = 0, |
| fc_max |
| } fc_parm_indx_t; |
| /* shell line parsing */ |
| uint32_t period; |
| int parsedargs; |
| int numparms; |
| MV_STATUS ret_code; |
| |
| numparms = count_parameters(buf); |
| if (numparms != fc_max) |
| parm_error_completion(numparms, fc_max, buf, sfs_help_rate_limit); |
| else { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d", &period); |
| |
| if (parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else { |
| ret_code = tpm_fc_set_period(period); |
| if (ret_code != MV_OK) |
| printk(KERN_INFO "%s: tpm_fc_set_period() failed!\n", __func__); |
| else |
| printk(KERN_INFO "OK\n"); |
| } |
| } |
| } |
| |
| #ifdef TPM_FC_DEBUG |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_fc_oneshot |
| * |
| * DESCRIPTION: |
| * This function configures SW flow control engine minitoring |
| * oneshot count for statistics |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_fc_oneshot(const char *buf, size_t len) |
| { |
| typedef enum { |
| fc_oneshot = 0, |
| fc_max |
| } fc_parm_indx_t; |
| /* shell line parsing */ |
| uint32_t oneshot; |
| int parsedargs; |
| int numparms; |
| MV_STATUS ret_code; |
| |
| numparms = count_parameters(buf); |
| if (numparms != fc_max) |
| parm_error_completion(numparms, fc_max, buf, sfs_help_rate_limit); |
| else { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d", &oneshot); |
| |
| if (parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else { |
| ret_code = tpm_fc_set_oneshot(oneshot); |
| if (ret_code != MV_OK) |
| printk(KERN_INFO "%s: tpm_fc_set_oneshot() failed!\n", __func__); |
| else |
| printk(KERN_INFO "OK\n"); |
| } |
| } |
| } |
| #endif |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_fc_enable |
| * |
| * DESCRIPTION: |
| * This function configures SW flow control engine minitoring |
| * oneshot count for statistics |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_fc_enable(const char *buf, size_t len) |
| { |
| typedef enum { |
| _fc_enable = 0, |
| fc_max |
| } fc_parm_indx_t; |
| /* shell line parsing */ |
| uint32_t fc_enable; |
| int parsedargs; |
| int numparms; |
| MV_STATUS ret_code; |
| |
| numparms = count_parameters(buf); |
| if (numparms != fc_max) |
| parm_error_completion(numparms, fc_max, buf, sfs_help_rate_limit); |
| else { |
| /* Get parameters */ |
| parsedargs = sscanf(buf, "%d", &fc_enable); |
| |
| if (parsedargs != numparms) |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| else { |
| ret_code = tpm_fc_enable((fc_enable == 0) ? MV_FALSE : MV_TRUE); |
| if (ret_code != MV_OK) |
| printk(KERN_INFO "%s: tpm_fc_enable() failed!\n", __func__); |
| else |
| printk(KERN_INFO "OK\n"); |
| } |
| } |
| } |
| |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_add_ds_load_balance_rule_bounce(uint32_t owner_id, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_parse_flags_t parse_flags_bm, |
| tpm_l2_acl_key_t *l2_key, |
| tpm_ds_load_balance_tgrt_t tgrt_port) |
| { |
| tpm_ioctl_add_acl_rule_t *tpm_add_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_add_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_ADD_ACL_SECTION; |
| tpm_add_acl_rule->add_acl_cmd = MV_TPM_IOCTL_ADD_DS_LOAD_BALANCE_RULE; |
| tpm_add_acl_rule->owner_id = owner_id; |
| tpm_add_acl_rule->rule_num = rule_num; |
| tpm_add_acl_rule->parse_rule_bm = parse_rule_bm; |
| tpm_add_acl_rule->ds_load_balance_acl_rule.parse_flags_bm = parse_flags_bm; |
| tpm_add_acl_rule->ds_load_balance_acl_rule.tgrt = tgrt_port; |
| memcpy(&(tpm_add_acl_rule->ds_load_balance_acl_rule.l2_key), (void*)l2_key, sizeof(tpm_l2_acl_key_t)); |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_add_ds_load_balance_rule tpm_add_ds_load_balance_rule_bounce |
| #else |
| #define _tpm_add_ds_load_balance_rule tpm_add_ds_load_balance_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_ds_load_balance_rule_add |
| * |
| * DESCRIPTION: |
| * This function creates a ds_load_balance rule |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_ds_load_balance_rule_add (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| ds_load_blnc_ruleadd_owner=0, ds_load_blnc_ruleadd_rulenum, |
| ds_load_blnc_ruleadd_parserulebm, ds_load_blnc_ruleadd_parseflagsbm, |
| ds_load_blnc_ruleadd_l2keyname, |
| ds_load_blnc_ruleadd_trgt, ds_load_blnc_ruleadd_max |
| } ds_load_blnc_ruleadd_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t rulenum; |
| uint32_t parserulebm; |
| uint32_t parseflagsbm; |
| uint32_t trgt; |
| char l2keyname[20]; |
| int parsedargs; |
| int numparms; |
| // DB |
| tpmcfg_l2_key_entry_t *pdbl2keyentry = 0; |
| //Used in API call |
| tpm_l2_acl_key_t l2_acl; |
| uint32_t rule_idx; |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != ds_load_blnc_ruleadd_max) |
| { |
| parm_error_completion(numparms, ds_load_blnc_ruleadd_max, buf, sfs_help_ds_load_balance_rule); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d 0x%x 0x%x %s %d", &ownerid, &rulenum, &parserulebm, |
| &parseflagsbm, l2keyname, &trgt); |
| printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], rulenum[%d], parserulebm[0x%x], parseflagsbm[0x%x], " |
| "l2keyname[%s], trgt[%d]\n", |
| len, parsedargs, ownerid, rulenum, parserulebm, parseflagsbm, l2keyname, trgt); |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else if (((pdbl2keyentry = find_tpm_l2_key_entry_by_name(l2keyname)) == 0) && strcmp(l2keyname, l2_key_empty_name) != 0) |
| { |
| printk(KERN_INFO "L2 key entry [%s] not found\n", l2keyname); |
| } |
| else |
| { |
| |
| if (pdbl2keyentry != 0) memcpy(&l2_acl, &pdbl2keyentry->l2_acl, sizeof(tpm_l2_acl_key_t)); |
| else memset(&l2_acl, 0, sizeof(tpm_l2_acl_key_t)); |
| |
| if ((rc = _tpm_add_ds_load_balance_rule(ownerid, |
| rulenum, |
| &rule_idx, |
| parserulebm, |
| parseflagsbm, |
| &l2_acl, |
| trgt)) == TPM_RC_OK) |
| PR_RULE_IDX(rule_idx) |
| else |
| { |
| printk(KERN_INFO "%s: tpm_add_ds_load_balance_rule failed, rc[%d] - %s\n", |
| __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| #ifdef CONFIG_MV_TPM_SFS_2_IOCTL |
| tpm_error_code_t tpm_del_ds_load_balance_rule_bounce(uint32_t owner_id, |
| uint32_t rule_idx) |
| { |
| tpm_ioctl_del_acl_rule_t *tpm_del_acl_rule = &tpm_sfs_2_ioctl_command.tpm_cmd_data.tpm_del_acl_rule; |
| |
| tpm_sfs_2_ioctl_command.cmd = MV_TPM_IOCTL_DEL_ACL_SECTION; |
| tpm_del_acl_rule->del_acl_cmd = MV_TPM_IOCTL_DEL_DS_LOAD_BALANCE_RULE; |
| tpm_del_acl_rule->owner_id = owner_id; |
| tpm_del_acl_rule->rule_idx = rule_idx; |
| |
| up(&tpm_sfs_2_ioctl_sem); |
| |
| return TPM_RC_OK; |
| } |
| #define _tpm_del_ds_load_balance_rule tpm_del_ds_load_balance_rule_bounce |
| #else |
| #define _tpm_del_ds_load_balance_rule tpm_del_ds_load_balance_rule |
| #endif |
| |
| |
| /******************************************************************************* |
| * sfs_tpm_cfg_set_no_rule_add_ds_load_balance |
| * |
| * DESCRIPTION: |
| * This function deletes a ds_load_balance HW rule (PNC) |
| * INPUTS: |
| * buf - Shell parameters as char buffer |
| * len - Number of characters in buffer |
| * |
| *******************************************************************************/ |
| void sfs_tpm_cfg_set_no_rule_add_ds_load_balance (const char *buf, size_t len) |
| { |
| typedef enum |
| { |
| noruleadd_owner=0, noruleadd_ruleidx, noruleadd_max |
| } noruleadd_parm_indx_t; |
| // shell line parsing |
| uint32_t ownerid; |
| uint32_t rule_idx; |
| int parsedargs; |
| int numparms; |
| //Used in API call |
| tpm_error_code_t rc; |
| |
| numparms = count_parameters(buf); |
| if (numparms != noruleadd_max) |
| { |
| parm_error_completion(numparms, noruleadd_max, buf, sfs_help_no_rule_add); |
| } |
| else |
| { |
| // Get parameters |
| parsedargs = sscanf(buf, "%d %d", &ownerid, &rule_idx); |
| //printk(KERN_INFO "len=%d, parsedargs=%d. ownerid[%d], rule_idx[%d]\n", |
| // len, parsedargs, ownerid, rule_idx); |
| |
| |
| if (parsedargs != numparms) |
| { |
| printk(KERN_INFO "Parse failure - %d/%d parameters were parsed\n", parsedargs, numparms); |
| } |
| else |
| { |
| if ((rc = _tpm_del_ds_load_balance_rule(ownerid, rule_idx)) == TPM_RC_OK) |
| { |
| printk(KERN_INFO "OK\n"); |
| } |
| else |
| { |
| printk(KERN_INFO "%s: tpm_del_ds_load_balance_rule failed, rc[%d] - %s\n", |
| __FUNCTION__, rc, get_tpm_err_str(rc)); |
| } |
| } |
| } |
| } |
| |
| |