// SPDX-License-Identifier: GPL-2.0
  /*
   * Copyright (C) 2018 NXP
   *
   */
  
  #include <keys/secure-type.h>
  #include "securekey_desc.h"
  
  /* key modifier for blob encapsulation & decapsulation descriptor */
  u8 key_modifier[] = "SECURE_KEY";
  u32 key_modifier_len = 10;
  
  void caam_sk_rng_desc(struct sk_req *skreq, struct sk_desc *skdesc)
  {
  	struct sk_fetch_rnd_data *fetch_rnd_data = NULL;
  	struct random_desc *rnd_desc = NULL;
  	size_t len = 0;
  	u32 *desc = skreq->hwdesc;
  
  	init_job_desc(desc, 0);
  
  	fetch_rnd_data = &skreq->req_u.sk_fetch_rnd_data;
  	rnd_desc = &skdesc->dma_u.random_descp;
  	len = fetch_rnd_data->key_len;
  
  	/* command 0x82500000 */
  	append_cmd(desc, CMD_OPERATION | OP_TYPE_CLASS1_ALG |
  			OP_ALG_ALGSEL_RNG);
  	/* command 0x60340000 | len */
  	append_cmd(desc, CMD_FIFO_STORE | FIFOST_TYPE_RNGSTORE | len);
  	append_ptr(desc, rnd_desc->rnd_data);
  }
  
  void caam_sk_redblob_encap_desc(struct sk_req *skreq, struct sk_desc *skdesc)
  {
  	struct redblob_encap_desc *red_blob_desc =
  					&skdesc->dma_u.redblob_encapdesc;
  	struct sk_red_blob_encap *red_blob_req =
  					&skreq->req_u.sk_red_blob_encap;
  	u32 *desc = skreq->hwdesc;
  
  	init_job_desc(desc, 0);
  
  	/* Load class 2 key with key modifier. */
  	append_key_as_imm(desc, key_modifier, key_modifier_len,
  			  key_modifier_len, CLASS_2 | KEY_DEST_CLASS_REG);
  
  	/* SEQ IN PTR Command. */
  	append_seq_in_ptr(desc, red_blob_desc->in_data, red_blob_req->data_sz,
  			  0);
  
  	/* SEQ OUT PTR Command. */
  	append_seq_out_ptr(desc, red_blob_desc->redblob,
  			   red_blob_req->redblob_sz, 0);
  
  	/* RedBlob encapsulation PROTOCOL Command. */
  	append_operation(desc, OP_TYPE_ENCAP_PROTOCOL | OP_PCLID_BLOB);
  }
  
  /* void caam_sk_redblob_decap_desc(struct sk_req *skreq, struct sk_desc *skdesc)
   * brief CAAM Descriptor creator from redblob to plaindata.
   * param[in] skreq Pointer to secure key request structure
   * param[in] skdesc Pointer to secure key descriptor structure
   */
  void caam_sk_redblob_decap_desc(struct sk_req *skreq, struct sk_desc *skdesc)
  {
  	struct redblob_decap_desc *red_blob_desc =
  					&skdesc->dma_u.redblob_decapdesc;
  	struct sk_red_blob_decap *red_blob_req =
  					&skreq->req_u.sk_red_blob_decap;
  	u32 *desc = skreq->hwdesc;
  
  	init_job_desc(desc, 0);
  
  	/* Load class 2 key with key modifier. */
  	append_key_as_imm(desc, key_modifier, key_modifier_len,
  			  key_modifier_len, CLASS_2 | KEY_DEST_CLASS_REG);
  
  	/* SEQ IN PTR Command. */
  	append_seq_in_ptr(desc, red_blob_desc->redblob,
  			  red_blob_req->redblob_sz, 0);
  
  	/* SEQ OUT PTR Command. */
  	append_seq_out_ptr(desc, red_blob_desc->out_data,
  			   red_blob_req->data_sz, 0);
  
  	/* RedBlob decapsulation PROTOCOL Command. */
  	append_operation(desc, OP_TYPE_DECAP_PROTOCOL | OP_PCLID_BLOB);
  }
  
  /* int caam_sk_get_random_map(struct device *dev, struct sk_req *req,
   *			      struct sk_desc *skdesc)
   * brief DMA map the buffer virtual pointers to physical address.
   * param[in] dev Pointer to job ring device structure
   * param[in] req Pointer to secure key request structure
   * param[in] skdesc Pointer to secure key descriptor structure
   * return 0 on success, error value otherwise.
   */
  int caam_sk_get_random_map(struct device *dev, struct sk_req *req,
  			   struct sk_desc *skdesc)
  {
  	struct sk_fetch_rnd_data *fetch_rnd_data;
  	struct random_desc *rnd_desc;
  
  	fetch_rnd_data = &req->req_u.sk_fetch_rnd_data;
  	rnd_desc = &skdesc->dma_u.random_descp;
  
  	rnd_desc->rnd_data = dma_map_single(dev, fetch_rnd_data->data,
  				fetch_rnd_data->key_len, DMA_FROM_DEVICE);
  
  	if (dma_mapping_error(dev, rnd_desc->rnd_data)) {
  		dev_err(dev, "Unable to map memory
  ");
  		goto sk_random_map_fail;
  	}
  	return 0;
  
  sk_random_map_fail:
  	return -ENOMEM;
  }
  
  /* int caam_sk_redblob_encap_map(struct device *dev, struct sk_req *req,
   *					struct sk_desc *skdesc)
   * brief DMA map the buffer virtual pointers to physical address.
   * param[in] dev Pointer to job ring device structure
   * param[in] req Pointer to secure key request structure
   * param[in] skdesc Pointer to secure key descriptor structure
   * return 0 on success, error value otherwise.
   */
  int caam_sk_redblob_encap_map(struct device *dev, struct sk_req *req,
  			      struct sk_desc *skdesc)
  {
  	struct sk_red_blob_encap *red_blob_encap;
  	struct redblob_encap_desc *red_blob_desc;
  
  	red_blob_encap = &req->req_u.sk_red_blob_encap;
  	red_blob_desc = &skdesc->dma_u.redblob_encapdesc;
  
  	red_blob_desc->in_data = dma_map_single(dev, red_blob_encap->data,
  					red_blob_encap->data_sz, DMA_TO_DEVICE);
  	if (dma_mapping_error(dev, red_blob_desc->in_data)) {
  		dev_err(dev, "Unable to map memory
  ");
  		goto sk_data_fail;
  	}
  
  	red_blob_desc->redblob = dma_map_single(dev, red_blob_encap->redblob,
  				red_blob_encap->redblob_sz, DMA_FROM_DEVICE);
  	if (dma_mapping_error(dev, red_blob_desc->redblob)) {
  		dev_err(dev, "Unable to map memory
  ");
  		goto sk_redblob_fail;
  	}
  
  	return 0;
  
  sk_redblob_fail:
  	dma_unmap_single(dev, red_blob_desc->in_data, red_blob_encap->data_sz,
  			 DMA_TO_DEVICE);
  sk_data_fail:
  	return -ENOMEM;
  }
  
  /* static int caam_sk_redblob_decap_map(struct device *dev,
   *					    struct sk_req *req,
   *					    struct sk_desc *skdesc)
   * brief DMA map the buffer virtual pointers to physical address.
   * param[in] dev Pointer to job ring device structure
   * param[in] req Pointer to secure key request structure
   * param[in] skdesc Pointer to secure key descriptor structure
   * return 0 on success, error value otherwise.
   */
  int caam_sk_redblob_decap_map(struct device *dev, struct sk_req *req,
  			      struct sk_desc *skdesc)
  {
  	struct sk_red_blob_decap *red_blob_decap;
  	struct redblob_decap_desc *red_blob_desc;
  
  	red_blob_decap = &req->req_u.sk_red_blob_decap;
  	red_blob_desc = &skdesc->dma_u.redblob_decapdesc;
  
  	red_blob_desc->redblob = dma_map_single(dev, red_blob_decap->redblob,
  				red_blob_decap->redblob_sz, DMA_TO_DEVICE);
  	if (dma_mapping_error(dev, red_blob_desc->redblob)) {
  		dev_err(dev, "Unable to map memory
  ");
  		goto sk_redblob_fail;
  	}
  
  	red_blob_desc->out_data = dma_map_single(dev, red_blob_decap->data,
  				red_blob_decap->data_sz, DMA_FROM_DEVICE);
  	if (dma_mapping_error(dev, red_blob_desc->out_data)) {
  		dev_err(dev, "Unable to map memory
  ");
  		goto sk_data_fail;
  	}
  
  	return 0;
  
  sk_data_fail:
  	dma_unmap_single(dev, red_blob_desc->redblob,
  			 red_blob_decap->redblob_sz, DMA_TO_DEVICE);
  sk_redblob_fail:
  	return -ENOMEM;
  }
  
  /* @fn void securekey_unmap(struct device *dev,
   *			    struct sk_desc *skdesc, struct sk_req *req)
   * @brief DMA unmap the buffer pointers.
   * @param[in] dev Pointer to job ring device structure
   * @param[in] skdesc Pointer to secure key descriptor structure
   * @param[in] req Pointer to secure key request structure
   */
  void securekey_unmap(struct device *dev,
  		     struct sk_desc *skdesc, struct sk_req *req)
  {
  
  	switch (req->type) {
  	case sk_get_random:
  		{
  			struct sk_fetch_rnd_data *fetch_rnd_data;
  			struct random_desc *rnd_desc;
  
  			fetch_rnd_data = &req->req_u.sk_fetch_rnd_data;
  			rnd_desc = &skdesc->dma_u.random_descp;
  
  			/* Unmap Descriptor buffer pointers. */
  			dma_unmap_single(dev, rnd_desc->rnd_data,
  					 fetch_rnd_data->key_len,
  					 DMA_FROM_DEVICE);
  			break;
  		}
  	case sk_red_blob_enc:
  		{
  			struct sk_red_blob_encap *red_blob_encap;
  			struct redblob_encap_desc *red_blob_desc;
  
  			red_blob_encap = &req->req_u.sk_red_blob_encap;
  			red_blob_desc = &skdesc->dma_u.redblob_encapdesc;
  
  			/* Unmap Descriptor buffer pointers. */
  			dma_unmap_single(dev, red_blob_desc->in_data,
  					 red_blob_encap->data_sz,
  					 DMA_TO_DEVICE);
  
  			dma_unmap_single(dev, red_blob_desc->redblob,
  					 red_blob_encap->redblob_sz,
  					 DMA_FROM_DEVICE);
  
  			break;
  		}
  	case sk_red_blob_dec:
  		{
  			struct sk_red_blob_decap *red_blob_decap;
  			struct redblob_decap_desc *red_blob_desc;
  
  			red_blob_decap = &req->req_u.sk_red_blob_decap;
  			red_blob_desc = &skdesc->dma_u.redblob_decapdesc;
  
  			/* Unmap Descriptor buffer pointers. */
  			dma_unmap_single(dev, red_blob_desc->redblob,
  					 red_blob_decap->redblob_sz,
  					 DMA_TO_DEVICE);
  
  			dma_unmap_single(dev, red_blob_desc->out_data,
  					 red_blob_decap->data_sz,
  					 DMA_FROM_DEVICE);
  
  			break;
  		}
  	default:
  		dev_err(dev, "Unable to find request type
  ");
  		break;
  	}
  	kfree(skdesc);
  }
  
  /*  int caam_securekey_desc_init(struct device *dev, struct sk_req *req)
   *  brief CAAM Descriptor creator for secure key operations.
   *  param[in] dev Pointer to job ring device structure
   *  param[in] req Pointer to secure key request structure
   *  return 0 on success, error value otherwise.
   */
  int caam_securekey_desc_init(struct device *dev, struct sk_req *req)
  {
  	struct sk_desc *skdesc = NULL;
  	int ret = 0;
  
  	switch (req->type) {
  	case sk_get_random:
  		{
  			skdesc = kmalloc(sizeof(*skdesc), GFP_DMA);
  			if (!skdesc) {
  				ret = -ENOMEM;
  				goto out;
  			}
  			skdesc->req_type = req->type;
  
  			if (caam_sk_get_random_map(dev, req, skdesc)) {
  				dev_err(dev, "caam get_random map fail
  ");
  				ret = -ENOMEM;
  				goto out;
  			}
  			caam_sk_rng_desc(req, skdesc);
  			break;
  		}
  	case sk_red_blob_enc:
  		{
  			skdesc = kmalloc(sizeof(*skdesc), GFP_DMA);
  			if (!skdesc) {
  				ret = -ENOMEM;
  				goto out;
  			}
  
  			skdesc->req_type = req->type;
  
  			if (caam_sk_redblob_encap_map(dev, req, skdesc)) {
  				dev_err(dev, "caam redblob_encap map fail
  ");
  				ret = -ENOMEM;
  				goto out;
  			}
  
  			/* Descriptor function to create redblob from data. */
  			caam_sk_redblob_encap_desc(req, skdesc);
  			break;
  		}
  
  	case sk_red_blob_dec:
  		{
  			skdesc = kmalloc(sizeof(*skdesc), GFP_DMA);
  			if (!skdesc) {
  				ret = -ENOMEM;
  				goto out;
  			}
  
  			skdesc->req_type = req->type;
  
  			if (caam_sk_redblob_decap_map(dev, req, skdesc)) {
  				dev_err(dev, "caam redblob_decap map fail
  ");
  				ret = -ENOMEM;
  				goto out;
  			}
  
  			/* Descriptor function to decap data from redblob. */
  			caam_sk_redblob_decap_desc(req, skdesc);
  			break;
  		}
  	default:
  		pr_debug("Unknown request type
  ");
  		ret = -EINVAL;
  		goto out;
  	}
  
  	req->desc_pointer = (void *)skdesc;
  
  out:
  	return ret;
  }
  
  /* static void caam_op_done (struct device *dev, u32 *desc, u32 ret,
   *			     void *context)
   * brief callback function to be called when descriptor executed.
   * param[in] dev Pointer to device structure
   * param[in] desc descriptor pointer
   * param[in] ret return status of Job submitted
   * param[in] context void pointer
   */
  static void caam_op_done(struct device *dev, u32 *desc, u32 ret,
  			 void *context)
  {
  	struct sk_req *req = context;
  
  	if (ret) {
  		dev_err(dev, "caam op done err: %x
  ", ret);
  		/* print the error source name. */
  		caam_jr_strstatus(dev, ret);
  	}
  	/* Call securekey_unmap function for unmapping the buffer pointers. */
  	securekey_unmap(dev, req->desc_pointer, req);
  
  	req->ret = ret;
  	complete(&req->comp);
  }
  
  
  /*  static int sk_job_submit(struct device *jrdev, struct sk_req *req)
   *  brief Enqueue a Job descriptor to Job ring and wait until SEC returns.
   *  param[in] jrdev Pointer to job ring device structure
   *  param[in] req Pointer to secure key request structure
   *  return 0 on success, error value otherwise.
   */
  static int sk_job_submit(struct device *jrdev, struct sk_req *req)
  {
  	int ret;
  
  	init_completion(&req->comp);
  
  	/* caam_jr_enqueue function for Enqueue a job descriptor */
  	ret = caam_jr_enqueue(jrdev, req->hwdesc, caam_op_done, req);

  	if (ret == -EINPROGRESS)

  		wait_for_completion_interruptible(&req->comp);
  
  	ret = req->ret;
  	return ret;
  }
  
  /* caam_get_random(struct secure_key_payload *p,  enum sk_req_type fetch_rnd,
   *		   struct device *dev)
   * Create the random number of the specified length using CAAM block
   * param[in]: out pointer to place the random bytes
   * param[in]: length for the random data bytes.
   * param[in]: dev Pointer to job ring device structure
   * If operation is successful return 0, otherwise error.
   */
  int caam_get_random(struct secure_key_payload *p,  enum sk_req_type fetch_rnd,
  		    struct device *dev)
  {
  	struct sk_fetch_rnd_data *fetch_rnd_data = NULL;
  	struct sk_req *req = NULL;
  	int ret = 0;
  	void *temp = NULL;
  
  	req = kmalloc(sizeof(struct sk_req), GFP_DMA);
  	if (!req) {
  		ret = -ENOMEM;
  		goto out;
  	}
  
  	req->type = fetch_rnd;
  	fetch_rnd_data = &(req->req_u.sk_fetch_rnd_data);
  
  	/* initialise with key length */
  	fetch_rnd_data->key_len = p->key_len;
  
  	temp = kmalloc(fetch_rnd_data->key_len, GFP_DMA);
  	if (!temp) {
  		ret = -ENOMEM;
  		goto out;
  	}
  	fetch_rnd_data->data = temp;
  
  	ret = caam_securekey_desc_init(dev, req);
  
  	if (ret) {
  		pr_info("caam_securekey_desc_init failed
  ");
  		goto out;
  	}
  
  	ret = sk_job_submit(dev, req);
  	if (!ret) {
  		/*Copy output to key buffer. */
  		memcpy(p->key, fetch_rnd_data->data, p->key_len);
  	} else {
  		ret = -EINVAL;
  	}
  
  out:
  	if (req)
  		kfree(req);
  
  	if (temp)
  		kfree(temp);
  
  	return ret;
  }
  EXPORT_SYMBOL(caam_get_random);
  
  /* key_deblob(struct secure_key_payload *p, enum sk_req_type decap_type
   *		struct device *dev)
   * Deblobify the blob to get the key data and fill in secure key payload struct
   * param[in] p pointer to the secure key payload
   * param[in] decap_type operation to be done.
   * param[in] dev dev Pointer to job ring device structure
   * If operation is successful return 0, otherwise error.
   */
  int key_deblob(struct secure_key_payload *p, enum sk_req_type decap_type,
  	       struct device *dev)
  {
  	unsigned int blob_len;
  	struct sk_red_blob_decap *d_blob;
  	struct sk_req *req = NULL;
  	int total_sz = 0, *temp = NULL, ret = 0;
  
  	req = kmalloc(sizeof(struct sk_req), GFP_DMA);
  	if (!req) {
  		ret = -ENOMEM;
  		goto out;
  	}
  
  	d_blob = &(req->req_u.sk_red_blob_decap);
  	blob_len = p->blob_len;
  	req->type = decap_type;
  
  	/*
  	 * Red blob size is the blob_len filled in payload struct
  	 * Data_sz i.e. key is the blob_len - blob header size
  	 */
  
  	d_blob->redblob_sz = blob_len;
  	d_blob->data_sz = blob_len - (SK_BLOB_KEY_SZ + SK_BLOB_MAC_SZ);
  	total_sz = d_blob->data_sz + d_blob->redblob_sz;
  
  	temp = kmalloc(total_sz, GFP_DMA);
  	if (!temp) {
  		ret = -ENOMEM;
  		goto out;
  	}
  
  	req->mem_pointer = temp;
  	d_blob->redblob = temp;
  	d_blob->data = d_blob->redblob + d_blob->redblob_sz;
  	memcpy(d_blob->redblob, p->blob, blob_len);
  
  	ret = caam_securekey_desc_init(dev, req);
  
  	if (ret) {
  		pr_info("caam_securekey_desc_init: Failed
  ");
  		goto out;
  	}
  
  	ret = sk_job_submit(dev, req);
  	if (!ret) {
  		/*Copy output to key buffer. */
  		p->key_len = d_blob->data_sz;
  		memcpy(p->key, d_blob->data, p->key_len);
  	} else {
  		ret = -EINVAL;
  	}
  
  out:
  	if (temp)
  		kfree(temp);
  	if (req)
  		kfree(req);
  	return ret;
  }
  EXPORT_SYMBOL(key_deblob);
  
  /* key_blob(struct secure_key_payload *p, enum sk_req_type encap_type,
   *		struct device *dev)
   * To blobify the key data to get the blob. This blob can only be seen by
   * userspace.
   * param[in] p pointer to the secure key payload
   * param[in] decap_type operation to be done.
   * param[in] dev dev Pointer to job ring device structure
   * If operation is successful return 0, otherwise error.
   */
  int key_blob(struct secure_key_payload *p, enum sk_req_type encap_type,
  	     struct device *dev)
  {
  	unsigned int key_len;
  	struct sk_red_blob_encap *k_blob;
  	struct sk_req *req = NULL;
  	int total_sz = 0, *temp = NULL, ret = 0;
  
  	req = kmalloc(sizeof(struct sk_req), GFP_DMA);
  	if (!req) {
  		ret = -ENOMEM;
  		goto out;
  	}
  
  	key_len = p->key_len;
  
  	req->type = encap_type;
  	k_blob = &(req->req_u.sk_red_blob_encap);
  
  	/*
  	 * Data_sz i.e. key len and the corresponding blob_len is
  	 * key_len + BLOB header size.
  	 */
  
  	k_blob->data_sz = key_len;
  	k_blob->redblob_sz = key_len + SK_BLOB_KEY_SZ + SK_BLOB_MAC_SZ;
  	total_sz = k_blob->data_sz + k_blob->redblob_sz;
  
  	temp = kmalloc(total_sz, GFP_DMA);
  	if (!temp) {
  		ret = -ENOMEM;
  		goto out;
  	}
  
  	req->mem_pointer = temp;
  	k_blob->data = temp;
  
  	k_blob->redblob = k_blob->data + k_blob->data_sz;
  	memcpy(k_blob->data, p->key, key_len);
  
  	ret = caam_securekey_desc_init(dev, req);
  
  	if (ret) {
  		pr_info("caam_securekey_desc_init failed
  ");
  		goto out;
  	}
  
  	ret = sk_job_submit(dev, req);
  	if (!ret) {
  		/*Copy output to key buffer. */
  		p->blob_len = k_blob->redblob_sz;
  		memcpy(p->blob, k_blob->redblob, p->blob_len);
  	} else {
  		ret = -EINVAL;
  	}
  
  out:
  	if (temp)
  		kfree(req->mem_pointer);
  	if (req)
  		kfree(req);
  	return ret;
  
  }
  EXPORT_SYMBOL(key_blob);