| /* |
| * Copyright (c) 2012, 2016, The Linux Foundation. All rights reserved. |
| * Permission to use, copy, modify, and/or distribute this software for |
| * any purpose with or without fee is hereby granted, provided that the |
| * above copyright notice and this permission notice appear in all copies. |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
| * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT |
| * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| |
| #include "sw_config.h" |
| #include "aos_head.h" |
| #include "sw_error.h" |
| #include "shared_func.h" |
| #include "hsl.h" |
| #include "hsl_dev.h" |
| #include "hsl_acl.h" |
| |
| typedef struct |
| { |
| a_uint32_t pri; |
| a_uint32_t addr; |
| a_uint32_t size; |
| a_uint32_t status; |
| a_uint32_t info; |
| } hsl_acl_blk_t; |
| |
| typedef struct |
| { |
| a_uint32_t used_blk; |
| a_uint32_t total_blk; |
| a_uint32_t free_rsc; |
| hsl_acl_blk_t *blk_ent; |
| } hsl_acl_pool_t; |
| |
| #define MEM_FREE 1 |
| #define MEM_USED 2 |
| |
| static hsl_acl_pool_t acl_pool[SW_MAX_NR_DEV]; |
| |
| static sw_error_t |
| _hsl_acl_blk_loc(a_uint32_t dev_id, a_uint32_t addr, a_uint32_t * idx); |
| |
| static sw_error_t |
| _hsl_acl_blk_comb(a_uint32_t dev_id, a_uint32_t idx, a_uint32_t nr); |
| |
| static sw_error_t _hsl_acl_free_blk_comb(a_uint32_t dev_id, a_uint32_t idx); |
| |
| static sw_error_t |
| _hsl_acl_blk_ent_left_mv(a_uint32_t dev_id, a_uint32_t idx, a_uint32_t offset); |
| |
| static sw_error_t |
| _hsl_acl_blk_ent_right_mv(a_uint32_t dev_id, a_uint32_t idx, a_uint32_t offset); |
| |
| static sw_error_t |
| _hsl_acl_blk_left_defrag(a_uint32_t dev_id, a_uint32_t p_idx, a_uint32_t t_size, |
| a_bool_t b_must, a_uint32_t * f_idx, a_uint32_t * f_nr, |
| a_uint32_t * f_size); |
| |
| static sw_error_t |
| _hsl_acl_blk_right_defrag(a_uint32_t dev_id, a_uint32_t p_idx, |
| a_uint32_t t_size, a_bool_t b_must, |
| a_uint32_t * f_idx, a_uint32_t * f_nr, |
| a_uint32_t * f_size); |
| |
| static sw_error_t |
| _hsl_acl_blk_alloc(a_uint32_t dev_id, a_uint32_t free_idx, a_uint32_t pri, |
| a_uint32_t size, a_uint32_t info, a_uint32_t * addr); |
| |
| static sw_error_t |
| _hsl_acl_blk_reduce(a_uint32_t dev_id, a_uint32_t idx, a_uint32_t new_size); |
| |
| static sw_error_t |
| _hsl_acl_blk_left_enlarge(a_uint32_t dev_id, a_uint32_t idx, |
| a_uint32_t new_size); |
| |
| static sw_error_t |
| _hsl_acl_blk_right_enlarge(a_uint32_t dev_id, a_uint32_t idx, |
| a_uint32_t new_size); |
| |
| static sw_error_t |
| _hsl_acl_rule_copy(a_uint32_t dev_id, a_uint32_t src_addr, a_uint32_t dest_addr, |
| a_uint32_t size); |
| |
| static sw_error_t |
| _hsl_acl_rule_invalid(a_uint32_t dev_id, a_uint32_t addr, a_uint32_t size); |
| |
| static sw_error_t |
| _hsl_acl_addr_update(a_uint32_t dev_id, a_uint32_t old_addr, |
| a_uint32_t new_addr, a_uint32_t info); |
| |
| //#define ACL_POOL_DEBUG |
| #ifdef ACL_POOL_DEBUG |
| static void |
| _hsl_acl_blk_dump(a_uint32_t dev_id, const char *info) |
| { |
| a_uint32_t i; |
| |
| aos_printk("\n%s dev_id=%d free_rsc=%d total_blk=%d used_blk=%d", |
| info, dev_id, acl_pool[dev_id].free_rsc, |
| acl_pool[dev_id].total_blk, acl_pool[dev_id].used_blk); |
| |
| for (i = 0; i < acl_pool[dev_id].used_blk; i++) |
| { |
| aos_printk("\naddr=%d status = %d size=%d list_id=%d list_pri=%d", |
| acl_pool[dev_id].blk_ent[i].addr, |
| acl_pool[dev_id].blk_ent[i].status, |
| acl_pool[dev_id].blk_ent[i].size, |
| acl_pool[dev_id].blk_ent[i].info, |
| acl_pool[dev_id].blk_ent[i].pri); |
| } |
| aos_printk("\n"); |
| } |
| #else |
| #define _hsl_acl_blk_dump(dev_id, info) |
| #endif |
| |
| static sw_error_t |
| _hsl_acl_blk_loc(a_uint32_t dev_id, a_uint32_t addr, a_uint32_t * idx) |
| { |
| a_uint32_t i; |
| |
| for (i = 0; i < acl_pool[dev_id].used_blk; i++) |
| { |
| if (addr == acl_pool[dev_id].blk_ent[i].addr) |
| { |
| *idx = i; |
| return SW_OK; |
| } |
| } |
| return SW_NOT_FOUND; |
| } |
| |
| static sw_error_t |
| _hsl_acl_blk_comb(a_uint32_t dev_id, a_uint32_t idx, a_uint32_t nr) |
| { |
| sw_error_t rv; |
| a_uint32_t i, size; |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_comb before combine"); |
| |
| if ((idx + nr) > acl_pool[dev_id].used_blk) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| if (nr < 2) |
| { |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_comb after combine"); |
| return SW_OK; |
| } |
| |
| size = 0; |
| for (i = 0; i < nr; i++) |
| { |
| size += acl_pool[dev_id].blk_ent[idx + i].size; |
| } |
| acl_pool[dev_id].blk_ent[idx].size = size; |
| |
| rv = _hsl_acl_blk_ent_left_mv(dev_id, idx + nr, nr - 1); |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_comb after combine"); |
| return rv; |
| } |
| |
| static sw_error_t |
| _hsl_acl_free_blk_comb(a_uint32_t dev_id, a_uint32_t idx) |
| { |
| sw_error_t rv; |
| a_uint32_t first, num; |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_free_blk_comb before combine"); |
| |
| first = idx; |
| num = 1; |
| if (0 != idx) |
| { |
| if (MEM_FREE == acl_pool[dev_id].blk_ent[idx - 1].status) |
| { |
| num++; |
| first = idx - 1; |
| } |
| } |
| |
| if ((acl_pool[dev_id].used_blk - 1) != idx) |
| { |
| if (MEM_FREE == acl_pool[dev_id].blk_ent[idx + 1].status) |
| { |
| num++; |
| } |
| } |
| |
| rv = _hsl_acl_blk_comb(dev_id, first, num); |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_free_blk_comb after combine"); |
| return rv; |
| } |
| |
| static sw_error_t |
| _hsl_acl_blk_ent_left_mv(a_uint32_t dev_id, a_uint32_t idx, a_uint32_t offset) |
| { |
| a_uint32_t i; |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_ent_left_mv before move"); |
| |
| if (offset > idx) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| for (i = idx; i < acl_pool[dev_id].used_blk; i++) |
| { |
| acl_pool[dev_id].blk_ent[i - offset] = acl_pool[dev_id].blk_ent[i]; |
| } |
| |
| acl_pool[dev_id].used_blk -= offset; |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_ent_left_mv after move"); |
| return SW_OK; |
| } |
| |
| static sw_error_t |
| _hsl_acl_blk_ent_right_mv(a_uint32_t dev_id, a_uint32_t idx, a_uint32_t offset) |
| { |
| a_uint32_t i, cnt, tmp; |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_ent_right_mv before move"); |
| |
| if (acl_pool[dev_id].total_blk < (acl_pool[dev_id].used_blk + offset)) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| /* we support to increase used block number without block moving */ |
| if (idx > acl_pool[dev_id].used_blk) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| cnt = acl_pool[dev_id].used_blk - idx; |
| tmp = acl_pool[dev_id].used_blk - 1; |
| for (i = 0; i < cnt; i++) |
| { |
| acl_pool[dev_id].blk_ent[tmp + offset - i] |
| = acl_pool[dev_id].blk_ent[tmp - i]; |
| } |
| |
| acl_pool[dev_id].used_blk += offset; |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_ent_right_mv after move"); |
| return SW_OK; |
| } |
| |
| static sw_error_t |
| _hsl_acl_blk_left_defrag(a_uint32_t dev_id, a_uint32_t p_idx, a_uint32_t t_size, |
| a_bool_t b_must, a_uint32_t * f_idx, a_uint32_t * f_nr, |
| a_uint32_t * f_size) |
| { |
| sw_error_t rv; |
| a_int32_t idx; |
| a_uint32_t i, f_rsc, f_blk, dest_addr; |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_left_defrag before defrag"); |
| |
| f_rsc = 0; |
| for (idx = p_idx - 1; idx >= 0; idx--) |
| { |
| if (MEM_FREE == acl_pool[dev_id].blk_ent[idx].status) |
| { |
| f_rsc += acl_pool[dev_id].blk_ent[idx].size; |
| } |
| |
| if (t_size <= f_rsc) |
| { |
| break; |
| } |
| } |
| |
| if ((f_rsc < t_size) && (A_TRUE == b_must)) |
| { |
| return SW_NO_RESOURCE; |
| } |
| |
| if (0 == f_rsc) |
| { |
| *f_idx = p_idx; |
| *f_nr = 0; |
| *f_size = 0; |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_left_defrag after defrag"); |
| return SW_OK; |
| } |
| |
| if (idx < 0) |
| { |
| idx = 0; |
| } |
| |
| f_blk = 0; |
| f_rsc = 0; |
| dest_addr = acl_pool[dev_id].blk_ent[idx].addr; |
| for (i = idx; i < p_idx; i++) |
| { |
| if (MEM_FREE == acl_pool[dev_id].blk_ent[i].status) |
| { |
| f_blk += 1; |
| f_rsc += acl_pool[dev_id].blk_ent[i].size; |
| } |
| |
| if (MEM_USED == acl_pool[dev_id].blk_ent[i].status) |
| { |
| if (dest_addr != acl_pool[dev_id].blk_ent[i].addr) |
| { |
| /* update acl rules hardware position */ |
| rv = _hsl_acl_rule_copy(dev_id, |
| acl_pool[dev_id].blk_ent[i].addr, |
| dest_addr, |
| acl_pool[dev_id].blk_ent[i].size); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_addr_update(dev_id, |
| acl_pool[dev_id].blk_ent[i].addr, |
| dest_addr, |
| acl_pool[dev_id].blk_ent[i].info); |
| SW_RTN_ON_ERROR(rv); |
| |
| /* update acl memory block control infomation */ |
| acl_pool[dev_id].blk_ent[i - f_blk] = |
| acl_pool[dev_id].blk_ent[i]; |
| acl_pool[dev_id].blk_ent[i - f_blk].addr -= f_rsc; |
| } |
| dest_addr += acl_pool[dev_id].blk_ent[i].size; |
| } |
| } |
| |
| for (i = p_idx - f_blk; i < p_idx; i++) |
| { |
| acl_pool[dev_id].blk_ent[i].status = MEM_FREE; |
| acl_pool[dev_id].blk_ent[i].addr = dest_addr; |
| acl_pool[dev_id].blk_ent[i].size = 0; |
| acl_pool[dev_id].blk_ent[i].info = 0; |
| acl_pool[dev_id].blk_ent[i].pri = 0; |
| } |
| acl_pool[dev_id].blk_ent[p_idx - f_blk].size = f_rsc; |
| |
| *f_idx = p_idx - f_blk; |
| *f_nr = f_blk; |
| *f_size = f_rsc; |
| rv = _hsl_acl_rule_invalid(dev_id, acl_pool[dev_id].blk_ent[*f_idx].addr, |
| f_rsc); |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_left_defrag after defrag"); |
| return rv; |
| } |
| |
| static sw_error_t |
| _hsl_acl_blk_right_defrag(a_uint32_t dev_id, a_uint32_t p_idx, |
| a_uint32_t t_size, a_bool_t b_must, |
| a_uint32_t * f_idx, a_uint32_t * f_nr, |
| a_uint32_t * f_size) |
| { |
| sw_error_t rv; |
| a_uint32_t i, cnt; |
| a_uint32_t idx, f_rsc, f_blk, dest_addr; |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_right_defrag before defrag"); |
| |
| f_rsc = 0; |
| for (idx = p_idx; idx < acl_pool[dev_id].used_blk; idx++) |
| { |
| if (MEM_FREE == acl_pool[dev_id].blk_ent[idx].status) |
| { |
| f_rsc += acl_pool[dev_id].blk_ent[idx].size; |
| } |
| |
| if (t_size <= f_rsc) |
| { |
| break; |
| } |
| } |
| |
| if ((f_rsc < t_size) && (A_TRUE == b_must)) |
| { |
| return SW_NO_RESOURCE; |
| } |
| |
| if (0 == f_rsc) |
| { |
| *f_idx = p_idx; |
| *f_nr = 0; |
| *f_size = 0; |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_right_defrag after defrag"); |
| return SW_OK; |
| } |
| |
| if (idx >= acl_pool[dev_id].used_blk) |
| { |
| idx = acl_pool[dev_id].used_blk - 1; |
| } |
| |
| f_blk = 0; |
| f_rsc = 0; |
| dest_addr = acl_pool[dev_id].blk_ent[idx].addr |
| + acl_pool[dev_id].blk_ent[idx].size; |
| for (cnt = 0; cnt <= (idx -p_idx); cnt++) |
| { |
| i = idx - cnt; |
| if (MEM_FREE == acl_pool[dev_id].blk_ent[i].status) |
| { |
| f_blk += 1; |
| f_rsc += acl_pool[dev_id].blk_ent[i].size; |
| } |
| |
| if (MEM_USED == acl_pool[dev_id].blk_ent[i].status) |
| { |
| dest_addr -= acl_pool[dev_id].blk_ent[i].size; |
| |
| if (dest_addr != acl_pool[dev_id].blk_ent[i].addr) |
| { |
| /* update acl rules hardware position */ |
| rv = _hsl_acl_rule_copy(dev_id, |
| acl_pool[dev_id].blk_ent[i].addr, |
| dest_addr, |
| acl_pool[dev_id].blk_ent[i].size); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_addr_update(dev_id, |
| acl_pool[dev_id].blk_ent[i].addr, |
| dest_addr, |
| acl_pool[dev_id].blk_ent[i].info); |
| SW_RTN_ON_ERROR(rv); |
| |
| /* update acl memory block control infomation */ |
| acl_pool[dev_id].blk_ent[i + f_blk] = |
| acl_pool[dev_id].blk_ent[i]; |
| acl_pool[dev_id].blk_ent[i + f_blk].addr += f_rsc; |
| } |
| } |
| } |
| |
| for (i = p_idx; i < (p_idx + f_blk); i++) |
| { |
| acl_pool[dev_id].blk_ent[i].status = MEM_FREE; |
| acl_pool[dev_id].blk_ent[i].size = 0; |
| acl_pool[dev_id].blk_ent[i].addr = dest_addr - f_rsc; |
| } |
| acl_pool[dev_id].blk_ent[p_idx].size = f_rsc; |
| |
| *f_idx = p_idx; |
| *f_nr = f_blk; |
| *f_size = f_rsc; |
| rv = _hsl_acl_rule_invalid(dev_id, acl_pool[dev_id].blk_ent[*f_idx].addr, |
| f_rsc); |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_right_defrag after defrag"); |
| return rv; |
| } |
| |
| static sw_error_t |
| _hsl_acl_blk_alloc(a_uint32_t dev_id, a_uint32_t free_idx, a_uint32_t pri, |
| a_uint32_t size, a_uint32_t info, a_uint32_t * addr) |
| { |
| sw_error_t rv; |
| a_uint32_t i; |
| a_bool_t b_comb = A_FALSE; |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_alloc before alloc"); |
| |
| if (MEM_FREE != acl_pool[dev_id].blk_ent[free_idx].status) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| if (size > acl_pool[dev_id].blk_ent[free_idx].size) |
| { |
| return SW_NO_RESOURCE; |
| } |
| |
| if (size != acl_pool[dev_id].blk_ent[free_idx].size) |
| { |
| b_comb = A_TRUE; |
| i = free_idx + 1; |
| rv = _hsl_acl_blk_ent_right_mv(dev_id, i, 1); |
| SW_RTN_ON_ERROR(rv); |
| |
| acl_pool[dev_id].blk_ent[i].addr = |
| acl_pool[dev_id].blk_ent[free_idx].addr + size; |
| acl_pool[dev_id].blk_ent[i].size = |
| acl_pool[dev_id].blk_ent[free_idx].size - size; |
| acl_pool[dev_id].blk_ent[i].status = MEM_FREE; |
| acl_pool[dev_id].blk_ent[i].pri = 0; |
| acl_pool[dev_id].blk_ent[i].info = 0; |
| } |
| |
| acl_pool[dev_id].blk_ent[free_idx].status = MEM_USED; |
| acl_pool[dev_id].blk_ent[free_idx].size = size; |
| acl_pool[dev_id].blk_ent[free_idx].pri = pri; |
| acl_pool[dev_id].blk_ent[free_idx].info = info; |
| acl_pool[dev_id].free_rsc -= size; |
| |
| if (A_TRUE == b_comb) |
| { |
| /* try to combine neighbor free memory blocks */ |
| rv = _hsl_acl_free_blk_comb(dev_id, free_idx + 1); |
| SW_RTN_ON_ERROR(rv); |
| } |
| |
| *addr = acl_pool[dev_id].blk_ent[free_idx].addr; |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_alloc after alloc"); |
| return SW_OK; |
| } |
| |
| static sw_error_t |
| _hsl_acl_blk_reduce(a_uint32_t dev_id, a_uint32_t idx, a_uint32_t new_size) |
| { |
| sw_error_t rv; |
| a_uint32_t addr, old_size; |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_reduce before reduce"); |
| |
| addr = acl_pool[dev_id].blk_ent[idx].addr; |
| old_size = acl_pool[dev_id].blk_ent[idx].size; |
| |
| rv = _hsl_acl_blk_ent_right_mv(dev_id, idx + 1, 1); |
| SW_RTN_ON_ERROR(rv); |
| |
| acl_pool[dev_id].blk_ent[idx].size = new_size; |
| acl_pool[dev_id].blk_ent[idx + 1].status = MEM_FREE; |
| acl_pool[dev_id].blk_ent[idx + 1].addr = addr + new_size; |
| acl_pool[dev_id].blk_ent[idx + 1].size = old_size - new_size; |
| acl_pool[dev_id].blk_ent[idx + 1].pri = 0; |
| acl_pool[dev_id].blk_ent[idx + 1].info = 0; |
| acl_pool[dev_id].free_rsc += (old_size - new_size); |
| |
| /* try to combine neighbor free blocks */ |
| rv = _hsl_acl_free_blk_comb(dev_id, idx + 1); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_rule_invalid(dev_id, addr + new_size, old_size - new_size); |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_reduce after reduce"); |
| return rv; |
| } |
| |
| static sw_error_t |
| _hsl_acl_blk_left_enlarge(a_uint32_t dev_id, a_uint32_t idx, |
| a_uint32_t new_size) |
| { |
| sw_error_t rv; |
| a_uint32_t old_size, old_addr, new_addr; |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_left_enlarge before enlarge"); |
| |
| if (0 == idx) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| if (MEM_FREE != acl_pool[dev_id].blk_ent[idx - 1].status) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| old_size = acl_pool[dev_id].blk_ent[idx].size; |
| if ((new_size - old_size) > acl_pool[dev_id].blk_ent[idx - 1].size) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| old_addr = acl_pool[dev_id].blk_ent[idx].addr; |
| new_addr = old_addr - (new_size - old_size); |
| rv = _hsl_acl_rule_copy(dev_id, old_addr, new_addr, old_size); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_rule_invalid(dev_id, new_addr + old_size, new_size - old_size); |
| SW_RTN_ON_ERROR(rv); |
| |
| acl_pool[dev_id].blk_ent[idx].size = new_size; |
| acl_pool[dev_id].blk_ent[idx].addr = new_addr; |
| acl_pool[dev_id].free_rsc -= (new_size - old_size); |
| rv = _hsl_acl_addr_update(dev_id, old_addr, new_addr, |
| acl_pool[dev_id].blk_ent[idx].info); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = SW_OK; |
| if ((new_size - old_size) == acl_pool[dev_id].blk_ent[idx - 1].size) |
| { |
| rv = _hsl_acl_blk_ent_left_mv(dev_id, idx, 1); |
| } |
| else |
| { |
| acl_pool[dev_id].blk_ent[idx - 1].size -= (new_size - old_size); |
| } |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_left_enlarge after enlarge"); |
| return rv; |
| } |
| |
| static sw_error_t |
| _hsl_acl_blk_right_enlarge(a_uint32_t dev_id, a_uint32_t idx, |
| a_uint32_t new_size) |
| { |
| sw_error_t rv; |
| a_uint32_t old_size; |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_right_enlarge before enlarge"); |
| |
| if ((idx + 1) >= acl_pool[dev_id].used_blk) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| if (MEM_FREE != acl_pool[dev_id].blk_ent[idx + 1].status) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| old_size = acl_pool[dev_id].blk_ent[idx].size; |
| if ((new_size - old_size) > acl_pool[dev_id].blk_ent[idx + 1].size) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| acl_pool[dev_id].blk_ent[idx].size = new_size; |
| acl_pool[dev_id].free_rsc -= (new_size - old_size); |
| rv = SW_OK; |
| if ((new_size - old_size) < acl_pool[dev_id].blk_ent[idx + 1].size) |
| { |
| acl_pool[dev_id].blk_ent[idx + 1].size -= (new_size - old_size); |
| acl_pool[dev_id].blk_ent[idx + 1].addr += (new_size - old_size); |
| } |
| else |
| { |
| if ((idx + 2) < acl_pool[dev_id].used_blk) |
| { |
| rv = _hsl_acl_blk_ent_left_mv(dev_id, idx + 2, 1); |
| } |
| } |
| |
| _hsl_acl_blk_dump(dev_id, "_hsl_acl_blk_right_enlarge after enlarge"); |
| return rv; |
| } |
| |
| static sw_error_t |
| _hsl_acl_rule_copy(a_uint32_t dev_id, a_uint32_t src_addr, a_uint32_t dest_addr, |
| a_uint32_t size) |
| { |
| hsl_acl_func_t * p_api; |
| sw_error_t rv; |
| |
| p_api = hsl_acl_ptr_get(dev_id); |
| SW_RTN_ON_NULL(p_api); |
| |
| if (NULL == p_api->acl_rule_copy) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->acl_rule_copy(dev_id, src_addr, dest_addr, size); |
| return rv; |
| } |
| |
| static sw_error_t |
| _hsl_acl_rule_invalid(a_uint32_t dev_id, a_uint32_t addr, a_uint32_t size) |
| { |
| hsl_acl_func_t * p_api; |
| sw_error_t rv; |
| |
| p_api = hsl_acl_ptr_get(dev_id); |
| SW_RTN_ON_NULL(p_api); |
| |
| if (NULL == p_api->acl_rule_invalid) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->acl_rule_invalid(dev_id, addr, size); |
| return rv; |
| } |
| |
| static sw_error_t |
| _hsl_acl_addr_update(a_uint32_t dev_id, a_uint32_t old_addr, |
| a_uint32_t new_addr, a_uint32_t info) |
| { |
| hsl_acl_func_t * p_api; |
| sw_error_t rv; |
| |
| p_api = hsl_acl_ptr_get(dev_id); |
| SW_RTN_ON_NULL(p_api); |
| |
| if (NULL == p_api->acl_addr_update) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->acl_addr_update(dev_id, old_addr, new_addr, info); |
| return rv; |
| } |
| |
| sw_error_t |
| hsl_acl_pool_creat(a_uint32_t dev_id, a_uint32_t blk_nr, a_uint32_t rsc_nr) |
| { |
| HSL_DEV_ID_CHECK(dev_id); |
| |
| acl_pool[dev_id].blk_ent = aos_mem_alloc(blk_nr * (sizeof (hsl_acl_blk_t))); |
| if (NULL == acl_pool[dev_id].blk_ent) |
| { |
| return SW_NO_RESOURCE; |
| } |
| aos_mem_zero(acl_pool[dev_id].blk_ent, blk_nr * (sizeof (hsl_acl_blk_t))); |
| |
| acl_pool[dev_id].used_blk = 1; |
| acl_pool[dev_id].total_blk = blk_nr; |
| acl_pool[dev_id].free_rsc = rsc_nr; |
| |
| acl_pool[dev_id].blk_ent[0].addr = 0; |
| acl_pool[dev_id].blk_ent[0].size = rsc_nr; |
| acl_pool[dev_id].blk_ent[0].status = MEM_FREE; |
| |
| _hsl_acl_blk_dump(dev_id, "hsl_acl_pool_creat after creat"); |
| return SW_OK; |
| } |
| |
| sw_error_t |
| hsl_acl_pool_destroy(a_uint32_t dev_id) |
| { |
| HSL_DEV_ID_CHECK(dev_id); |
| |
| if (NULL == acl_pool[dev_id].blk_ent) |
| { |
| return SW_FAIL; |
| } |
| |
| aos_mem_free(acl_pool[dev_id].blk_ent); |
| aos_mem_zero(&acl_pool[dev_id], sizeof(acl_pool[dev_id])); |
| return SW_OK; |
| } |
| |
| sw_error_t |
| hsl_acl_blk_alloc(a_uint32_t dev_id, a_uint32_t pri, a_uint32_t size, |
| a_uint32_t info, a_uint32_t * addr) |
| { |
| sw_error_t rv; |
| a_uint32_t i; |
| a_uint32_t blk_nr; |
| a_uint32_t p_idx, largest_idx, prev_f_s, largest_f_s; |
| a_uint32_t l_idx, l_nr, l_size, r_idx, r_nr, r_size; |
| |
| HSL_DEV_ID_CHECK(dev_id); |
| |
| _hsl_acl_blk_dump(dev_id, "hsl_acl_blk_alloc before alloc"); |
| |
| if (0 == size) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| if (size > acl_pool[dev_id].free_rsc) |
| { |
| return SW_NO_RESOURCE; |
| } |
| |
| blk_nr = acl_pool[dev_id].used_blk; |
| |
| p_idx = 0; |
| prev_f_s = 0; |
| largest_f_s = 0; |
| largest_idx = 0; |
| |
| for (i = 0; i < blk_nr; i++) |
| { |
| if (MEM_FREE == acl_pool[dev_id].blk_ent[i].status) |
| { |
| prev_f_s += acl_pool[dev_id].blk_ent[i].size; |
| continue; |
| } |
| |
| p_idx = i; |
| if (pri <= acl_pool[dev_id].blk_ent[i].pri) |
| { |
| break; |
| } |
| } |
| |
| if (i == blk_nr) |
| { |
| p_idx = blk_nr; |
| } |
| |
| for (i = p_idx; i < blk_nr; i++) |
| { |
| if (MEM_FREE == acl_pool[dev_id].blk_ent[i].status) |
| { |
| if (largest_f_s < acl_pool[dev_id].blk_ent[i].size) |
| { |
| largest_idx = i; |
| largest_f_s = acl_pool[dev_id].blk_ent[i].size; |
| } |
| continue; |
| } |
| |
| if (pri != acl_pool[dev_id].blk_ent[i].pri) |
| { |
| break; |
| } |
| } |
| |
| if (largest_f_s >= size) |
| { |
| rv = _hsl_acl_blk_alloc(dev_id, largest_idx, pri, size, info, |
| addr); |
| |
| } |
| else if (prev_f_s >= size) |
| { |
| rv = _hsl_acl_blk_left_defrag(dev_id, p_idx, size, A_TRUE, &l_idx, |
| &l_nr, &l_size); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_comb(dev_id, l_idx, l_nr); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_alloc(dev_id, l_idx, pri, size, info, addr); |
| } |
| else if ((acl_pool[dev_id].free_rsc - prev_f_s) >= size) |
| { |
| rv = _hsl_acl_blk_right_defrag(dev_id, p_idx, size, A_TRUE, &r_idx, |
| &r_nr, &r_size); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_comb(dev_id, r_idx, r_nr); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_alloc(dev_id, r_idx, pri, size, info, addr); |
| } |
| else |
| { |
| rv = _hsl_acl_blk_left_defrag(dev_id, p_idx, size, A_FALSE, &l_idx, |
| &l_nr, &l_size); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_right_defrag(dev_id, p_idx, size, A_FALSE, &r_idx, |
| &r_nr, &r_size); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_comb(dev_id, l_idx, (l_nr + r_nr)); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_alloc(dev_id, l_idx, pri, size, info, addr); |
| } |
| |
| _hsl_acl_blk_dump(dev_id, "hsl_acl_blk_alloc after alloc"); |
| return rv; |
| } |
| |
| sw_error_t |
| hsl_acl_blk_free(a_uint32_t dev_id, a_uint32_t addr) |
| { |
| sw_error_t rv; |
| a_uint32_t idx; |
| |
| HSL_DEV_ID_CHECK(dev_id); |
| |
| _hsl_acl_blk_dump(dev_id, "hsl_acl_blk_free before free"); |
| |
| rv = _hsl_acl_blk_loc(dev_id, addr, &idx); |
| SW_RTN_ON_ERROR(rv); |
| |
| acl_pool[dev_id].blk_ent[idx].status = MEM_FREE; |
| acl_pool[dev_id].blk_ent[idx].pri = 0; |
| acl_pool[dev_id].blk_ent[idx].info = 0; |
| acl_pool[dev_id].free_rsc += acl_pool[dev_id].blk_ent[idx].size; |
| |
| rv = _hsl_acl_rule_invalid(dev_id, addr, acl_pool[dev_id].blk_ent[idx].size); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_free_blk_comb(dev_id, idx); |
| SW_RTN_ON_ERROR(rv); |
| |
| _hsl_acl_blk_dump(dev_id, "hsl_acl_blk_free after free"); |
| return SW_OK; |
| } |
| |
| sw_error_t |
| hsl_acl_blk_resize(a_uint32_t dev_id, a_uint32_t addr, a_uint32_t new_size) |
| { |
| sw_error_t rv; |
| a_uint32_t idx, l_idx, l_nr, l_size, r_idx, r_nr, r_size, old_size; |
| |
| HSL_DEV_ID_CHECK(dev_id); |
| |
| _hsl_acl_blk_dump(dev_id, "hsl_acl_blk_resize before resize"); |
| |
| rv = _hsl_acl_blk_loc(dev_id, addr, &idx); |
| SW_RTN_ON_ERROR(rv); |
| |
| if (MEM_USED != acl_pool[dev_id].blk_ent[idx].status) |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| old_size = acl_pool[dev_id].blk_ent[idx].size; |
| if (new_size == old_size) |
| { |
| return SW_OK; |
| } |
| |
| if (0 == new_size) |
| { |
| rv = hsl_acl_blk_free(dev_id, addr); |
| return rv; |
| } |
| |
| /* reduce acl memory block size */ |
| if (new_size < old_size) |
| { |
| rv = _hsl_acl_blk_reduce(dev_id, idx, new_size); |
| _hsl_acl_blk_dump(dev_id, "hsl_acl_blk_resize after resize"); |
| return rv; |
| } |
| |
| /* enlarge acl memory block size */ |
| if (acl_pool[dev_id].free_rsc < (new_size - old_size)) |
| { |
| return SW_NO_RESOURCE; |
| } |
| |
| rv = _hsl_acl_blk_left_defrag(dev_id, idx, new_size - old_size, |
| A_FALSE, &l_idx, &l_nr, &l_size); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_comb(dev_id, l_idx, l_nr); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_loc(dev_id, addr, &idx); |
| SW_RTN_ON_ERROR(rv); |
| |
| if (l_size >= (new_size - old_size)) |
| { |
| rv = _hsl_acl_blk_left_enlarge(dev_id, idx, new_size); |
| _hsl_acl_blk_dump(dev_id, "hsl_acl_blk_resize after resize"); |
| return rv; |
| } |
| |
| if (idx >= (acl_pool[dev_id].used_blk - 1)) |
| { |
| return SW_NO_RESOURCE; |
| } |
| rv = _hsl_acl_blk_right_defrag(dev_id, idx + 1, new_size - old_size, |
| A_FALSE, &r_idx, &r_nr, &r_size); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_comb(dev_id, r_idx, r_nr); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_loc(dev_id, addr, &idx); |
| SW_RTN_ON_ERROR(rv); |
| |
| if (r_size >= (new_size - old_size)) |
| { |
| rv = _hsl_acl_blk_right_enlarge(dev_id, idx, new_size); |
| _hsl_acl_blk_dump(dev_id, "hsl_acl_blk_resize after resize"); |
| return rv; |
| } |
| |
| rv = _hsl_acl_blk_right_enlarge(dev_id, idx, old_size + r_size); |
| SW_RTN_ON_ERROR(rv); |
| |
| rv = _hsl_acl_blk_left_enlarge(dev_id, idx, new_size); |
| _hsl_acl_blk_dump(dev_id, "hsl_acl_blk_resize after resize"); |
| return rv; |
| } |
| |
| sw_error_t |
| hsl_acl_free_rsc_get(a_uint32_t dev_id, a_uint32_t * free_rsc) |
| { |
| HSL_DEV_ID_CHECK(dev_id); |
| |
| * free_rsc = acl_pool[dev_id].free_rsc; |
| return SW_OK; |
| } |
