diff --git a/config/common_base b/config/common_base
index 6b0d1cbbb..00cfb8b22 100644
--- a/config/common_base
+++ b/config/common_base
@@ -550,7 +550,6 @@ CONFIG_RTE_LIBRTE_PMD_ZUC_DEBUG=n
 # Compile PMD for Crypto Scheduler device
 #
 CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER=y
-CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER_DEBUG=n
 
 #
 # Compile PMD for NULL Crypto device
diff --git a/drivers/crypto/scheduler/rte_cryptodev_scheduler.c b/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
index ed574cc18..4fdb111ea 100644
--- a/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
+++ b/drivers/crypto/scheduler/rte_cryptodev_scheduler.c
@@ -9,6 +9,8 @@
 #include "rte_cryptodev_scheduler.h"
 #include "scheduler_pmd_private.h"
 
+int scheduler_logtype_driver;
+
 /** update the scheduler pmd's capability with attaching device's
  *  capability.
  *  For each device to be attached, the scheduler's capability should be
@@ -168,30 +170,30 @@ rte_cryptodev_scheduler_slave_attach(uint8_t scheduler_id, uint8_t slave_id)
 	uint32_t i;
 
 	if (!dev) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->driver_id != cryptodev_driver_id) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->data->dev_started) {
-		CS_LOG_ERR("Illegal operation");
+		CR_SCHED_LOG(ERR, "Illegal operation");
 		return -EBUSY;
 	}
 
 	sched_ctx = dev->data->dev_private;
 	if (sched_ctx->nb_slaves >=
 			RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES) {
-		CS_LOG_ERR("Too many slaves attached");
+		CR_SCHED_LOG(ERR, "Too many slaves attached");
 		return -ENOMEM;
 	}
 
 	for (i = 0; i < sched_ctx->nb_slaves; i++)
 		if (sched_ctx->slaves[i].dev_id == slave_id) {
-			CS_LOG_ERR("Slave already added");
+			CR_SCHED_LOG(ERR, "Slave already added");
 			return -ENOTSUP;
 		}
 
@@ -208,7 +210,7 @@ rte_cryptodev_scheduler_slave_attach(uint8_t scheduler_id, uint8_t slave_id)
 		slave->driver_id = 0;
 		sched_ctx->nb_slaves--;
 
-		CS_LOG_ERR("capabilities update failed");
+		CR_SCHED_LOG(ERR, "capabilities update failed");
 		return -ENOTSUP;
 	}
 
@@ -227,17 +229,17 @@ rte_cryptodev_scheduler_slave_detach(uint8_t scheduler_id, uint8_t slave_id)
 	uint32_t i, slave_pos;
 
 	if (!dev) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->driver_id != cryptodev_driver_id) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->data->dev_started) {
-		CS_LOG_ERR("Illegal operation");
+		CR_SCHED_LOG(ERR, "Illegal operation");
 		return -EBUSY;
 	}
 
@@ -247,12 +249,12 @@ rte_cryptodev_scheduler_slave_detach(uint8_t scheduler_id, uint8_t slave_id)
 		if (sched_ctx->slaves[slave_pos].dev_id == slave_id)
 			break;
 	if (slave_pos == sched_ctx->nb_slaves) {
-		CS_LOG_ERR("Cannot find slave");
+		CR_SCHED_LOG(ERR, "Cannot find slave");
 		return -ENOTSUP;
 	}
 
 	if (sched_ctx->ops.slave_detach(dev, slave_id) < 0) {
-		CS_LOG_ERR("Failed to detach slave");
+		CR_SCHED_LOG(ERR, "Failed to detach slave");
 		return -ENOTSUP;
 	}
 
@@ -265,7 +267,7 @@ rte_cryptodev_scheduler_slave_detach(uint8_t scheduler_id, uint8_t slave_id)
 	sched_ctx->nb_slaves--;
 
 	if (update_scheduler_capability(sched_ctx) < 0) {
-		CS_LOG_ERR("capabilities update failed");
+		CR_SCHED_LOG(ERR, "capabilities update failed");
 		return -ENOTSUP;
 	}
 
@@ -284,17 +286,17 @@ rte_cryptodev_scheduler_mode_set(uint8_t scheduler_id,
 	struct scheduler_ctx *sched_ctx;
 
 	if (!dev) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->driver_id != cryptodev_driver_id) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->data->dev_started) {
-		CS_LOG_ERR("Illegal operation");
+		CR_SCHED_LOG(ERR, "Illegal operation");
 		return -EBUSY;
 	}
 
@@ -307,33 +309,33 @@ rte_cryptodev_scheduler_mode_set(uint8_t scheduler_id,
 	case CDEV_SCHED_MODE_ROUNDROBIN:
 		if (rte_cryptodev_scheduler_load_user_scheduler(scheduler_id,
 				roundrobin_scheduler) < 0) {
-			CS_LOG_ERR("Failed to load scheduler");
+			CR_SCHED_LOG(ERR, "Failed to load scheduler");
 			return -1;
 		}
 		break;
 	case CDEV_SCHED_MODE_PKT_SIZE_DISTR:
 		if (rte_cryptodev_scheduler_load_user_scheduler(scheduler_id,
 				pkt_size_based_distr_scheduler) < 0) {
-			CS_LOG_ERR("Failed to load scheduler");
+			CR_SCHED_LOG(ERR, "Failed to load scheduler");
 			return -1;
 		}
 		break;
 	case CDEV_SCHED_MODE_FAILOVER:
 		if (rte_cryptodev_scheduler_load_user_scheduler(scheduler_id,
 				failover_scheduler) < 0) {
-			CS_LOG_ERR("Failed to load scheduler");
+			CR_SCHED_LOG(ERR, "Failed to load scheduler");
 			return -1;
 		}
 		break;
 	case CDEV_SCHED_MODE_MULTICORE:
 		if (rte_cryptodev_scheduler_load_user_scheduler(scheduler_id,
 				multicore_scheduler) < 0) {
-			CS_LOG_ERR("Failed to load scheduler");
+			CR_SCHED_LOG(ERR, "Failed to load scheduler");
 			return -1;
 		}
 		break;
 	default:
-		CS_LOG_ERR("Not yet supported");
+		CR_SCHED_LOG(ERR, "Not yet supported");
 		return -ENOTSUP;
 	}
 
@@ -347,12 +349,12 @@ rte_cryptodev_scheduler_mode_get(uint8_t scheduler_id)
 	struct scheduler_ctx *sched_ctx;
 
 	if (!dev) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->driver_id != cryptodev_driver_id) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
@@ -369,17 +371,17 @@ rte_cryptodev_scheduler_ordering_set(uint8_t scheduler_id,
 	struct scheduler_ctx *sched_ctx;
 
 	if (!dev) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->driver_id != cryptodev_driver_id) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->data->dev_started) {
-		CS_LOG_ERR("Illegal operation");
+		CR_SCHED_LOG(ERR, "Illegal operation");
 		return -EBUSY;
 	}
 
@@ -397,12 +399,12 @@ rte_cryptodev_scheduler_ordering_get(uint8_t scheduler_id)
 	struct scheduler_ctx *sched_ctx;
 
 	if (!dev) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->driver_id != cryptodev_driver_id) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
@@ -419,25 +421,25 @@ rte_cryptodev_scheduler_load_user_scheduler(uint8_t scheduler_id,
 	struct scheduler_ctx *sched_ctx;
 
 	if (!dev) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->driver_id != cryptodev_driver_id) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->data->dev_started) {
-		CS_LOG_ERR("Illegal operation");
+		CR_SCHED_LOG(ERR, "Illegal operation");
 		return -EBUSY;
 	}
 
 	sched_ctx = dev->data->dev_private;
 
 	if (strlen(scheduler->name) > RTE_CRYPTODEV_NAME_MAX_LEN - 1) {
-		CS_LOG_ERR("Invalid name %s, should be less than "
-				"%u bytes.\n", scheduler->name,
+		CR_SCHED_LOG(ERR, "Invalid name %s, should be less than "
+				"%u bytes.", scheduler->name,
 				RTE_CRYPTODEV_NAME_MAX_LEN);
 		return -EINVAL;
 	}
@@ -446,8 +448,8 @@ rte_cryptodev_scheduler_load_user_scheduler(uint8_t scheduler_id,
 
 	if (strlen(scheduler->description) >
 			RTE_CRYPTODEV_SCHEDULER_DESC_MAX_LEN - 1) {
-		CS_LOG_ERR("Invalid description %s, should be less than "
-				"%u bytes.\n", scheduler->description,
+		CR_SCHED_LOG(ERR, "Invalid description %s, should be less than "
+				"%u bytes.", scheduler->description,
 				RTE_CRYPTODEV_SCHEDULER_DESC_MAX_LEN - 1);
 		return -EINVAL;
 	}
@@ -473,7 +475,7 @@ rte_cryptodev_scheduler_load_user_scheduler(uint8_t scheduler_id,
 		int ret = (*sched_ctx->ops.create_private_ctx)(dev);
 
 		if (ret < 0) {
-			CS_LOG_ERR("Unable to create scheduler private "
+			CR_SCHED_LOG(ERR, "Unable to create scheduler private "
 					"context");
 			return ret;
 		}
@@ -492,12 +494,12 @@ rte_cryptodev_scheduler_slaves_get(uint8_t scheduler_id, uint8_t *slaves)
 	uint32_t nb_slaves = 0;
 
 	if (!dev) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (dev->driver_id != cryptodev_driver_id) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
@@ -525,17 +527,17 @@ rte_cryptodev_scheduler_option_set(uint8_t scheduler_id,
 
 	if (option_type == CDEV_SCHED_OPTION_NOT_SET ||
 			option_type >= CDEV_SCHED_OPTION_COUNT) {
-		CS_LOG_ERR("Invalid option parameter");
+		CR_SCHED_LOG(ERR, "Invalid option parameter");
 		return -EINVAL;
 	}
 
 	if (!option) {
-		CS_LOG_ERR("Invalid option parameter");
+		CR_SCHED_LOG(ERR, "Invalid option parameter");
 		return -EINVAL;
 	}
 
 	if (dev->data->dev_started) {
-		CS_LOG_ERR("Illegal operation");
+		CR_SCHED_LOG(ERR, "Illegal operation");
 		return -EBUSY;
 	}
 
@@ -555,17 +557,17 @@ rte_cryptodev_scheduler_option_get(uint8_t scheduler_id,
 	struct scheduler_ctx *sched_ctx;
 
 	if (!dev) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
 	if (!option) {
-		CS_LOG_ERR("Invalid option parameter");
+		CR_SCHED_LOG(ERR, "Invalid option parameter");
 		return -EINVAL;
 	}
 
 	if (dev->driver_id != cryptodev_driver_id) {
-		CS_LOG_ERR("Operation not supported");
+		CR_SCHED_LOG(ERR, "Operation not supported");
 		return -ENOTSUP;
 	}
 
@@ -575,3 +577,11 @@ rte_cryptodev_scheduler_option_get(uint8_t scheduler_id,
 
 	return (*sched_ctx->ops.option_get)(dev, option_type, option);
 }
+
+RTE_INIT(scheduler_init_log);
+
+static void
+scheduler_init_log(void)
+{
+	scheduler_logtype_driver = rte_log_register("pmd.crypto.scheduler");
+}
diff --git a/drivers/crypto/scheduler/scheduler_failover.c b/drivers/crypto/scheduler/scheduler_failover.c
index 005b16387..ddfb5b815 100644
--- a/drivers/crypto/scheduler/scheduler_failover.c
+++ b/drivers/crypto/scheduler/scheduler_failover.c
@@ -139,7 +139,7 @@ scheduler_start(struct rte_cryptodev *dev)
 	uint16_t i;
 
 	if (sched_ctx->nb_slaves < 2) {
-		CS_LOG_ERR("Number of slaves shall no less than 2");
+		CR_SCHED_LOG(ERR, "Number of slaves shall no less than 2");
 		return -ENOMEM;
 	}
 
@@ -182,7 +182,7 @@ scheduler_config_qp(struct rte_cryptodev *dev, uint16_t qp_id)
 	fo_qp_ctx = rte_zmalloc_socket(NULL, sizeof(*fo_qp_ctx), 0,
 			rte_socket_id());
 	if (!fo_qp_ctx) {
-		CS_LOG_ERR("failed allocate memory for private queue pair");
+		CR_SCHED_LOG(ERR, "failed allocate memory for private queue pair");
 		return -ENOMEM;
 	}
 
diff --git a/drivers/crypto/scheduler/scheduler_multicore.c b/drivers/crypto/scheduler/scheduler_multicore.c
index 91fb06681..d410e69d3 100644
--- a/drivers/crypto/scheduler/scheduler_multicore.c
+++ b/drivers/crypto/scheduler/scheduler_multicore.c
@@ -178,7 +178,8 @@ mc_scheduler_worker(struct rte_cryptodev *dev)
 		}
 	}
 	if (worker_idx == -1) {
-		CS_LOG_ERR("worker on core %u:cannot find worker index!\n", core_id);
+		CR_SCHED_LOG(ERR, "worker on core %u:cannot find worker index!",
+			core_id);
 		return -1;
 	}
 
@@ -313,7 +314,7 @@ scheduler_config_qp(struct rte_cryptodev *dev, uint16_t qp_id)
 	mc_qp_ctx = rte_zmalloc_socket(NULL, sizeof(*mc_qp_ctx), 0,
 			rte_socket_id());
 	if (!mc_qp_ctx) {
-		CS_LOG_ERR("failed allocate memory for private queue pair");
+		CR_SCHED_LOG(ERR, "failed allocate memory for private queue pair");
 		return -ENOMEM;
 	}
 
@@ -339,7 +340,7 @@ scheduler_create_private_ctx(struct rte_cryptodev *dev)
 	mc_ctx = rte_zmalloc_socket(NULL, sizeof(struct mc_scheduler_ctx), 0,
 			rte_socket_id());
 	if (!mc_ctx) {
-		CS_LOG_ERR("failed allocate memory");
+		CR_SCHED_LOG(ERR, "failed allocate memory");
 		return -ENOMEM;
 	}
 
@@ -356,7 +357,7 @@ scheduler_create_private_ctx(struct rte_cryptodev *dev)
 						rte_socket_id(),
 						RING_F_SC_DEQ | RING_F_SP_ENQ);
 			if (!mc_ctx->sched_enq_ring[i]) {
-				CS_LOG_ERR("Cannot create ring for worker %u",
+				CR_SCHED_LOG(ERR, "Cannot create ring for worker %u",
 					   i);
 				goto exit;
 			}
@@ -370,7 +371,7 @@ scheduler_create_private_ctx(struct rte_cryptodev *dev)
 						rte_socket_id(),
 						RING_F_SC_DEQ | RING_F_SP_ENQ);
 			if (!mc_ctx->sched_deq_ring[i]) {
-				CS_LOG_ERR("Cannot create ring for worker %u",
+				CR_SCHED_LOG(ERR, "Cannot create ring for worker %u",
 					   i);
 				goto exit;
 			}
diff --git a/drivers/crypto/scheduler/scheduler_pkt_size_distr.c b/drivers/crypto/scheduler/scheduler_pkt_size_distr.c
index d09e849ae..74129b667 100644
--- a/drivers/crypto/scheduler/scheduler_pkt_size_distr.c
+++ b/drivers/crypto/scheduler/scheduler_pkt_size_distr.c
@@ -258,7 +258,7 @@ scheduler_start(struct rte_cryptodev *dev)
 
 	/* for packet size based scheduler, nb_slaves have to >= 2 */
 	if (sched_ctx->nb_slaves < NB_PKT_SIZE_SLAVES) {
-		CS_LOG_ERR("not enough slaves to start");
+		CR_SCHED_LOG(ERR, "not enough slaves to start");
 		return -1;
 	}
 
@@ -302,7 +302,7 @@ scheduler_stop(struct rte_cryptodev *dev)
 
 		if (ps_qp_ctx->primary_slave.nb_inflight_cops +
 				ps_qp_ctx->secondary_slave.nb_inflight_cops) {
-			CS_LOG_ERR("Some crypto ops left in slave queue");
+			CR_SCHED_LOG(ERR, "Some crypto ops left in slave queue");
 			return -1;
 		}
 	}
@@ -319,7 +319,7 @@ scheduler_config_qp(struct rte_cryptodev *dev, uint16_t qp_id)
 	ps_qp_ctx = rte_zmalloc_socket(NULL, sizeof(*ps_qp_ctx), 0,
 			rte_socket_id());
 	if (!ps_qp_ctx) {
-		CS_LOG_ERR("failed allocate memory for private queue pair");
+		CR_SCHED_LOG(ERR, "failed allocate memory for private queue pair");
 		return -ENOMEM;
 	}
 
@@ -342,7 +342,7 @@ scheduler_create_private_ctx(struct rte_cryptodev *dev)
 	psd_ctx = rte_zmalloc_socket(NULL, sizeof(struct psd_scheduler_ctx), 0,
 			rte_socket_id());
 	if (!psd_ctx) {
-		CS_LOG_ERR("failed allocate memory");
+		CR_SCHED_LOG(ERR, "failed allocate memory");
 		return -ENOMEM;
 	}
 
@@ -362,14 +362,14 @@ scheduler_option_set(struct rte_cryptodev *dev, uint32_t option_type,
 
 	if ((enum rte_cryptodev_schedule_option_type)option_type !=
 			CDEV_SCHED_OPTION_THRESHOLD) {
-		CS_LOG_ERR("Option not supported");
+		CR_SCHED_LOG(ERR, "Option not supported");
 		return -EINVAL;
 	}
 
 	threshold = ((struct rte_cryptodev_scheduler_threshold_option *)
 			option)->threshold;
 	if (!rte_is_power_of_2(threshold)) {
-		CS_LOG_ERR("Threshold is not power of 2");
+		CR_SCHED_LOG(ERR, "Threshold is not power of 2");
 		return -EINVAL;
 	}
 
@@ -388,7 +388,7 @@ scheduler_option_get(struct rte_cryptodev *dev, uint32_t option_type,
 
 	if ((enum rte_cryptodev_schedule_option_type)option_type !=
 			CDEV_SCHED_OPTION_THRESHOLD) {
-		CS_LOG_ERR("Option not supported");
+		CR_SCHED_LOG(ERR, "Option not supported");
 		return -EINVAL;
 	}
 
diff --git a/drivers/crypto/scheduler/scheduler_pmd.c b/drivers/crypto/scheduler/scheduler_pmd.c
index 25d6409f3..5489e9ed0 100644
--- a/drivers/crypto/scheduler/scheduler_pmd.c
+++ b/drivers/crypto/scheduler/scheduler_pmd.c
@@ -82,7 +82,7 @@ cryptodev_scheduler_create(const char *name,
 	dev = rte_cryptodev_pmd_create(name, &vdev->device,
 			&init_params->def_p);
 	if (dev == NULL) {
-		CS_LOG_ERR("driver %s: failed to create cryptodev vdev",
+		CR_SCHED_LOG(ERR, "driver %s: failed to create cryptodev vdev",
 			name);
 		return -EFAULT;
 	}
@@ -101,7 +101,7 @@ cryptodev_scheduler_create(const char *name,
 
 		for (i = 0; i < sched_ctx->nb_wc; i++) {
 			sched_ctx->wc_pool[i] = init_params->wc_pool[i];
-			RTE_LOG(INFO, PMD, "  Worker core[%u]=%u added\n",
+			CR_SCHED_LOG(INFO, "  Worker core[%u]=%u added",
 				i, sched_ctx->wc_pool[i]);
 		}
 	}
@@ -119,7 +119,7 @@ cryptodev_scheduler_create(const char *name,
 			if (scheduler_mode_map[i].val != sched_ctx->mode)
 				continue;
 
-			RTE_LOG(INFO, PMD, "  Scheduling mode = %s\n",
+			CR_SCHED_LOG(INFO, "  Scheduling mode = %s",
 					scheduler_mode_map[i].name);
 			break;
 		}
@@ -132,7 +132,7 @@ cryptodev_scheduler_create(const char *name,
 				sched_ctx->reordering_enabled)
 			continue;
 
-		RTE_LOG(INFO, PMD, "  Packet ordering = %s\n",
+		CR_SCHED_LOG(INFO, "  Packet ordering = %s",
 				scheduler_ordering_map[i].name);
 
 		break;
@@ -147,7 +147,7 @@ cryptodev_scheduler_create(const char *name,
 
 		if (!sched_ctx->init_slave_names[
 				sched_ctx->nb_init_slaves]) {
-			CS_LOG_ERR("driver %s: Insufficient memory",
+			CR_SCHED_LOG(ERR, "driver %s: Insufficient memory",
 					name);
 			return -ENOMEM;
 		}
@@ -169,8 +169,8 @@ cryptodev_scheduler_create(const char *name,
 			0, SOCKET_ID_ANY);
 
 	if (!sched_ctx->capabilities) {
-		RTE_LOG(ERR, PMD, "Not enough memory for capability "
-				"information\n");
+		CR_SCHED_LOG(ERR, "Not enough memory for capability "
+				"information");
 		return -ENOMEM;
 	}
 
@@ -214,7 +214,7 @@ parse_integer_arg(const char *key __rte_unused,
 
 	*i = atoi(value);
 	if (*i < 0) {
-		CS_LOG_ERR("Argument has to be positive.\n");
+		CR_SCHED_LOG(ERR, "Argument has to be positive.");
 		return -EINVAL;
 	}
 
@@ -287,8 +287,8 @@ parse_corelist_arg(const char *key __rte_unused,
 		unsigned int core = strtoul(token, &rval, 10);
 
 		if (core >= RTE_MAX_LCORE) {
-			CS_LOG_ERR("Invalid worker core %u, should be smaller "
-				   "than %u.\n", core, RTE_MAX_LCORE);
+			CR_SCHED_LOG(ERR, "Invalid worker core %u, should be smaller "
+				   "than %u.", core, RTE_MAX_LCORE);
 		}
 		params->wc_pool[params->nb_wc++] = (uint16_t)core;
 		token = (const char *)rval;
@@ -308,8 +308,8 @@ parse_name_arg(const char *key __rte_unused,
 	struct rte_cryptodev_pmd_init_params *params = extra_args;
 
 	if (strlen(value) >= RTE_CRYPTODEV_NAME_MAX_LEN - 1) {
-		CS_LOG_ERR("Invalid name %s, should be less than "
-				"%u bytes.\n", value,
+		CR_SCHED_LOG(ERR, "Invalid name %s, should be less than "
+				"%u bytes.", value,
 				RTE_CRYPTODEV_NAME_MAX_LEN - 1);
 		return -EINVAL;
 	}
@@ -327,7 +327,7 @@ parse_slave_arg(const char *key __rte_unused,
 	struct scheduler_init_params *param = extra_args;
 
 	if (param->nb_slaves >= RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES) {
-		CS_LOG_ERR("Too many slaves.\n");
+		CR_SCHED_LOG(ERR, "Too many slaves.");
 		return -ENOMEM;
 	}
 
@@ -353,7 +353,7 @@ parse_mode_arg(const char *key __rte_unused,
 	}
 
 	if (i == RTE_DIM(scheduler_mode_map)) {
-		CS_LOG_ERR("Unrecognized input.\n");
+		CR_SCHED_LOG(ERR, "Unrecognized input.");
 		return -EINVAL;
 	}
 
@@ -376,7 +376,7 @@ parse_ordering_arg(const char *key __rte_unused,
 	}
 
 	if (i == RTE_DIM(scheduler_ordering_map)) {
-		CS_LOG_ERR("Unrecognized input.\n");
+		CR_SCHED_LOG(ERR, "Unrecognized input.");
 		return -EINVAL;
 	}
 
diff --git a/drivers/crypto/scheduler/scheduler_pmd_ops.c b/drivers/crypto/scheduler/scheduler_pmd_ops.c
index 147dc51e9..874205849 100644
--- a/drivers/crypto/scheduler/scheduler_pmd_ops.c
+++ b/drivers/crypto/scheduler/scheduler_pmd_ops.c
@@ -27,7 +27,7 @@ scheduler_attach_init_slave(struct rte_cryptodev *dev)
 		int status;
 
 		if (!slave_dev) {
-			CS_LOG_ERR("Failed to locate slave dev %s",
+			CR_SCHED_LOG(ERR, "Failed to locate slave dev %s",
 					dev_name);
 			return -EINVAL;
 		}
@@ -36,12 +36,12 @@ scheduler_attach_init_slave(struct rte_cryptodev *dev)
 				scheduler_id, slave_dev->data->dev_id);
 
 		if (status < 0) {
-			CS_LOG_ERR("Failed to attach slave cryptodev %u",
+			CR_SCHED_LOG(ERR, "Failed to attach slave cryptodev %u",
 					slave_dev->data->dev_id);
 			return status;
 		}
 
-		CS_LOG_INFO("Scheduler %s attached slave %s\n",
+		CR_SCHED_LOG(INFO, "Scheduler %s attached slave %s",
 				dev->data->name,
 				sched_ctx->init_slave_names[i]);
 
@@ -102,7 +102,7 @@ update_order_ring(struct rte_cryptodev *dev, uint16_t qp_id)
 		if (snprintf(order_ring_name, RTE_CRYPTODEV_NAME_MAX_LEN,
 			"%s_rb_%u_%u", RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
 			dev->data->dev_id, qp_id) < 0) {
-			CS_LOG_ERR("failed to create unique reorder buffer "
+			CR_SCHED_LOG(ERR, "failed to create unique reorder buffer"
 					"name");
 			return -ENOMEM;
 		}
@@ -111,7 +111,7 @@ update_order_ring(struct rte_cryptodev *dev, uint16_t qp_id)
 				buff_size, rte_socket_id(),
 				RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (!qp_ctx->order_ring) {
-			CS_LOG_ERR("failed to create order ring");
+			CR_SCHED_LOG(ERR, "failed to create order ring");
 			return -ENOMEM;
 		}
 	} else {
@@ -145,18 +145,18 @@ scheduler_pmd_start(struct rte_cryptodev *dev)
 	for (i = 0; i < dev->data->nb_queue_pairs; i++) {
 		ret = update_order_ring(dev, i);
 		if (ret < 0) {
-			CS_LOG_ERR("Failed to update reorder buffer");
+			CR_SCHED_LOG(ERR, "Failed to update reorder buffer");
 			return ret;
 		}
 	}
 
 	if (sched_ctx->mode == CDEV_SCHED_MODE_NOT_SET) {
-		CS_LOG_ERR("Scheduler mode is not set");
+		CR_SCHED_LOG(ERR, "Scheduler mode is not set");
 		return -1;
 	}
 
 	if (!sched_ctx->nb_slaves) {
-		CS_LOG_ERR("No slave in the scheduler");
+		CR_SCHED_LOG(ERR, "No slave in the scheduler");
 		return -1;
 	}
 
@@ -166,7 +166,7 @@ scheduler_pmd_start(struct rte_cryptodev *dev)
 		uint8_t slave_dev_id = sched_ctx->slaves[i].dev_id;
 
 		if ((*sched_ctx->ops.slave_attach)(dev, slave_dev_id) < 0) {
-			CS_LOG_ERR("Failed to attach slave");
+			CR_SCHED_LOG(ERR, "Failed to attach slave");
 			return -ENOTSUP;
 		}
 	}
@@ -174,7 +174,7 @@ scheduler_pmd_start(struct rte_cryptodev *dev)
 	RTE_FUNC_PTR_OR_ERR_RET(*sched_ctx->ops.scheduler_start, -ENOTSUP);
 
 	if ((*sched_ctx->ops.scheduler_start)(dev) < 0) {
-		CS_LOG_ERR("Scheduler start failed");
+		CR_SCHED_LOG(ERR, "Scheduler start failed");
 		return -1;
 	}
 
@@ -186,7 +186,7 @@ scheduler_pmd_start(struct rte_cryptodev *dev)
 
 		ret = (*slave_dev->dev_ops->dev_start)(slave_dev);
 		if (ret < 0) {
-			CS_LOG_ERR("Failed to start slave dev %u",
+			CR_SCHED_LOG(ERR, "Failed to start slave dev %u",
 					slave_dev_id);
 			return ret;
 		}
@@ -386,7 +386,7 @@ scheduler_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
 	if (snprintf(name, RTE_CRYPTODEV_NAME_MAX_LEN,
 			"CRYTO_SCHE PMD %u QP %u",
 			dev->data->dev_id, qp_id) < 0) {
-		CS_LOG_ERR("Failed to create unique queue pair name");
+		CR_SCHED_LOG(ERR, "Failed to create unique queue pair name");
 		return -EFAULT;
 	}
 
@@ -424,14 +424,14 @@ scheduler_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
 	 */
 	ret = scheduler_attach_init_slave(dev);
 	if (ret < 0) {
-		CS_LOG_ERR("Failed to attach slave");
+		CR_SCHED_LOG(ERR, "Failed to attach slave");
 		scheduler_pmd_qp_release(dev, qp_id);
 		return ret;
 	}
 
 	if (*sched_ctx->ops.config_queue_pair) {
 		if ((*sched_ctx->ops.config_queue_pair)(dev, qp_id) < 0) {
-			CS_LOG_ERR("Unable to configure queue pair");
+			CR_SCHED_LOG(ERR, "Unable to configure queue pair");
 			return -1;
 		}
 	}
@@ -498,7 +498,7 @@ scheduler_pmd_session_configure(struct rte_cryptodev *dev,
 		ret = rte_cryptodev_sym_session_init(slave->dev_id, sess,
 					xform, mempool);
 		if (ret < 0) {
-			CS_LOG_ERR("unabled to config sym session");
+			CR_SCHED_LOG(ERR, "unable to config sym session");
 			return ret;
 		}
 	}
diff --git a/drivers/crypto/scheduler/scheduler_pmd_private.h b/drivers/crypto/scheduler/scheduler_pmd_private.h
index 12410b483..d5e602a2f 100644
--- a/drivers/crypto/scheduler/scheduler_pmd_private.h
+++ b/drivers/crypto/scheduler/scheduler_pmd_private.h
@@ -12,25 +12,11 @@
 
 #define PER_SLAVE_BUFF_SIZE			(256)
 
-#define CS_LOG_ERR(fmt, args...)					\
-	RTE_LOG(ERR, CRYPTODEV, "[%s] %s() line %u: " fmt "\n",		\
-		RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),			\
-		__func__, __LINE__, ## args)
-
-#ifdef RTE_LIBRTE_CRYPTO_SCHEDULER_DEBUG
-#define CS_LOG_INFO(fmt, args...)					\
-	RTE_LOG(INFO, CRYPTODEV, "[%s] %s() line %u: " fmt "\n",	\
-		RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),			\
-		__func__, __LINE__, ## args)
-
-#define CS_LOG_DBG(fmt, args...)					\
-	RTE_LOG(DEBUG, CRYPTODEV, "[%s] %s() line %u: " fmt "\n",	\
-		RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),			\
-		__func__, __LINE__, ## args)
-#else
-#define CS_LOG_INFO(fmt, args...)
-#define CS_LOG_DBG(fmt, args...)
-#endif
+extern int scheduler_logtype_driver;
+
+#define CR_SCHED_LOG(level, fmt, args...) \
+	rte_log(RTE_LOG_ ## level, scheduler_logtype_driver,		\
+			"%s() line %u: "fmt "\n", __func__, __LINE__, ##args)
 
 struct scheduler_slave {
 	uint8_t dev_id;
diff --git a/drivers/crypto/scheduler/scheduler_roundrobin.c b/drivers/crypto/scheduler/scheduler_roundrobin.c
index c6e03e219..c7082a64e 100644
--- a/drivers/crypto/scheduler/scheduler_roundrobin.c
+++ b/drivers/crypto/scheduler/scheduler_roundrobin.c
@@ -175,7 +175,7 @@ scheduler_config_qp(struct rte_cryptodev *dev, uint16_t qp_id)
 	rr_qp_ctx = rte_zmalloc_socket(NULL, sizeof(*rr_qp_ctx), 0,
 			rte_socket_id());
 	if (!rr_qp_ctx) {
-		CS_LOG_ERR("failed allocate memory for private queue pair");
+		CR_SCHED_LOG(ERR, "failed allocate memory for private queue pair");
 		return -ENOMEM;
 	}
 
