From: Longfang Liu <liulongfang@huawei.com> After the uadk framework updates the heterogeneous scheduling function, the internal implementation functions of the ECC algorithm need to be adapted and modified. Signed-off-by: Longfang Liu <liulongfang@huawei.com> --- drv/hisi_hpre.c | 5 +- include/drv/wd_ecc_drv.h | 5 +- wd_ecc.c | 164 ++++++++++++++++----------------------- 3 files changed, 69 insertions(+), 105 deletions(-) diff --git a/drv/hisi_hpre.c b/drv/hisi_hpre.c index d8f3b53..e9948a8 100644 --- a/drv/hisi_hpre.c +++ b/drv/hisi_hpre.c @@ -1577,7 +1577,7 @@ static int u_is_in_p(struct wd_ecc_msg *msg) static int ecc_prepare_in(struct wd_ecc_msg *msg, struct hisi_hpre_sqe *hw_msg, void **data) { - struct hisi_hpre_ctx *hpre_ctx = (struct hisi_hpre_ctx *)msg->drv_cfg; + struct hisi_hpre_ctx *hpre_ctx = (struct hisi_hpre_ctx *)msg->priv; int ret = -WD_EINVAL; switch (msg->req.op_type) { @@ -2873,10 +2873,7 @@ static int hpre_ecc_get_extend_ops(void *ops) if (!ecc_ops) return -WD_EINVAL; - ecc_ops->params = NULL; - ecc_ops->sess_init = NULL; ecc_ops->eops_params_cfg = ecc_sess_eops_params_cfg; - ecc_ops->sess_uninit = NULL; return WD_SUCCESS; } diff --git a/include/drv/wd_ecc_drv.h b/include/drv/wd_ecc_drv.h index 899f593..471c96b 100644 --- a/include/drv/wd_ecc_drv.h +++ b/include/drv/wd_ecc_drv.h @@ -56,7 +56,7 @@ struct wd_ecc_msg { __u16 key_bytes; /* key bytes */ __u8 curve_id; /* Ec curve denoted by enum wd_ecc_curve_type */ __u8 result; /* alg op error code */ - void *drv_cfg; /* internal driver configuration */ + void *priv; /* internal driver configuration */ __u8 *rsv_out; /* reserved output data pointer */ }; @@ -180,11 +180,8 @@ struct wd_ecc_out { }; struct wd_ecc_extend_ops { - void *params; /* the params are passed to the following ops */ void (*eops_params_cfg)(struct wd_ecc_sess_setup *setup, struct wd_ecc_curve *cv, void *priv); - int (*sess_init)(struct wd_alg_driver *drv, void **params); - void (*sess_uninit)(struct wd_alg_driver *drv, void *params); }; struct wd_ecc_msg *wd_ecc_get_msg(__u32 idx, __u32 tag); diff --git a/wd_ecc.c b/wd_ecc.c index b7e5481..75507e8 100644 --- a/wd_ecc.c +++ b/wd_ecc.c @@ -50,7 +50,6 @@ struct wd_ecc_sess { __u32 key_size; struct wd_ecc_key key; struct wd_ecc_sess_setup setup; - struct wd_ecc_extend_ops eops; void *sched_key; struct wd_mm_ops mm_ops; enum wd_mem_type mm_type; @@ -68,7 +67,6 @@ static struct wd_ecc_setting { struct wd_ctx_config_internal config; struct wd_sched sched; struct wd_async_msg_pool pool; - struct wd_alg_driver *driver; void *priv; void *dlhandle; void *dlh_list; @@ -113,19 +111,15 @@ static void wd_ecc_close_driver(int init_type) if (!wd_ecc_setting.dlhandle) return; - wd_release_drv(wd_ecc_setting.driver); dlclose(wd_ecc_setting.dlhandle); wd_ecc_setting.dlhandle = NULL; #else - wd_release_drv(wd_ecc_setting.driver); hisi_hpre_remove(); #endif } static int wd_ecc_open_driver(int init_type) { - struct wd_alg_driver *driver = NULL; - const char *alg_name = "sm2"; #ifndef WD_STATIC_DRV char lib_path[PATH_MAX]; int ret; @@ -159,14 +153,6 @@ static int wd_ecc_open_driver(int init_type) if (init_type == WD_TYPE_V2) return WD_SUCCESS; #endif - driver = wd_request_drv(alg_name, false); - if (!driver) { - wd_ecc_close_driver(WD_TYPE_V1); - WD_ERR("failed to get %s driver support\n", alg_name); - return -WD_EINVAL; - } - - wd_ecc_setting.driver = driver; return WD_SUCCESS; } @@ -210,16 +196,10 @@ static int wd_ecc_common_init(struct wd_ctx_config *config, struct wd_sched *sch if (ret < 0) goto out_clear_sched; - ret = wd_alg_init_driver(&wd_ecc_setting.config, - wd_ecc_setting.driver, - &wd_ecc_setting.priv); - if (ret) - goto out_clear_pool; + wd_ecc_setting.priv = STATUS_ENABLE; return WD_SUCCESS; -out_clear_pool: - wd_uninit_async_request_pool(&wd_ecc_setting.pool); out_clear_sched: wd_clear_sched(&wd_ecc_setting.sched); out_clear_ctx_config: @@ -239,9 +219,7 @@ static int wd_ecc_common_uninit(void) /* unset config, sched, driver */ wd_clear_sched(&wd_ecc_setting.sched); - wd_alg_uninit_driver(&wd_ecc_setting.config, - wd_ecc_setting.driver, - &wd_ecc_setting.priv); + wd_ecc_setting.priv = NULL; return WD_SUCCESS; } @@ -268,10 +246,22 @@ int wd_ecc_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_close_driver; + ret = wd_ctx_drv_config("sm2", &wd_ecc_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_ecc_setting.config); + if (ret) + goto out_drv_deconfig; + wd_alg_set_init(&wd_ecc_setting.status); return WD_SUCCESS; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_ecc_setting.config); +out_uninit_nolock: + wd_ecc_common_uninit(); out_close_driver: wd_ecc_close_driver(WD_TYPE_V1); out_clear_init: @@ -283,6 +273,8 @@ void wd_ecc_uninit(void) { int ret; + wd_alg_uninit_driver_nw(&wd_ecc_setting.config); + wd_ctx_drv_deconfig(&wd_ecc_setting.config); ret = wd_ecc_common_uninit(); if (ret) return; @@ -323,37 +315,26 @@ int wd_ecc_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para while (ret) { memset(&wd_ecc_setting.config, 0, sizeof(struct wd_ctx_config_internal)); - /* Get alg driver and dev name */ - wd_ecc_setting.driver = wd_alg_drv_bind(task_type, alg); - if (!wd_ecc_setting.driver) { - WD_ERR("failed to bind a valid driver!\n"); - ret = -WD_EINVAL; - goto out_dlopen; - } - + /* Init ctx param and prepare for ctx request */ ecc_ctx_params.ctx_set_num = ecc_ctx_num; - ret = wd_ctx_param_init(&ecc_ctx_params, ctx_params, - wd_ecc_setting.driver, WD_ECC_TYPE, WD_EC_OP_MAX); + ret = wd_ctx_param_init_nw(&ecc_ctx_params, ctx_params, + alg, task_type, WD_ECC_TYPE, WD_EC_OP_MAX); if (ret) { - if (ret == -WD_EAGAIN) { - wd_disable_drv(wd_ecc_setting.driver); - wd_alg_drv_unbind(wd_ecc_setting.driver); + if (ret == -WD_EAGAIN) continue; - } + goto out_driver; } (void)strcpy(wd_ecc_init_attrs.alg, alg); wd_ecc_init_attrs.sched_type = sched_type; - wd_ecc_init_attrs.driver = wd_ecc_setting.driver; + wd_ecc_init_attrs.task_type = task_type; wd_ecc_init_attrs.ctx_params = &ecc_ctx_params; wd_ecc_init_attrs.alg_init = wd_ecc_common_init; wd_ecc_init_attrs.alg_poll_ctx = wd_ecc_poll_ctx; ret = wd_alg_attrs_init(&wd_ecc_init_attrs); if (ret) { if (ret == -WD_ENODEV) { - wd_disable_drv(wd_ecc_setting.driver); - wd_alg_drv_unbind(wd_ecc_setting.driver); wd_ctx_param_uninit(&ecc_ctx_params); continue; } @@ -362,16 +343,27 @@ int wd_ecc_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para } } + ret = wd_ctx_drv_config(alg, &wd_ecc_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_ecc_setting.config); + if (ret) + goto out_drv_deconfig; + wd_alg_set_init(&wd_ecc_setting.status); wd_ctx_param_uninit(&ecc_ctx_params); return WD_SUCCESS; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_ecc_setting.config); +out_uninit_nolock: + wd_ecc_common_uninit(); + wd_alg_attrs_uninit(&wd_ecc_init_attrs); out_params_uninit: wd_ctx_param_uninit(&ecc_ctx_params); out_driver: - wd_alg_drv_unbind(wd_ecc_setting.driver); -out_dlopen: wd_ecc_close_driver(WD_TYPE_V2); out_clear_init: wd_alg_clear_init(&wd_ecc_setting.status); @@ -382,12 +374,12 @@ void wd_ecc_uninit2(void) { int ret; + wd_ctx_drv_deconfig(&wd_ecc_setting.config); ret = wd_ecc_common_uninit(); if (ret) return; wd_alg_attrs_uninit(&wd_ecc_init_attrs); - wd_alg_drv_unbind(wd_ecc_setting.driver); wd_ecc_close_driver(WD_TYPE_V2); wd_alg_clear_init(&wd_ecc_setting.status); } @@ -1174,39 +1166,34 @@ static void del_sess_key(struct wd_ecc_sess *sess) } } -static int wd_ecc_sess_eops_init(struct wd_ecc_sess *sess) +static void wd_ecc_sess_eops_cfg(struct wd_ecc_sess_setup *setup, + struct wd_ecc_sess *sess) { - int ret; + struct wd_ctx_config_internal *config = &wd_ecc_setting.config; + struct wd_ecc_extend_ops *eops; + struct wd_alg_driver *drv; + int ret, valide = 0; + __u32 i; + + for (i = 0; i < config->ctx_num; i++) { + drv = config->ctxs[i].drv; + if (!drv->get_extend_ops) + continue; + + ret = drv->get_extend_ops(config->ctxs[i].extend_ops); + if (!ret && config->ctxs[i].extend_ops) { + valide++; + eops = config->ctxs[i].extend_ops; + + if (!eops->eops_params_cfg) + continue; - if (sess->eops.sess_init) { - if (!sess->eops.sess_uninit) { - WD_ERR("failed to get extend ops in session!\n"); - return -WD_EINVAL; - } - ret = sess->eops.sess_init(wd_ecc_setting.driver, &sess->eops.params); - if (ret) { - WD_ERR("failed to init extend ops params in session!\n"); - return ret; + eops->eops_params_cfg(setup, sess->key.cv, config->ctxs[i].drv_priv); } } - return WD_SUCCESS; -} -static void wd_ecc_sess_eops_uninit(struct wd_ecc_sess *sess) -{ - if (sess->eops.sess_uninit) { - sess->eops.sess_uninit(wd_ecc_setting.driver, sess->eops.params); - sess->eops.params = NULL; - } -} - -static void wd_ecc_sess_eops_cfg(struct wd_ecc_sess_setup *setup, - struct wd_ecc_sess *sess) -{ - if (sess->eops.sess_init && sess->eops.eops_params_cfg) { - /* the config result does not impact task sucesss or failure */ - sess->eops.eops_params_cfg(setup, sess->key.cv, wd_ecc_setting.priv); - } + if (!valide) + WD_ERR("failed to get ecc extend ops!\n"); } handle_t wd_ecc_alloc_sess(struct wd_ecc_sess_setup *setup) @@ -1217,7 +1204,7 @@ handle_t wd_ecc_alloc_sess(struct wd_ecc_sess_setup *setup) if (setup_param_check(setup)) return (handle_t)0; - ret = wd_drv_alg_support(setup->alg, wd_ecc_setting.driver); + ret = wd_drv_alg_support(setup->alg, &wd_ecc_setting.config); if (!ret) { WD_ERR("failed to support this algorithm: %s!\n", setup->alg); return (handle_t)0; @@ -1239,24 +1226,10 @@ handle_t wd_ecc_alloc_sess(struct wd_ecc_sess_setup *setup) memcpy(&sess->mm_ops, &setup->mm_ops, sizeof(struct wd_mm_ops)); sess->mm_type = setup->mm_type; - if (wd_ecc_setting.driver->get_extend_ops) { - ret = wd_ecc_setting.driver->get_extend_ops(&sess->eops); - if (ret) { - WD_ERR("failed to get ecc sess extend ops!\n"); - goto sess_err; - } - } - - ret = wd_ecc_sess_eops_init(sess); - if (ret) { - WD_ERR("failed to init ecc sess extend eops!\n"); - goto sess_err; - } - ret = create_sess_key(setup, sess); if (ret) { WD_ERR("failed to create ecc sess keys!\n"); - goto eops_err; + goto sess_err; } wd_ecc_sess_eops_cfg(setup, sess); @@ -1273,8 +1246,6 @@ handle_t wd_ecc_alloc_sess(struct wd_ecc_sess_setup *setup) sched_err: del_sess_key(sess); -eops_err: - wd_ecc_sess_eops_uninit(sess); sess_err: free(sess); return (handle_t)0; @@ -1292,7 +1263,6 @@ void wd_ecc_free_sess(handle_t sess) if (sess_t->sched_key) free(sess_t->sched_key); del_sess_key(sess_t); - wd_ecc_sess_eops_uninit(sess_t); free(sess_t); } @@ -1569,7 +1539,6 @@ static int fill_ecc_msg(struct wd_ecc_msg *msg, struct wd_ecc_req *req, msg->mm_type = sess->mm_type; msg->key_bytes = sess->key_size; msg->curve_id = sess->setup.cv.cfg.id; - msg->drv_cfg = sess->eops.params; msg->result = WD_EINVAL; switch (req->op_type) { @@ -1649,8 +1618,9 @@ int wd_do_ecc_sync(handle_t h_sess, struct wd_ecc_req *req) if (unlikely(ret)) return ret; - msg_handle.send = wd_ecc_setting.driver->send; - msg_handle.recv = wd_ecc_setting.driver->recv; + msg_handle.send = ctx->drv->send; + msg_handle.recv = ctx->drv->recv; + msg.priv = ctx->drv_priv; pthread_spin_lock(&ctx->lock); ret = wd_handle_msg_sync(&msg_handle, ctx->ctx, &msg, &balance, @@ -2328,7 +2298,6 @@ int wd_do_ecc_async(handle_t sess, struct wd_ecc_req *req) return ret; ctx = config->ctxs + idx; - mid = wd_get_msg_from_pool(&wd_ecc_setting.pool, idx, (void **)&msg); if (unlikely(mid < 0)) { WD_ERR("failed to get msg from pool!\n"); @@ -2338,9 +2307,10 @@ int wd_do_ecc_async(handle_t sess, struct wd_ecc_req *req) ret = fill_ecc_msg(msg, req, (struct wd_ecc_sess *)sess); if (ret) goto fail_with_msg; + msg->priv = ctx->drv_priv; msg->tag = mid; - ret = wd_ecc_setting.driver->send(ctx->ctx, msg); + ret = ctx->drv->send(ctx->ctx, msg); if (unlikely(ret)) { if (ret != -WD_EBUSY) WD_ERR("failed to send ecc BD, hw is err!\n"); @@ -2390,7 +2360,7 @@ int wd_ecc_poll_ctx(__u32 idx, __u32 expt, __u32 *count) ctx = config->ctxs + idx; do { - ret = wd_ecc_setting.driver->recv(ctx->ctx, &recv_msg); + ret = ctx->drv->recv(ctx->ctx, &recv_msg); if (ret == -WD_EAGAIN) { return ret; } else if (ret < 0) { -- 2.43.0