Line: 124 Column: 2 CWE codes: 120
Suggestion: Make sure destination can always hold the source data

              		goto free_public_key;

	/* save the public key */
	memcpy(public_key, &cmd->data[RSP_DATA_IDX], ATMEL_ECC_PUBKEY_SIZE);
	ctx->public_key = public_key;

	kfree(cmd);
	return 0;


            

Line: 1114 Column: 21 CWE codes: 126

              static bool is_acpi_graph_node(struct fwnode_handle *fwnode,
			       const char *str)
{
	unsigned int len = strlen(str);
	const char *name;

	if (!len || !is_acpi_data_node(fwnode))
		return false;


            

Line: 902 Column: 2 CWE codes: 120
Suggestion: Make sure destination can always hold the source data

              	if (!dst)
		return NULL;

	memcpy(dst + (dstlen - nbytes), ptr, nbytes);

	return dst;
}

/**

            

Line: 73 Column: 2 CWE codes: 120
Suggestion: Make sure destination can always hold the source data

              		return ret;
	}

	memcpy(key_out, key_in, keylen);

	dma_addr = dma_map_single(jrdev, key_out, local_max, DMA_BIDIRECTIONAL);
	if (dma_mapping_error(jrdev, dma_addr)) {
		dev_err(jrdev, "unable to map key memory\n");
		goto out_free;

            

Line: 1057 Column: 4 CWE codes: 120
Suggestion: Make sure destination can always hold the source data

              		flpi = &pr->power.lpi_states[flat_state_cnt];

		if (!prev_level) { /* leaf/processor node */
			memcpy(flpi, t, sizeof(*t));
			stash_composite_state(curr_level, flpi);
			flat_state_cnt++;
			continue;
		}


            

Line: 634 Column: 2 CWE codes: 120
Suggestion: Make sure destination can always hold the source data

              
static inline void nitrox_creq_copy_iv(char *dst, char *src, int size)
{
	memcpy(dst, src, size);
}

static inline struct scatterlist *nitrox_creq_src_sg(char *iv, int ivsize)
{
	return (struct scatterlist *)(iv + ivsize);

            

Line: 299 Column: 2 CWE codes: 120
Suggestion: Make sure destination can always hold the source data

              	idx = cmdq->write_idx;
	/* copy the instruction */
	ent = cmdq->base + (idx * cmdq->instr_size);
	memcpy(ent, &sr->instr, cmdq->instr_size);

	atomic_set(&sr->status, REQ_POSTED);
	response_list_add(sr, cmdq);
	sr->tstamp = jiffies;
	/* flush the command queue updates */

            

Line: 621 Column: 3 CWE codes: 119 120
Suggestion: Perform bounds checking, use functions that limit length, or ensure that the size is larger than the maximum possible length

              		return false;
	} else if (!dt_is_dp500) {
		u16 product_id;
		char buf[32];

		core_id = malidp_hw_read(hwdev,
					 MALIDP550_DC_BASE + MALIDP_DE_CORE_ID);
		product_id = MALIDP_PRODUCT_ID(core_id);
		snprintf(buf, sizeof(buf), "arm,mali-dp%X", product_id);

            

Line: 56 Column: 2 CWE codes: 119 120
Suggestion: Perform bounds checking, use functions that limit length, or ensure that the size is larger than the maximum possible length

              {
	struct armada_crtc *dcrtc;
	unsigned long reg, mask, val;
	char buf[32];
	int ret;
	u32 v;

	if (*off != 0)
		return 0;

            

Line: 721 Column: 2 CWE codes: 119 120
Suggestion: Perform bounds checking, use functions that limit length, or ensure that the size is larger than the maximum possible length

              	u32 reg_mcr18, reg_mcr0c, passcnt[2], diff;
	u32 g_dqidly, g_dqsip, g_margin, g_side;
	u16 pass[32][2][2];
	char tag[2][76];

	/* Disable DQI CBR */
	reg_mcr0c  = ast_mindwm(ast, 0x1E6E000C);
	reg_mcr18  = ast_mindwm(ast, 0x1E6E0018);
	reg_mcr18 &= 0x0000ffff;