static void set_mode_compression(struct scsi_cmd *cmd, uint8_t *p)
{
struct lu_phy_attr *lu = cmd->lu;
struct priv_lu_ssc *lu_priv = lu->lu_private;
struct ssc_personality_template *pm;
int dce;
pm = lu_priv->pm;
dce = p[2] & 0x80;
MHVTL_DBG(2, " Data Compression Enable : %s (0x%02x)",
(p[1] & 0x80) ? "Yes" : "No", p[1]);
MHVTL_DBG(2, " Data Compression Capable : %s",
(p[1] & 0x40) ? "Yes" : "No");
MHVTL_DBG(2, " Data DeCompression Enable : %s (0x%02x)",
(p[2] & 0x80) ? "Yes" : "No", p[2]);
MHVTL_DBG(2, " Compression Algorithm : 0x%04x",
get_unaligned_be32(&p[4]));
MHVTL_DBG(2, " DeCompression Algorithm : 0x%04x",
get_unaligned_be32(&p[8]));
MHVTL_DBG(2, " Report Exception on Decompression: 0x%02x",
(p[3] & 0x6) >> 5);
if (dce) { /* Data Compression Enable bit set */
MHVTL_DBG(1, " Setting compression");
if (pm->set_compression)
pm->set_compression(&lu->mode_pg,
lu_priv->configCompressionFactor);
} else {
MHVTL_DBG(1, " Clearing compression");
if (pm->clear_compression)
pm->clear_compression(&lu->mode_pg);
}
}
int extract_subprogram(u8 **progdata, u32 expected_magic,
struct key_program **result)
{
struct key_program *prog = *result;
u32 magic, code_crc, code_size;
magic = get_unaligned_be32(*progdata);
code_crc = get_unaligned_be32(*progdata + 4);
code_size = get_unaligned_be32(*progdata + 8);
*progdata += 12;
if (magic != expected_magic)
return -1;
*result = malloc(sizeof(struct key_program) + code_size);
if (!*result)
return -1;
prog->magic = magic;
prog->code_crc = code_crc;
prog->code_size = code_size;
memcpy(prog->code, *progdata, code_size);
*progdata += code_size;
if (hre_verify_program(prog)) {
free(prog);
return -1;
}
return 0;
}
/**
* ldm_parse_vmdb - Read the LDM Database VMDB structure
* @data: Raw database VMDB structure loaded from the device
* @vm: In-memory vmdb structure in which to return parsed information
*
* This parses the LDM Database VMDB structure supplied in @data and sets up
* the in-memory vmdb structure @vm with the obtained information.
*
* N.B. The *_start, *_size and *_seq values will be range-checked later.
*
* Return: 'true' @vm contains VMDB info
* 'false' @vm contents are undefined
*/
static bool ldm_parse_vmdb (const u8 *data, struct vmdb *vm)
{
BUG_ON (!data || !vm);
if (MAGIC_VMDB != get_unaligned_be32(data)) {
ldm_crit ("Cannot find the VMDB, database may be corrupt.");
return false;
}
vm->ver_major = get_unaligned_be16(data + 0x12);
vm->ver_minor = get_unaligned_be16(data + 0x14);
if ((vm->ver_major != 4) || (vm->ver_minor != 10)) {
ldm_error ("Expected VMDB version %d.%d, got %d.%d. "
"Aborting.", 4, 10, vm->ver_major, vm->ver_minor);
return false;
}
vm->vblk_size = get_unaligned_be32(data + 0x08);
if (vm->vblk_size == 0) {
ldm_error ("Illegal VBLK size");
return false;
}
vm->vblk_offset = get_unaligned_be32(data + 0x0C);
vm->last_vblk_seq = get_unaligned_be32(data + 0x04);
ldm_debug ("Parsed VMDB successfully.");
return true;
}
int tpm_xfer(struct udevice *dev, const uint8_t *sendbuf, size_t send_size,
uint8_t *recvbuf, size_t *recv_size)
{
struct tpm_chip_priv *priv = dev_get_uclass_priv(dev);
struct tpm_ops *ops = tpm_get_ops(dev);
ulong start, stop;
uint count, ordinal;
int ret, ret2;
if (ops->xfer)
return ops->xfer(dev, sendbuf, send_size, recvbuf, recv_size);
if (!ops->send || !ops->recv)
return -ENOSYS;
/* switch endianess: big->little */
count = get_unaligned_be32(sendbuf + TPM_CMD_COUNT_BYTE);
ordinal = get_unaligned_be32(sendbuf + TPM_CMD_ORDINAL_BYTE);
if (count == 0) {
debug("no data\n");
return -ENODATA;
}
if (count > send_size) {
debug("invalid count value %x %zx\n", count, send_size);
return -E2BIG;
}
debug("%s: Calling send\n", __func__);
ret = ops->send(dev, sendbuf, send_size);
if (ret < 0)
return ret;
start = get_timer(0);
stop = tpm_tis_i2c_calc_ordinal_duration(priv, ordinal);
do {
ret = ops->recv(dev, priv->buf, sizeof(priv->buf));
if (ret >= 0) {
if (ret > *recv_size)
return -ENOSPC;
memcpy(recvbuf, priv->buf, ret);
*recv_size = ret;
ret = 0;
break;
} else if (ret != -EAGAIN) {
return ret;
}
mdelay(priv->retry_time_ms);
if (get_timer(start) > stop) {
ret = -ETIMEDOUT;
break;
}
} while (ret);
ret2 = ops->cleanup ? ops->cleanup(dev) : 0;
return ret2 ? ret2 : ret;
}
/*
* @pi must be allocated previously
* @skb is the buffer passed to the filter
*/
static inline int getPacketInfo(const struct sk_buff *skb, struct packetInfo *src_pi, struct packetInfo *dst_pi)
{
u32 tmp;
void *ptr;
u32 X;
ptr = load_pointer(skb,23,1,&tmp);
if(ptr != NULL)
{
src_pi->protocol = *(u8 *)ptr;
dst_pi->protocol = *(u8 *)ptr;
}else goto out;
ptr = load_pointer(skb,26,4,&tmp);
if(ptr !=NULL)
{
src_pi->address = get_unaligned_be32(ptr);
}else goto out;
ptr = load_pointer(skb,30,4,&tmp);
if(ptr != NULL)
{
dst_pi->address = get_unaligned_be32(ptr);
}else goto out;
ptr = load_pointer(skb,14,1,&tmp);
if(ptr != NULL)
{
X = (*(u8 *)ptr & 0xf) << 2;
X+=14;
ptr = load_pointer(skb,X,2,&tmp);
if(ptr != NULL)
{
src_pi->port = get_unaligned_be16(ptr);
}else goto out;
X+=2;
ptr = load_pointer(skb,X,2,&tmp);
if(ptr != NULL)
{
dst_pi->port = get_unaligned_be16(ptr);
}else goto out;
}else goto out;
return 0;
out:
return -1;
}
static void
rk3399_vpu_jpeg_enc_set_qtable(struct rockchip_vpu_dev *vpu,
unsigned char *luma_qtable,
unsigned char *chroma_qtable)
{
u32 reg, i;
for (i = 0; i < VEPU_JPEG_QUANT_TABLE_COUNT; i++) {
reg = get_unaligned_be32(&luma_qtable[i]);
vepu_write_relaxed(vpu, reg, VEPU_REG_JPEG_LUMA_QUAT(i));
reg = get_unaligned_be32(&chroma_qtable[i]);
vepu_write_relaxed(vpu, reg, VEPU_REG_JPEG_CHROMA_QUAT(i));
}
}
static int ratpfs_open(struct device_d __always_unused *dev,
FILE *file, const char *filename)
{
int len_name = strlen(filename);
int len_tx = 1 /* type */
+ 4 /* flags */
+ len_name /* path */;
struct ratp_bb_pkt *pkt_tx = xzalloc(sizeof(*pkt_tx) + len_tx);
struct ratp_bb_pkt *pkt_rx = NULL;
struct ratpfs_file *rfile = xzalloc(sizeof(*rfile));
int ret;
pr_debug("%s: len_tx=%i filename='%s'\n", __func__, len_tx, filename);
pkt_tx->len = len_tx;
pkt_tx->data[0] = RATPFS_TYPE_OPEN_CALL;
put_unaligned_be32(file->flags, &pkt_tx->data[1]);
memcpy(&pkt_tx->data[5], filename, len_name);
ret = barebox_ratp_fs_call(pkt_tx, &pkt_rx);
if (ret) {
ret = -EIO;
goto err;
}
pr_debug("%s: len_rx=%i\n", __func__, pkt_rx->len);
if (pkt_rx->len < 1 || pkt_rx->data[0] != RATPFS_TYPE_OPEN_RETURN) {
pr_err("invalid open response\n");
ret = -EIO;
goto err;
}
rfile->handle = get_unaligned_be32(&pkt_rx->data[1]);
if (rfile->handle == 0) {
ret = -get_unaligned_be32(&pkt_rx->data[5]); /* errno */
goto err;
}
file->priv = rfile;
file->size = get_unaligned_be32(&pkt_rx->data[5]);
goto out;
err:
file->priv = NULL;
free(rfile);
out:
free(pkt_rx);
return ret;
}
static void nps_enet_send_frame(struct net_device *ndev,
struct sk_buff *skb)
{
struct nps_enet_priv *priv = netdev_priv(ndev);
u32 tx_ctrl_value = 0;
short length = skb->len;
u32 i, len = DIV_ROUND_UP(length, sizeof(u32));
u32 *src = (void *)skb->data;
bool src_is_aligned = IS_ALIGNED((unsigned long)src, sizeof(u32));
/* In case src is not aligned we need an intermediate buffer */
if (src_is_aligned)
iowrite32_rep(priv->regs_base + NPS_ENET_REG_TX_BUF, src, len);
else /* !src_is_aligned */
for (i = 0; i < len; i++, src++)
nps_enet_reg_set(priv, NPS_ENET_REG_TX_BUF,
get_unaligned_be32(src));
/* Write the length of the Frame */
tx_ctrl_value |= length << TX_CTL_NT_SHIFT;
tx_ctrl_value |= NPS_ENET_ENABLE << TX_CTL_CT_SHIFT;
/* Send Frame */
nps_enet_reg_set(priv, NPS_ENET_REG_TX_CTL, tx_ctrl_value);
}
static void tcp_sack(const struct sk_buff *skb, unsigned int dataoff,
const struct tcphdr *tcph, __u32 *sack)
{
unsigned char buff[(15 * 4) - sizeof(struct tcphdr)];
const unsigned char *ptr;
int length = (tcph->doff*4) - sizeof(struct tcphdr);
__u32 tmp;
if (!length)
return;
ptr = skb_header_pointer(skb, dataoff + sizeof(struct tcphdr),
length, buff);
BUG_ON(ptr == NULL);
/* Fast path for timestamp-only option */
if (length == TCPOLEN_TSTAMP_ALIGNED*4
&& *(__be32 *)ptr == htonl((TCPOPT_NOP << 24)
| (TCPOPT_NOP << 16)
| (TCPOPT_TIMESTAMP << 8)
| TCPOLEN_TIMESTAMP))
return;
while (length > 0) {
int opcode = *ptr++;
int opsize, i;
switch (opcode) {
case TCPOPT_EOL:
return;
case TCPOPT_NOP: /* Ref: RFC 793 section 3.1 */
length--;
continue;
default:
opsize = *ptr++;
if (opsize < 2) /* "silly options" */
return;
if (opsize > length)
break; /* don't parse partial options */
if (opcode == TCPOPT_SACK
&& opsize >= (TCPOLEN_SACK_BASE
+ TCPOLEN_SACK_PERBLOCK)
&& !((opsize - TCPOLEN_SACK_BASE)
% TCPOLEN_SACK_PERBLOCK)) {
for (i = 0;
i < (opsize - TCPOLEN_SACK_BASE);
i += TCPOLEN_SACK_PERBLOCK) {
tmp = get_unaligned_be32((__be32 *)(ptr+i)+1);
if (after(tmp, *sack))
*sack = tmp;
}
return;
}
ptr += opsize - 2;
length -= opsize;
}
}
}
static int cyttsp5_check_firmware_version_builtin(struct device *dev,
const struct firmware *fw)
{
struct cyttsp5_loader_data *ld = cyttsp5_get_loader_data(dev);
u32 fw_ver_new;
u32 fw_revctrl_new;
int upgrade;
if (!ld->si) {
dev_info(dev, "%s: No firmware infomation found, device FW may be corrupted\n",
__func__);
return CYTTSP5_AUTO_LOAD_FOR_CORRUPTED_FW;
}
fw_ver_new = get_unaligned_be16(fw->data + 3);
/* 4 middle bytes are not used */
fw_revctrl_new = get_unaligned_be32(fw->data + 9);
upgrade = cyttsp5_check_firmware_version(dev, fw_ver_new,
fw_revctrl_new);
if (upgrade > 0)
return 1;
return 0;
}
/**
* Read values defined by a type string from a buffer, and write these values
* to environment variables.
*
* @param type_str type string
* @param data input buffer of values
* @param vars names of environment variables
* @return 0 on success, non-0 on error
*/
static int type_string_write_vars(const char *type_str, uint8_t *data,
char * const vars[])
{
size_t offset;
uint32_t value;
for (offset = 0; *type_str; type_str++, vars++) {
switch (*type_str) {
case 'b':
value = data[offset];
offset += 1;
break;
case 'w':
value = get_unaligned_be16(data + offset);
offset += 2;
break;
case 'd':
value = get_unaligned_be32(data + offset);
offset += 4;
break;
default:
return -1;
}
if (setenv_ulong(*vars, value))
return -1;
}
return 0;
}
uint8_t ssc_write_attributes(struct scsi_cmd *cmd)
{
int sz;
struct priv_lu_ssc *lu_priv;
uint8_t *sam_stat;
lu_priv = cmd->lu->lu_private;
sam_stat = &cmd->dbuf_p->sam_stat;
MHVTL_DBG(1, "Write Attributes (%ld) **", (long)cmd->dbuf_p->serialNo);
switch (lu_priv->tapeLoaded) {
case TAPE_UNLOADED:
mkSenseBuf(NOT_READY, E_MEDIUM_NOT_PRESENT, sam_stat);
return SAM_STAT_CHECK_CONDITION;
break;
case TAPE_LOADED:
cmd->dbuf_p->sz = get_unaligned_be32(&cmd->scb[10]);
sz = retrieve_CDB_data(cmd->cdev, cmd->dbuf_p);
MHVTL_DBG(1, " --> Expected to read %d bytes"
", read %d", cmd->dbuf_p->sz, sz);
if (resp_write_attribute(cmd) > 0)
rewriteMAM(sam_stat);
break;
default:
mkSenseBuf(NOT_READY, E_MEDIUM_FMT_CORRUPT, sam_stat);
return SAM_STAT_CHECK_CONDITION;
break;
}
return SAM_STAT_GOOD;
}
/*
* Validate that the next four input bytes match the value of s->crc32.
* s->pos must be zero when starting to validate the first byte.
*/
static enum xz_ret crc32_validate(struct xz_dec *s, struct xz_buf *b)
{
if(s->crc32_temp == 0)
{
GRUB_MD_CRC32->final(s->crc32_context);
s->crc32_temp = get_unaligned_be32(GRUB_MD_CRC32->read(s->crc32_context));
}
static int hfsplus_read_mdb(void *bufptr, struct hfsplus_wd *wd)
{
u32 extent;
u16 attrib;
__be16 sig;
sig = *(__be16 *)(bufptr + HFSP_WRAPOFF_EMBEDSIG);
if (sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIG) &&
sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIGX))
return 0;
attrib = be16_to_cpu(*(__be16 *)(bufptr + HFSP_WRAPOFF_ATTRIB));
if (!(attrib & HFSP_WRAP_ATTRIB_SLOCK) ||
!(attrib & HFSP_WRAP_ATTRIB_SPARED))
return 0;
wd->ablk_size =
be32_to_cpu(*(__be32 *)(bufptr + HFSP_WRAPOFF_ABLKSIZE));
if (wd->ablk_size < HFSPLUS_SECTOR_SIZE)
return 0;
if (wd->ablk_size % HFSPLUS_SECTOR_SIZE)
return 0;
wd->ablk_start =
be16_to_cpu(*(__be16 *)(bufptr + HFSP_WRAPOFF_ABLKSTART));
extent = get_unaligned_be32(bufptr + HFSP_WRAPOFF_EMBEDEXT);
wd->embed_start = (extent >> 16) & 0xFFFF;
wd->embed_count = extent & 0xFFFF;
return 1;
}
static int cyttsp5_check_ttconfig_version_platform(struct device *dev,
struct cyttsp5_touch_config *ttconfig)
{
struct cyttsp5_loader_data *ld = cyttsp5_get_loader_data(dev);
u32 fw_ver_config;
u32 fw_revctrl_config;
if (!ld->si) {
dev_info(dev, "%s: No firmware infomation found, device FW may be corrupted\n",
__func__);
return 0;
}
fw_ver_config = get_unaligned_be16(ttconfig->fw_ver + 2);
/* 4 middle bytes are not used */
fw_revctrl_config = get_unaligned_be32(ttconfig->fw_ver + 8);
/* FW versions should match */
if (cyttsp5_check_firmware_version(dev, fw_ver_config,
fw_revctrl_config)) {
dev_err(dev, "%s: FW versions mismatch\n", __func__);
return 0;
}
/* Check PowerOn Self Test, TT_CFG CRC bit */
if ((ld->si->cydata.post_code & CY_POST_TT_CFG_CRC_MASK) == 0) {
dev_dbg(dev, "%s: POST, TT_CFG failed (%X), will upgrade\n",
__func__, ld->si->cydata.post_code);
return 1;
}
return cyttsp5_check_ttconfig_version(dev, ttconfig->param_regs->data,
ttconfig->param_regs->size);
}
static ovs_be32
get_be32(const void **pp)
{
const ovs_be32 *p = *pp;
ovs_be32 value = get_unaligned_be32(p);
*pp = p + 1;
return value;
}
void smc_eng_clk_dump(struct smc_eng_clk *tbl)
{
u32 tmp;
L("SMC_ENG_CLK START");
tmp = get_unaligned_be32(&tbl->cg_eng_pll_func_ctl_0);
L("cg_eng_pll_func_ctl_0=0x%08x",tmp);
tmp = get_unaligned_be32(&tbl->cg_eng_pll_func_ctl_1);
L("cg_eng_pll_func_ctl_1=0x%08x",tmp);
tmp = get_unaligned_be32(&tbl->cg_eng_pll_func_ctl_2);
L("cg_eng_pll_func_ctl_2=0x%08x",tmp);
tmp = get_unaligned_be32(&tbl->cg_eng_pll_func_ctl_3);
L("cg_eng_pll_func_ctl_3=0x%08x",tmp);
tmp = get_unaligned_be32(&tbl->cg_eng_pll_ss_0);
L("cg_eng_pll_ss_0=0x%08x",tmp);
tmp = get_unaligned_be32(&tbl->cg_eng_pll_ss_1);
L("cg_eng_pll_ss_1=0x%08x",tmp);
tmp = get_unaligned_be32(&tbl->clk);
L("clk=0x%08x",tmp);
L("SMC_ENG_CLK END");
}
STATIC inline int INIT parse_header(u8 *input, int *skip, int in_len)
{
int l;
u8 *parse = input;
u8 *end = input + in_len;
u8 level = 0;
u16 version;
/*
*/
if (in_len < HEADER_SIZE_MIN)
return 0;
/* */
for (l = 0; l < 9; l++) {
if (*parse++ != lzop_magic[l])
return 0;
}
/*
*/
version = get_unaligned_be16(parse);
parse += 7;
if (version >= 0x0940)
level = *parse++;
if (get_unaligned_be32(parse) & HEADER_HAS_FILTER)
parse += 8; /* */
else
parse += 4; /* */
/*
*/
if (end - parse < 8 + 1 + 4)
return 0;
/* */
parse += 8;
if (version >= 0x0940)
parse += 4; /* */
l = *parse++;
/* */
if (end - parse < l + 4)
return 0;
parse += l + 4;
*skip = parse - input;
return 1;
}
static STATIC inline int INIT parse_header(u8 *input, int *skip, int in_len)
{
int l;
u8 *parse = input;
u8 *end = input + in_len;
u8 level = 0;
u16 version;
/*
* Check that there's enough input to possibly have a valid header.
* Then it is possible to parse several fields until the minimum
* size may have been used.
*/
if (in_len < HEADER_SIZE_MIN)
return 0;
/* read magic: 9 first bits */
for (l = 0; l < 9; l++) {
if (*parse++ != lzop_magic[l])
return 0;
}
/* get version (2bytes), skip library version (2),
* 'need to be extracted' version (2) and
* method (1) */
version = get_unaligned_be16(parse);
parse += 7;
if (version >= 0x0940)
level = *parse++;
if (get_unaligned_be32(parse) & HEADER_HAS_FILTER)
parse += 8; /* flags + filter info */
else
parse += 4; /* flags */
/*
* At least mode, mtime_low, filename length, and checksum must
* be left to be parsed. If also mtime_high is present, it's OK
* because the next input buffer check is after reading the
* filename length.
*/
if (end - parse < 8 + 1 + 4)
return 0;
/* skip mode and mtime_low */
parse += 8;
if (version >= 0x0940)
parse += 4; /* skip mtime_high */
l = *parse++;
/* don't care about the file name, and skip checksum */
if (end - parse < l + 4)
return 0;
parse += l + 4;
*skip = parse - input;
return 1;
}
/*
* Inode numbers in short-form directories can come in two versions,
* either 4 bytes or 8 bytes wide. These helpers deal with the
* two forms transparently by looking at the headers i8count field.
*
* For 64-bit inode number the most significant byte must be zero.
*/
static xfs_ino_t
xfs_dir2_sf_get_ino(
struct xfs_dir2_sf_hdr *hdr,
xfs_dir2_inou_t *from)
{
if (hdr->i8count)
return get_unaligned_be64(&from->i8.i) & 0x00ffffffffffffffULL;
else
return get_unaligned_be32(&from->i4.i);
}
/*
* Inode numbers in short-form directories can come in two versions,
* either 4 bytes or 8 bytes wide. These helpers deal with the
* two forms transparently by looking at the headers i8count field.
*
* For 64-bit inode number the most significant byte must be zero.
*/
static xfs_ino_t
xfs_dir2_sf_get_ino(
struct xfs_dir2_sf_hdr *hdr,
__uint8_t *from)
{
if (hdr->i8count)
return get_unaligned_be64(from) & 0x00ffffffffffffffULL;
else
return get_unaligned_be32(from);
}
uint8_t ssc_spout(struct scsi_cmd *cmd)
{
MHVTL_DBG(1, "Security Protocol Out (%ld) **",
(long)cmd->dbuf_p->serialNo);
cmd->dbuf_p->sz = get_unaligned_be32(&cmd->scb[6]);
/* Check for '512 increment' bit & multiply sz by 512 if set */
cmd->dbuf_p->sz *= (cmd->scb[4] & 0x80) ? 512 : 1;
retrieve_CDB_data(cmd->cdev, cmd->dbuf_p);
return resp_spout(cmd);
}
/*
* (1) len doesn't include the header by default. I want this.
*/
static int
aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt, struct net_device *orig_dev)
{
struct aoe_hdr *h;
u32 n;
if (dev_net(ifp) != &init_net)
goto exit;
skb = skb_share_check(skb, GFP_ATOMIC);
if (skb == NULL)
return 0;
if (skb_linearize(skb))
goto exit;
if (!is_aoe_netif(ifp))
goto exit;
skb_push(skb, ETH_HLEN); /* (1) */
h = (struct aoe_hdr *) skb_mac_header(skb);
n = get_unaligned_be32(&h->tag);
if ((h->verfl & AOEFL_RSP) == 0 || (n & 1<<31))
goto exit;
if (h->verfl & AOEFL_ERR) {
n = h->err;
if (n > NECODES)
n = 0;
if (net_ratelimit())
printk(KERN_ERR
"%s%d.%d@%s; ecode=%d '%s'\n",
"aoe: error packet from ",
get_unaligned_be16(&h->major),
h->minor, skb->dev->name,
h->err, aoe_errlist[n]);
goto exit;
}
switch (h->cmd) {
case AOECMD_ATA:
aoecmd_ata_rsp(skb);
break;
case AOECMD_CFG:
aoecmd_cfg_rsp(skb);
break;
default:
printk(KERN_INFO "aoe: unknown cmd %d\n", h->cmd);
}
exit:
dev_kfree_skb(skb);
return 0;
}
static int em_cmp_match(struct sk_buff *skb, struct tcf_ematch *em,
struct tcf_pkt_info *info)
{
struct tcf_em_cmp *cmp = (struct tcf_em_cmp *) em->data;
unsigned char *ptr = tcf_get_base_ptr(skb, cmp->layer) + cmp->off;
u32 val = 0;
if (!tcf_valid_offset(skb, ptr, cmp->align))
return 0;
switch (cmp->align) {
case TCF_EM_ALIGN_U8:
val = *ptr;
break;
case TCF_EM_ALIGN_U16:
val = get_unaligned_be16(ptr);
if (cmp_needs_transformation(cmp))
val = be16_to_cpu(val);
break;
case TCF_EM_ALIGN_U32:
/* Worth checking boundries? The branching seems
* to get worse. Visit again.
*/
val = get_unaligned_be32(ptr);
if (cmp_needs_transformation(cmp))
val = be32_to_cpu(val);
break;
default:
return 0;
}
if (cmp->mask)
val &= cmp->mask;
switch (cmp->opnd) {
case TCF_EM_OPND_EQ:
return val == cmp->val;
case TCF_EM_OPND_LT:
return val < cmp->val;
case TCF_EM_OPND_GT:
return val > cmp->val;
}
return 0;
}
static int tpm_tis_i2c_recv(struct udevice *dev, u8 *buf, size_t count)
{
struct tpm_chip *chip = dev_get_priv(dev);
int size = 0;
int status;
unsigned int expected;
int rc;
status = tpm_tis_i2c_status(dev);
if (status == TPM_STS_COMMAND_READY)
return -EINTR;
if ((status & (TPM_STS_DATA_AVAIL | TPM_STS_VALID)) !=
(TPM_STS_DATA_AVAIL | TPM_STS_VALID))
return -EAGAIN;
debug("...got it;\n");
/* Read first 10 bytes, including tag, paramsize, and result */
size = tpm_tis_i2c_recv_data(dev, buf, TPM_HEADER_SIZE);
if (size < TPM_HEADER_SIZE) {
debug("Unable to read header\n");
return size < 0 ? size : -EIO;
}
expected = get_unaligned_be32(buf + TPM_RSP_SIZE_BYTE);
if ((size_t)expected > count || (size_t)expected < TPM_HEADER_SIZE) {
debug("Error size=%x, expected=%x, count=%x\n", size, expected,
count);
return -ENOSPC;
}
size += tpm_tis_i2c_recv_data(dev, &buf[TPM_HEADER_SIZE],
expected - TPM_HEADER_SIZE);
if (size < expected) {
debug("Unable to read remainder of result\n");
return -ETIMEDOUT;
}
rc = tpm_tis_i2c_wait_for_stat(dev, TPM_STS_VALID, chip->timeout_c,
&status);
if (rc)
return rc;
if (status & TPM_STS_DATA_AVAIL) { /* Retry? */
debug("Error left over data\n");
return -EIO;
}
return size;
}
static int cyttsp5_verify_ttconfig_binary(struct device *dev,
u8 *bin_config_data, int bin_config_size, u8 **start, int *len)
{
struct cyttsp5_loader_data *ld = cyttsp5_get_loader_data(dev);
int header_size;
u16 config_size;
u32 fw_ver_config;
u32 fw_revctrl_config;
if (!ld->si) {
dev_err(dev, "%s: No firmware infomation found, device FW may be corrupted\n",
__func__);
return -ENODEV;
}
/*
* We need 11 bytes for FW version control info and at
* least 6 bytes in config (Length + Max Length + CRC)
*/
header_size = bin_config_data[0] + 1;
if (header_size < 11 || header_size >= bin_config_size - 6) {
dev_err(dev, "%s: Invalid header size %d\n", __func__,
header_size);
return -EINVAL;
}
fw_ver_config = get_unaligned_be16(&bin_config_data[1]);
/* 4 middle bytes are not used */
fw_revctrl_config = get_unaligned_be32(&bin_config_data[7]);
/* FW versions should match */
if (cyttsp5_check_firmware_version(dev, fw_ver_config,
fw_revctrl_config)) {
dev_err(dev, "%s: FW versions mismatch\n", __func__);
return -EINVAL;
}
config_size = get_unaligned_le16(&bin_config_data[header_size]);
/* Perform a simple size check (2 bytes for CRC) */
if (config_size != bin_config_size - header_size - 2) {
dev_err(dev, "%s: Config size invalid\n", __func__);
return -EINVAL;
}
*start = &bin_config_data[header_size];
*len = bin_config_size - header_size;
return 0;
}
int parse_dek_packet(char *data,
struct ecryptfs_crypt_stat *crypt_stat,
size_t *packet_size) {
int rc = 0;
char temp_comm[PKG_NAME_SIZE]; //test
int temp_euid;
(*packet_size) = 0;
if (data[(*packet_size)++] != ECRYPTFS_DEK_PACKET_TYPE) {
DEK_LOGE("First byte != 0x%.2x; invalid packet\n",
ECRYPTFS_DEK_PACKET_TYPE);
rc = -EINVAL;
}
memcpy(temp_comm, &data[*packet_size], PKG_NAME_SIZE);
(*packet_size) += PKG_NAME_SIZE;
temp_euid = get_unaligned_be32(data + *packet_size);
(*packet_size) += 4;
if (crypt_stat->flags & ECRYPTFS_DEK_IS_SENSITIVE) {
crypt_stat->sdp_dek.type = get_unaligned_be32(data + *packet_size);
(*packet_size) += 4;
crypt_stat->sdp_dek.len = get_unaligned_be32(data + *packet_size);
(*packet_size) += 4;
memcpy(crypt_stat->sdp_dek.buf, &data[*packet_size], crypt_stat->sdp_dek.len);
(*packet_size) += crypt_stat->sdp_dek.len;
}
#if ECRYPTFS_DEK_DEBUG
DEK_LOGD("%s() : comm : %s [euid:%d]\n",
__func__, temp_comm, temp_euid);
#endif
return rc;
}
/*
* tis_sendrecv()
*
* Send the requested data to the TPM and then try to get its response
*
* @sendbuf - buffer of the data to send
* @send_size size of the data to send
* @recvbuf - memory to save the response to
* @recv_len - pointer to the size of the response buffer
*
* Returns 0 on success (and places the number of response bytes at recv_len)
* or -1 on failure.
*/
int tis_sendrecv(const uint8_t *sendbuf, size_t send_size, uint8_t *recvbuf,
size_t *recv_len)
{
int res;
unsigned long start;
#ifdef DEBUG
memset(recvbuf, 0xcc, *recv_len);
printf("send to TPM (%d bytes, recv_len=%d):\n", send_size, *recv_len);
print_buffer(0, (void *)sendbuf, 1, send_size, 0);
#endif
res = i2c_write(0x29, 0, 0, (uchar *)sendbuf, send_size);
if (res) {
printf("i2c_write returned %d\n", res);
return -1;
}
start = get_timer(0);
while ((res = i2c_read(0x29, 0, 0, recvbuf, 10))) {
if (get_timer(start) > ATMEL_TPM_TIMEOUT_MS) {
puts("tpm timed out\n");
return -1;
}
udelay(100);
}
if (!res) {
*recv_len = get_unaligned_be32(recvbuf + 2);
if (*recv_len > 10)
res = i2c_read(0x29, 0, 0, recvbuf, *recv_len);
}
if (res) {
printf("i2c_read returned %d (rlen=%d)\n", res, *recv_len);
#ifdef DEBUG
print_buffer(0, recvbuf, 1, *recv_len, 0);
#endif
}
#ifdef DEBUG
if (!res) {
printf("read from TPM (%d bytes):\n", *recv_len);
print_buffer(0, recvbuf, 1, *recv_len, 0);
}
#endif
return res;
}
static void sm3_expand(u32 *t, u32 *w, u32 *wt)
{
int i;
unsigned int tmp;
/* load the input */
for (i = 0; i <= 15; i++)
w[i] = get_unaligned_be32((__u32 *)t + i);
for (i = 16; i <= 67; i++) {
tmp = w[i - 16] ^ w[i - 9] ^ rol32(w[i - 3], 15);
w[i] = p1(tmp) ^ (rol32(w[i - 13], 7)) ^ w[i - 6];
}
for (i = 0; i <= 63; i++)
wt[i] = w[i] ^ w[i + 4];
}
uint8_t ssc_pr_out(struct scsi_cmd *cmd)
{
struct priv_lu_ssc *lu_priv;
uint8_t *sam_stat = &cmd->dbuf_p->sam_stat;
lu_priv = cmd->lu->lu_private;
MHVTL_DBG(1, "PERSISTENT RESERVE OUT (%ld) **",
(long)cmd->dbuf_p->serialNo);
if (lu_priv->I_am_SPC_2_Reserved) {
MHVTL_DBG(1, "SPC 2 reserved");
*sam_stat = SAM_STAT_RESERVATION_CONFLICT;
return SAM_STAT_RESERVATION_CONFLICT;
}
cmd->dbuf_p->sz = get_unaligned_be32(&cmd->scb[5]);
retrieve_CDB_data(cmd->cdev, cmd->dbuf_p);
return resp_spc_pro(cmd->scb, cmd->dbuf_p);
}