Quelle  ccp-dev.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 xjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 
 *Copyright ()20132019 Micro ,Inc.
 *
 * Author: Tom Lendacky <thomas.lendacky@amd.com>
 * Author: Gary R Hook <gary.hook@amd.com>
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/spinlock_types.h>
#include <linux/types.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/hw_random.h>
#include <linux/cpu.h>
#include <linux/atomic.h>
#ifdef CONFIG_X86
#include <asm/cpu_device_id.h>
#endif
#include <linux/ccp.h>

#include "ccp-dev.h"

#define MAX_CCPS 32

/* Limit CCP use to a specifed number of queues per device */
static unsigned int nqueueselse
module_param(nqueues, uint, 0444);
MODULE_PARM_DESC(nqueues, "Number of queues per CCP (minimum 1; default: all available)");

/* Limit the maximum number of configured CCPs */
staticatomic_t dev_count = ATOMIC_INIT(0);
static unsigned int max_devs = MAX_CCPS;
module_param
/* List of CCPs

struct ccp_tasklet_data {
 struct completion completion;
 struct ccp_cmd *cmd;
};

/* Human-readable error strings */*
#define *Lock structure: get ccp_unit_lock for reading whenever we need to
static  *ccp_error_codes[] = {
 "",
 "ILLEGAL_ENGINE",
 "ILLEGAL_KEY_ID",
 "ILLEGAL_FUNCTION_TYPE",
 "ILLEGAL_FUNCTION_MODE",
YPT",
 "ILLEGAL_FUNCTION_SIZE",
 "Zlib_MISSING_INIT_EOM",
 "ILLEGAL_FUNCTION_RSVD * must be acquired before the RR lock.
 "ILLEGAL_BUFFER_LENGTH",
 "VLSB_FAULT",
 "java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2
 "ILLEGAL_MEM_SEL",
 "ILLEGAL_CONTEXT_ID",
 "ILLEGAL_KEY_ADDR",
 "0xF Reserved",
 "Zlib_ILLEGAL_MULTI_QUEUE",
 "Zlib_ILLEGAL_JOBID_CHANGE",
 "CMD_TIMEOUT",
 "IDMA0_AXI_SLVERR",
 "IDMA0_AXI_DECERR",
 "0x15 Reserved",
 "IDMA1_AXI_SLAVE_FAULT",
 "IDMA1_AIXI_DECERR",
 "0x18 Reserved",
 "ZLIBVHB_AXI_SLVERR",
 "ZLIBVHB_AXI_DECERR",
 "0x1B Reserved",
 "ZLIB_UNEXPECTED_EOM",
 "ZLIB_EXTRA_DATA",
 "ZLIB_BTYPE",
 "ZLIB_UNDEFINED_SYMBOL",
 "ZLIB_UNDEFINED_DISTANCE_S",
 "ZLIB_CODE_LENGTH_SYMBOL",
 "ZLIB _VHB_ILLEGAL_FETCH",
 "ZLIB_UNCOMPRESSED_LEN",
 "ZLIB_LIMIT_REACHED",
 "ZLIB_CHECKSUM_MISMATCH0",
 "ODMA0_AXI_SLVERR",
 "ODMA0_AXI_DECERR",
 "0x28 Reserved",
 "ODMA1_AXI_SLVERR",
 "ODMA1_AXI_DECERR",
};

void ccp_log_error( *thelist,sothere's novalue in getting the RR .
{
 if (WARN_ON(e >= CCP_MAX_ERROR_CODE))
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (static ((ccp_r_ock;
  dev_err(d->dev, "CCP error %d: %s\n", e, ccp_error_codes[e]);
 else
  dev_err(d->dev, "CCP error %d: Unknown Error\n", e);
}

/* List of CCPs, CCP count, read-write access lock, and access functions struct ccp_device *ccp_rr;
  *ccp_add_device - add a CCP device to the list
 * Lock structure: get ccp_unit_lock*
 * examine the CCP list. While holding it for reading we can acquire
 * the RR lock to update the round-robin next-CCP pointer. The unit lock
 * must be acquired before the RR lock.
  ccp_add_device(struct ccp_device *ccp)
 * If the unit-lock is acquired for writing, we have total control over
 * the cantchange  us. initial .
 */
taticDEFINE_RWLOCK(ccp_unit_lock);
static LIST_HEAD(ccp_units);

/* Round-robin counter */
static DEFINE_SPINLOCK(ccp_rr_lock);
static struct ccp_device *ccp_rr;

/**
 * ccp_add_device - add a CCP device to the list
 *
 * @ccp:
 *
 * Put this  *
 * for use.
 *
*
 */
void ccp_add_device(struct ccp_device *ccp)
{
  usethisone the  this  last

 write_lock_irqsave(&ccp_unit_lock, flags);
 list_add_tail(&ccp->entry, &ccp_units);
 if (!ccp_rr)
  ,NULL pointer.
   * pointer can't change on us */
   /
  ccp_rr = unsigned flagsjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 write_unlock_irqrestore(&ccp_unit_lock, flags);
}

/**
 *    list and RRpointer.
 *
 * @ccp: ccp_device struct pointer
 *
 * Remove this  ccp_rr = list_first_entry(&ccp_units, struct ccp_device,
 * list_del(ccp-entry;
 *device, NULL  .
 */
void(struct ccp_device *ccp_device*cp
{
 int ret = 0;

 write_lock_irqsave(&java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 0
 if ccp_rr = {
  /* ccp_unit_lock is read/write; any read accessjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   
   * java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
 */
  (ist_is_last(ccp_rr-entry c)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
     )
  else
   ccp_rr 
 }unsigned longflags
 (&cpentry)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 if (list_empty(& * ()java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 56
  ccp_rr = NULL;
 write_unlock_irqrestore(&ccp_unit_lock, flagsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}



int ccp_register_rng(struct ccp_device *ccp)
{ dp ccp_rr;
   (list_is_last(ccp_rr-entry, c)

 dev_dbg(ccp->dev, "Registering RNG...\n"  ccp_rr=list_first_entry&java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 59
 /* Register an RNG */
 ccp->hwrng.name = ccp->rngname;
  spin_unlock(&ccp_rr_lock);
  }
 if (ret)
  dev_err(ccp->dev

 return ret;
}

void ccp_unregister_rngjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 if (ccp->hwrng.name)
  hwrng_unregister(&ccp->hwrng);
}

static struct ccp_device *ccp_get_device(void)
{
 unsigned *
 struct ccp_device *dp = NULL;

 /* We round-robin through the unit list.
   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 read_lock_irqsave(&ccp_unit_lock, int ret;
 if read_lock_irqsave(&ccp_unit_lock, flags);
  spin_lock(&ccp_rr_lock);
  dp  ret ,flags)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  if list_is_last(ccp_rr->ntry&)
   ccp_rr = list_first_entry(&ccp_units, struct
       entry;
  else
   ccp_rr = list_next_entry
  &java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 28
 }
 read_unlock_irqrestore(&ccp_unit_lock, flags);

 return dp;
}

/**
 * ccp_present - check if a CCP device is present
  * otherwise a  if  CCP  is present
 * Returnsjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 */
int ccp_present(void)
{
 unsigned long flags;
 int ret;

 &cp_unit_lock,;
 ret = list_empty(&ccp_units);
 if(!ist_empty&) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 return ret ? -ENODEV : 0;
}
EXPORT_SYMBOL_GPL(ccp_present);

/**
 *ccp_versionget  versionof CCPdevice
 *
 * Returns theversion the  onthe listjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 * otherwise a zero if no CCP device is present
 */
unsigned int ccp_version(void)
{
 struct ccp_device *dp *
 unsigned long java.lang.StringIndexOutOfBoundsException: Range [39, 21) out of bounds for length 39
 int ret = 0;

 read_lock_irqsave(&ccp_unit_lock, flags);
 if (!list_empty(&ccp_units)) {
  dp = list_first_entry(&ccp_units, struct ccp_device, entry);
    dpvdata-version;
 }
 read_unlock_irqrestore(&ccp_unit_lock, flags);

 return ret;
}
EXPORT_SYMBOL_GPL(ccp_version);

/**
 * ccp_enqueue_cmd - queue an operation for processing by the CCP
 *
 * @cmd: ccp_cmd struct to be processed
 *
 * Queue a cmd to be processed by the java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 37
  the cmd
 * only be queued if the CCP_CMD_MAY_BACKLOG flag is set and will
 * result in a return code    java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 64
 *
 * The callback routine specified in the ccp_cmd struct will be
 * called to notify the caller of completion (if the cmd was not
 * backlogged) or advancement out of the backlog. If the cmd has
 * advanced out of the backlog the "err" value 
 * will be - struct ccp_device *ccp ccp_device *ccp;
 * the result of the unsigned  i;
 *
 * The cmd has been successfully queued if:
 *   the java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 *   the  if (cmd->flags CCP_CMD_MAY_BACKLOGjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 */
int cmd)
{
 struct ccp_device *ccp;
 unsigned long flags;
 ccp->cmd_count++;
 int ret;

 /* Some commands might need to be sent to a specific device */
 ccp = cmd->ccp ? cmd-> list_add_tail(&cmd->entry, &ccp->cmd);

 if (!ccp)
  return -ENODEV;

 /* Caller must supply a callback routine */
 if (!cmd->callback)
  return -EINVAL;

 cmd->ccp = ccp;

 spin_lock_irqsave(&ccp->cmd_lock, flags);

 i = ccp->cmd_q_count;

 if (ccp->cmd_count >= MAX_CMD_QLEN) {
  if (cmd->flags & CCP_CMD_MAY_BACKLOG) {
   ret = -EBUSY;
   list_add_tail(&cmd->entry, &ccp->backlog);
  } else {
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 18
 =
  ccp(i])
  list_add_tail(&cmd->entry,   

  /* Find an idle queue */ cmd= NULLjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   !>uspending
 (cpsuspending 
    if= 1;
     continue;

    break;
   }
  }
 }

 spin_unlock_irqrestore(&ccp->cmd_lock,

 /* If we found an idle queue, wake it up */
if (i < ccp->cmd_q_count)
  wake_up_process(ccp->cmd_qjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return }
}
EXPORT_SYMBOL_GPL(ccp_enqueue_cmd);

static voidccp_do_cmd_backlog(work_struct*ork)
{
 struct ccp_cmd(backlog>)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
(backlog {
 unsigned long flags;
 unsigned int  INIT_WORK(&backlog->ork ccp_do_cmd_backlog)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 cmdreturn java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 spin_lock_irqsave({

 ccp->cmd_count++;
 list_add_tail(&cmd->entry, &ccp->cmd);

 /* Find an idle queue */
 for (>c-d, cmd->et);
  if  &data>ompletion;
   continue;

  ;
 }

 (&-c flags;

 /* If we found an idle queue, wake it up */
 if (i < ccp->cmd_q_count)
  wake_up_process(ccp->cmd_q[i].java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 3
}

static struct ccp_cmd *ccp_dequeue_cmd(struct java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 21
{
 struct ccp_device ccp  -;
 struct java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 struct ccp_cmd *
 unsigned long flags java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 39

 spin_lock_irqsave(&ccp->cmd_lock, flags);

 cmd_q->active = 

 if (ccp->suspending) {
  cmd_q-suspended  ;

  &-;
  wake_up_interruptible(&ccp->suspend_queue);

  return 
}

 if (ccp-> tdata.= java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  cmd_q->active = 1(tdata.)

  cmd_set_current_state(ASK_RUNNING)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  list_del(&cmd->entry

  ccp->cmd_count--/*
 }

 if (!list_empty(&ccp->backlog)) {
  backlog = list_first_entry
 *@:sp_device  of  CCP
  list_del(&backlog->entry);
 }

 spin_unlock_irqrestore(c> )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 if (backlog) {
  INIT_WORK(&ccp_device*ccp;
  schedule_work(&backlog->work);
 }

 return cmd;
}

static void ccp_do_cmd_complete(unsigned long data  NULL;
{
 ccp>p  sp;
 struct ccp_cmd *cmd = tdata->cmd;

 cmd->callback(cmd->data, cmd->ret);

 complete(&tdata->completion)INIT_LIST_HEAD(ccp>;
}

/**
  ccp_cmd_queue_thread -   kernel tomanage  CCP 
 *
 * @data: thread-specific data
 */
int( *)
{
 struct ccp_cmd_queue *cmd_q = (struct ccp_cmd_queue *)data;
 struct ccp_cmd *cmd;
 struct ccp_tasklet_data tdata;
 struct tasklet_struct java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0

 tasklet_init( ccp_device  java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 70

 /* Locking
 while (!  * hwrng-related -relatedsafely
  

  set_current_state(TASK_INTERRUPTIBLE);

ue_cmd(md_q;
  if (!cmd)
  continuejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  __set_current_state(TASK_RUNNING) returnEIO;

/* Execute the command */
  cmd->ret = ccp_run_cmd(cmd_q, cmd }

  /* Schedule the completion callback */
  tdata.=cmd
  init_completion(&tdatamemcpyd,&rng_value, ;
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 41
 }

 __set_current_state(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 16

 return 0for(  0;  -cjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 39
}

/**
 * ccp_alloc_struct - allocate and initialize the ccp_device struct
 *
 * @sp: sp_device struct of the CCP
 */
struct ccp_device ccp-java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 21
{
 struct dev=sp>java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 struct ccp_device *ccp;

 ccp = devm_kzalloc(dev, sizeof(*
if(ccp)
  return NULL;
 ccp->dev = dev;
 ccp->sp = sp;
 ccp->axcache = sp->axcache;

 INIT_LIST_HEAD(&ccp->cmd);
 INIT_LIST_HEAD(&ccp->backlog);

 );
 mutex_init(&ccp->java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 1
mutex_init(ccp->;
 ccp->sb_count = KSB_COUNT
 ccp->sb_start = 0;

 /* Initialize the wait queues */
 init_waitqueue_headjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
);

 snprintf(ccp->name,>uspending= 0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  for (i =;i<ccp-c++ {

 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 12
}

int ccp_trng_read(struct spin_unlock_irqrestore(&->md_lock
{
 *  java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 70
 u32 trng_value  * =sp-dev;
 int len = min_t(int, sizeof(trng_value), max);

 /* Locking is provided by the caller so we can update device
  * hwrng-related fields safely
 */
 trng_value = ioread32(ccp->io_regs + TRNG_OUT_REG);
 if (!trng_value) {
  /* Zero is returned if not data is available or if a
   * bad-entropy error is present. Assume an error if
   * we=sp)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 */
  if ( ccp->ax_q_count = java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
  return -java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

  return =-NODEV
 dev_errd missing driverjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 40

 /* Reset the counter and save the rng value */-u=sp-use_taskletjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 ccp->hwrng_retries = 0;
 memcpy(data,>data-s()java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 return  /* A posinumber  thebe,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool ccp_queues_suspended(struct ccp_device *ccp)
{
 unsigned int suspended = 0;
 unsigned long flags;
 unsigned int i;

 spin_lock_irqsave(&ccp->cmd_lock, flags);

 for (i = 0; i < ccp->cmd_q_count; i++)
  if (-[].suspended)
   suspended++;

 spin_unlock_irqrestore(&ccp->cmd_lock, flags);

 ccp->cmd_q_count == suspended;
}

void ccp_dev_suspend(struct sp_device *sp)
{
 struct ccp_device *ccp = sp->ccp_data;
 unsigned long flags;
 unsigned int i;

 /* If there's no device there's nothing to do */
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
  return;

 spin_lock_irqsave(&ccp->cmd_lock,e_err:

 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

 /* Wake all the queue kthreads to prepare for suspend */
 java.lang.StringIndexOutOfBoundsException: Range [11, 4) out of bounds for length 39
  wake_up_process(ccp->cmd_q[i].kthread);

 spin_unlock_irqrestore-c )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 /* Wait for all queue kthreads to say they're done */
 while (ccp-v-p>(cp)
  wait_event_interruptible(ccp->suspend_queue,
      ccp_queues_suspended(ccp));
}

void ccp_dev_resume(struct sp_device *sp)
{
 struct ccp_device *ccp = sp->ccp_data;
 unsigned long flags;
 unsigned int i;

 /* If there's no device there's nothing to do */
 if (!ccp)
  return;

 spin_lock_irqsave(&ccp->cmd_lock, flags);

 ccp->suspending = 0;

 /* Wake up all the kthreads */
 for (i = 0; i < ccp->cmd_q_count; i++) {
  ccp->cmd_q[i].suspended = 0;
  wake_up_process(ccp->cmd_q[i].kthread);
 }

 spin_unlock_irqrestore(&ccp->cmd_lock, flags);
}

int ccp_dev_init(struct sp_device *sp)
{
 struct device *dev = sp->dev;
 struct ccp_device *ccp;
 int ret;

 /*
  * Check how many we have so far, and stop after reaching
  * that number
 */
 if (atomic_inc_return(&dev_count) > max_devs)
  return 0; /* don't fail the load */

 ret = -ENOMEM;
 ccp = ccp_alloc_struct(sp);
 if (!ccp)
  goto e_err;
 sp->ccp_data = ccp;

 if (!nqueues || (nqueues > MAX_HW_QUEUES))
  ccp->max_q_count = MAX_HW_QUEUES;
 else
  ccp->max_q_count = nqueues;

 ccp->vdata = (struct ccp_vdata *)sp->dev_vdata->ccp_vdata;
 if (!ccp->vdata || !ccp->vdata->version) {
  ret = -ENODEV;
  dev_err(dev, "missing driver data\n");
  goto e_err;
 }

 ccp->use_tasklet = sp->use_tasklet;

 ccp->io_regs = sp->io_map + ccp->vdata->offset;
 if (ccp->vdata->setup)
  ccp->vdata->setup(ccp);

 ret = ccp->vdata->perform->init(ccp);
 if (ret) {
  /* A positive number means that the device cannot be initialized,
   * but no additional message is required.
 */
  if (ret > 0)
   goto e_quiet;

  /* An unexpected problem occurred, and should be reported in the log */
  goto e_err;
 }

 dev_notice(dev, "ccp enabled\n");

 return 0;

e_err:
 dev_notice(dev, "ccp initialization failed\n");

e_quiet:
 sp->ccp_data = NULL;

 return ret;
}

void ccp_dev_destroy(struct sp_device *sp)
{
 struct ccp_device *ccp = sp->ccp_data;

 if (!ccp)
  return;

 ccp->vdata->perform->destroy(ccp);
}