tobi/M7350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
801e6d2ad8
M7350/kernel/drivers/crypto/msm/qce.c
T f9cc65cfda M7350v1_en_gpl
2024-09-09 08:52:07 +00:00

2625 lines
70 KiB
C
Raw Blame History

/* Qualcomm Crypto Engine driver.
*
* Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/device.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/dma-mapping.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <linux/spinlock.h>
#include <linux/delay.h>
#include <linux/crypto.h>
#include <crypto/hash.h>
#include <crypto/sha.h>
#include <linux/qcedev.h>
#include <linux/qcota.h>
#include <mach/dma.h>
#include "qce.h"
#include "qcryptohw_30.h"
#include "qce_ota.h"
/* ADM definitions */
#define LI_SG_CMD (1 << 31) /* last index in the scatter gather cmd */
#define SRC_INDEX_SG_CMD(index) ((index & 0x3fff) << 16)
#define DST_INDEX_SG_CMD(index) (index & 0x3fff)
#define ADM_DESC_LAST (1 << 31)
/* Data xfer between DM and CE in blocks of 16 bytes */
#define ADM_CE_BLOCK_SIZE 16
#define QCE_FIFO_SIZE 0x8000
/* Data xfer between DM and CE in blocks of 64 bytes */
#define ADM_SHA_BLOCK_SIZE 64
#define ADM_DESC_LENGTH_MASK 0xffff
#define ADM_DESC_LENGTH(x) (x & ADM_DESC_LENGTH_MASK)
struct dmov_desc {
uint32_t addr;
uint32_t len;
};
#define ADM_STATUS_OK 0x80000002
/* Misc definitions */
/* QCE max number of descriptor in a descriptor list */
#define QCE_MAX_NUM_DESC 128
/* State of DM channel */
enum qce_chan_st_enum {
QCE_CHAN_STATE_IDLE = 0,
QCE_CHAN_STATE_IN_PROG = 1,
QCE_CHAN_STATE_COMP = 2,
QCE_CHAN_STATE_LAST
};
/*
* CE HW device structure.
* Each engine has an instance of the structure.
* Each engine can only handle one crypto operation at one time. It is up to
* the sw above to ensure single threading of operation on an engine.
*/
struct qce_device {
struct device *pdev; /* Handle to platform_device structure */
unsigned char *coh_vmem; /* Allocated coherent virtual memory */
dma_addr_t coh_pmem; /* Allocated coherent physical memory */
void __iomem *iobase; /* Virtual io base of CE HW */
unsigned int phy_iobase; /* Physical io base of CE HW */
struct clk *ce_clk; /* Handle to CE clk */
unsigned int crci_in; /* CRCI for CE DM IN Channel */
unsigned int crci_out; /* CRCI for CE DM OUT Channel */
unsigned int crci_hash; /* CRCI for CE HASH */
unsigned int chan_ce_in; /* ADM channel used for CE input
* and auth result if authentication
* only operation. */
unsigned int chan_ce_out; /* ADM channel used for CE output,
and icv for esp */
unsigned int *cmd_pointer_list_ce_in;
dma_addr_t phy_cmd_pointer_list_ce_in;
unsigned int *cmd_pointer_list_ce_out;
dma_addr_t phy_cmd_pointer_list_ce_out;
unsigned char *cmd_list_ce_in;
dma_addr_t phy_cmd_list_ce_in;
unsigned char *cmd_list_ce_out;
dma_addr_t phy_cmd_list_ce_out;
struct dmov_desc *ce_out_src_desc;
dma_addr_t phy_ce_out_src_desc;
struct dmov_desc *ce_out_dst_desc;
dma_addr_t phy_ce_out_dst_desc;
struct dmov_desc *ce_in_src_desc;
dma_addr_t phy_ce_in_src_desc;
struct dmov_desc *ce_in_dst_desc;
dma_addr_t phy_ce_in_dst_desc;
unsigned char *ce_out_ignore;
dma_addr_t phy_ce_out_ignore;
unsigned char *ce_pad;
dma_addr_t phy_ce_pad;
struct msm_dmov_cmd *chan_ce_in_cmd;
struct msm_dmov_cmd *chan_ce_out_cmd;
uint32_t ce_out_ignore_size;
int ce_out_dst_desc_index;
int ce_in_dst_desc_index;
int ce_out_src_desc_index;
int ce_in_src_desc_index;
enum qce_chan_st_enum chan_ce_in_state; /* chan ce_in state */
enum qce_chan_st_enum chan_ce_out_state; /* chan ce_out state */
int chan_ce_in_status; /* chan ce_in status */
int chan_ce_out_status; /* chan ce_out status */
unsigned char *dig_result;
dma_addr_t phy_dig_result;
/* cached aes key */
uint32_t aeskey[AES256_KEY_SIZE/sizeof(uint32_t)];
uint32_t aes_key_size; /* cached aes key size in bytes */
int fastaes; /* ce supports fast aes */
int hmac; /* ce support hmac-sha1 */
bool ota; /* ce support ota */
qce_comp_func_ptr_t qce_cb; /* qce callback function pointer */
int assoc_nents;
int src_nents;
int dst_nents;
void *areq;
enum qce_cipher_mode_enum mode;
dma_addr_t phy_iv_in;
dma_addr_t phy_ota_src;
dma_addr_t phy_ota_dst;
unsigned int ota_size;
int err;
};
/* Standard initialization vector for SHA-1, source: FIPS 180-2 */
static uint32_t _std_init_vector_sha1[] = {
0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0
};
/* Standard initialization vector for SHA-256, source: FIPS 180-2 */
static uint32_t _std_init_vector_sha256[] = {
0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
};
/* Source: FIPS 197, Figure 7. S-box: substitution values for the byte xy */
static const uint32_t _s_box[256] = {
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };
/*
* Source: FIPS 197, Sec 5.2 Key Expansion, Figure 11. Pseudo Code for Key
* Expansion.
*/
static void _aes_expand_key_schedule(uint32_t keysize, uint32_t *AES_KEY,
uint32_t *AES_RND_KEY)
{
uint32_t i;
uint32_t Nk;
uint32_t Nr, rot_data;
uint32_t Rcon = 0x01000000;
uint32_t temp;
uint32_t data_in;
uint32_t MSB_store;
uint32_t byte_for_sub;
uint32_t word_sub[4];
switch (keysize) {
case 192:
Nk = 6;
Nr = 12;
break;
case 256:
Nk = 8;
Nr = 14;
break;
case 128:
default: /* default to AES128 */
Nk = 4;
Nr = 10;
break;
}
/* key expansion */
i = 0;
while (i < Nk) {
AES_RND_KEY[i] = AES_KEY[i];
i = i + 1;
}
i = Nk;
while (i < (4 * (Nr + 1))) {
temp = AES_RND_KEY[i-1];
if (Nr == 14) {
switch (i) {
case 8:
Rcon = 0x01000000;
break;
case 16:
Rcon = 0x02000000;
break;
case 24:
Rcon = 0x04000000;
break;
case 32:
Rcon = 0x08000000;
break;
case 40:
Rcon = 0x10000000;
break;
case 48:
Rcon = 0x20000000;
break;
case 56:
Rcon = 0x40000000;
break;
}
} else if (Nr == 12) {
switch (i) {
case 6:
Rcon = 0x01000000;
break;
case 12:
Rcon = 0x02000000;
break;
case 18:
Rcon = 0x04000000;
break;
case 24:
Rcon = 0x08000000;
break;
case 30:
Rcon = 0x10000000;
break;
case 36:
Rcon = 0x20000000;
break;
case 42:
Rcon = 0x40000000;
break;
case 48:
Rcon = 0x80000000;
break;
}
} else if (Nr == 10) {
switch (i) {
case 4:
Rcon = 0x01000000;
break;
case 8:
Rcon = 0x02000000;
break;
case 12:
Rcon = 0x04000000;
break;
case 16:
Rcon = 0x08000000;
break;
case 20:
Rcon = 0x10000000;
break;
case 24:
Rcon = 0x20000000;
break;
case 28:
Rcon = 0x40000000;
break;
case 32:
Rcon = 0x80000000;
break;
case 36:
Rcon = 0x1b000000;
break;
case 40:
Rcon = 0x36000000;
break;
}
}
if ((i % Nk) == 0) {
data_in = temp;
MSB_store = (data_in >> 24 & 0xff);
rot_data = (data_in << 8) | MSB_store;
byte_for_sub = rot_data;
word_sub[0] = _s_box[(byte_for_sub & 0xff)];
word_sub[1] = (_s_box[((byte_for_sub & 0xff00) >> 8)]
<< 8);
word_sub[2] = (_s_box[((byte_for_sub & 0xff0000) >> 16)]
<< 16);
word_sub[3] = (_s_box[((byte_for_sub & 0xff000000)
>> 24)] << 24);
word_sub[0] = word_sub[0] | word_sub[1] | word_sub[2] |
word_sub[3];
temp = word_sub[0] ^ Rcon;
} else if ((Nk > 6) && ((i % Nk) == 4)) {
byte_for_sub = temp;
word_sub[0] = _s_box[(byte_for_sub & 0xff)];
word_sub[1] = (_s_box[((byte_for_sub & 0xff00) >> 8)]
<< 8);
word_sub[2] = (_s_box[((byte_for_sub & 0xff0000) >> 16)]
<< 16);
word_sub[3] = (_s_box[((byte_for_sub & 0xff000000) >>
24)] << 24);
word_sub[0] = word_sub[0] | word_sub[1] | word_sub[2] |
word_sub[3];
temp = word_sub[0];
}
AES_RND_KEY[i] = AES_RND_KEY[i-Nk]^temp;
i = i+1;
}
}
static void _byte_stream_to_net_words(uint32_t *iv, unsigned char *b,
unsigned int len)
{
unsigned n;
n = len / sizeof(uint32_t) ;
for (; n > 0; n--) {
*iv = ((*b << 24) & 0xff000000) |
(((*(b+1)) << 16) & 0xff0000) |
(((*(b+2)) << 8) & 0xff00) |
(*(b+3) & 0xff);
b += sizeof(uint32_t);
iv++;
}
n = len % sizeof(uint32_t);
if (n == 3) {
*iv = ((*b << 24) & 0xff000000) |
(((*(b+1)) << 16) & 0xff0000) |
(((*(b+2)) << 8) & 0xff00) ;
} else if (n == 2) {
*iv = ((*b << 24) & 0xff000000) |
(((*(b+1)) << 16) & 0xff0000) ;
} else if (n == 1) {
*iv = ((*b << 24) & 0xff000000) ;
}
}
static void _net_words_to_byte_stream(uint32_t *iv, unsigned char *b,
unsigned int len)
{
unsigned n = len / sizeof(uint32_t);
for (; n > 0; n--) {
*b++ = (unsigned char) ((*iv >> 24) & 0xff);
*b++ = (unsigned char) ((*iv >> 16) & 0xff);
*b++ = (unsigned char) ((*iv >> 8) & 0xff);
*b++ = (unsigned char) (*iv & 0xff);
iv++;
}
n = len % sizeof(uint32_t);
if (n == 3) {
*b++ = (unsigned char) ((*iv >> 24) & 0xff);
*b++ = (unsigned char) ((*iv >> 16) & 0xff);
*b = (unsigned char) ((*iv >> 8) & 0xff);
} else if (n == 2) {
*b++ = (unsigned char) ((*iv >> 24) & 0xff);
*b = (unsigned char) ((*iv >> 16) & 0xff);
} else if (n == 1) {
*b = (unsigned char) ((*iv >> 24) & 0xff);
}
}
static int count_sg(struct scatterlist *sg, int nbytes)
{
int i;
for (i = 0; nbytes > 0; i++, sg = scatterwalk_sg_next(sg))
nbytes -= sg->length;
return i;
}
static int qce_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
enum dma_data_direction direction)
{
int i;
for (i = 0; i < nents; ++i) {
dma_map_sg(dev, sg, 1, direction);
sg = scatterwalk_sg_next(sg);
}
return nents;
}
static int qce_dma_unmap_sg(struct device *dev, struct scatterlist *sg,
int nents, enum dma_data_direction direction)
{
int i;
for (i = 0; i < nents; ++i) {
dma_unmap_sg(dev, sg, 1, direction);
sg = scatterwalk_sg_next(sg);
}
return nents;
}
static int _probe_ce_engine(struct qce_device *pce_dev)
{
unsigned int val;
unsigned int rev;
unsigned int eng_availability; /* engine available functions */
val = readl_relaxed(pce_dev->iobase + CRYPTO_STATUS_REG);
if ((val & 0xfffffff) != 0x0200004) {
dev_err(pce_dev->pdev,
"unknown Qualcomm crypto device at 0x%x 0x%x\n",
pce_dev->phy_iobase, val);
return -EIO;
};
rev = (val & CRYPTO_CORE_REV_MASK) >> CRYPTO_CORE_REV;
if (rev == 0x2) {
dev_info(pce_dev->pdev,
"Qualcomm Crypto 3e device found at 0x%x\n",
pce_dev->phy_iobase);
} else if (rev == 0x1) {
dev_info(pce_dev->pdev,
"Qualcomm Crypto 3 device found at 0x%x\n",
pce_dev->phy_iobase);
} else if (rev == 0x0) {
dev_info(pce_dev->pdev,
"Qualcomm Crypto 2 device found at 0x%x\n",
pce_dev->phy_iobase);
} else {
dev_err(pce_dev->pdev,
"unknown Qualcomm crypto device at 0x%x\n",
pce_dev->phy_iobase);
return -EIO;
}
eng_availability = readl_relaxed(pce_dev->iobase +
CRYPTO_ENGINES_AVAIL);
if (((eng_availability & CRYPTO_AES_SEL_MASK) >> CRYPTO_AES_SEL)
== CRYPTO_AES_SEL_FAST)
pce_dev->fastaes = 1;
else
pce_dev->fastaes = 0;
if (eng_availability & (1 << CRYPTO_HMAC_SEL))
pce_dev->hmac = 1;
else
pce_dev->hmac = 0;
if ((eng_availability & (1 << CRYPTO_F9_SEL)) &&
(eng_availability & (1 << CRYPTO_F8_SEL)))
pce_dev->ota = true;
else
pce_dev->ota = false;
pce_dev->aes_key_size = 0;
return 0;
};
static int _init_ce_engine(struct qce_device *pce_dev)
{
unsigned int val;
/* reset qce */
writel_relaxed(1 << CRYPTO_SW_RST, pce_dev->iobase + CRYPTO_CONFIG_REG);
/* Ensure previous instruction (write to reset bit)
* was completed.
*/
mb();
/* configure ce */
val = (1 << CRYPTO_MASK_DOUT_INTR) | (1 << CRYPTO_MASK_DIN_INTR) |
(1 << CRYPTO_MASK_AUTH_DONE_INTR) |
(1 << CRYPTO_MASK_ERR_INTR);
writel_relaxed(val, pce_dev->iobase + CRYPTO_CONFIG_REG);
if (_probe_ce_engine(pce_dev) < 0)
return -EIO;
if (readl_relaxed(pce_dev->iobase + CRYPTO_CONFIG_REG) != val) {
dev_err(pce_dev->pdev,
"unknown Qualcomm crypto device at 0x%x\n",
pce_dev->phy_iobase);
return -EIO;
};
return 0;
};
static int _sha_ce_setup(struct qce_device *pce_dev, struct qce_sha_req *sreq)
{
uint32_t auth32[SHA256_DIGEST_SIZE / sizeof(uint32_t)];
uint32_t diglen;
int rc;
int i;
uint32_t cfg = 0;
/* if not the last, the size has to be on the block boundary */
if (sreq->last_blk == 0 && (sreq->size % SHA256_BLOCK_SIZE))
return -EIO;
switch (sreq->alg) {
case QCE_HASH_SHA1:
diglen = SHA1_DIGEST_SIZE;
break;
case QCE_HASH_SHA256:
diglen = SHA256_DIGEST_SIZE;
break;
default:
return -EINVAL;
}
/*
* write 20/32 bytes, 5/8 words into auth_iv
* for SHA1/SHA256
*/
if (sreq->first_blk) {
if (sreq->alg == QCE_HASH_SHA1) {
for (i = 0; i < 5; i++)
auth32[i] = _std_init_vector_sha1[i];
} else {
for (i = 0; i < 8; i++)
auth32[i] = _std_init_vector_sha256[i];
}
} else
_byte_stream_to_net_words(auth32, sreq->digest, diglen);
rc = clk_enable(pce_dev->ce_clk);
if (rc)
return rc;
writel_relaxed(auth32[0], pce_dev->iobase + CRYPTO_AUTH_IV0_REG);
writel_relaxed(auth32[1], pce_dev->iobase + CRYPTO_AUTH_IV1_REG);
writel_relaxed(auth32[2], pce_dev->iobase + CRYPTO_AUTH_IV2_REG);
writel_relaxed(auth32[3], pce_dev->iobase + CRYPTO_AUTH_IV3_REG);
writel_relaxed(auth32[4], pce_dev->iobase + CRYPTO_AUTH_IV4_REG);
if (sreq->alg == QCE_HASH_SHA256) {
writel_relaxed(auth32[5], pce_dev->iobase +
CRYPTO_AUTH_IV5_REG);
writel_relaxed(auth32[6], pce_dev->iobase +
CRYPTO_AUTH_IV6_REG);
writel_relaxed(auth32[7], pce_dev->iobase +
CRYPTO_AUTH_IV7_REG);
}
/* write auth_bytecnt 0/1, start with 0 */
writel_relaxed(sreq->auth_data[0], pce_dev->iobase +
CRYPTO_AUTH_BYTECNT0_REG);
writel_relaxed(sreq->auth_data[1], pce_dev->iobase +
CRYPTO_AUTH_BYTECNT1_REG);
/* write auth_seg_cfg */
writel_relaxed(sreq->size << CRYPTO_AUTH_SEG_SIZE,
pce_dev->iobase + CRYPTO_AUTH_SEG_CFG_REG);
/*
* write seg_cfg
*/
if (sreq->alg == QCE_HASH_SHA1)
cfg |= (CRYPTO_AUTH_SIZE_SHA1 << CRYPTO_AUTH_SIZE);
else
cfg = (CRYPTO_AUTH_SIZE_SHA256 << CRYPTO_AUTH_SIZE);
if (sreq->first_blk)
cfg |= 1 << CRYPTO_FIRST;
if (sreq->last_blk)
cfg |= 1 << CRYPTO_LAST;
cfg |= CRYPTO_AUTH_ALG_SHA << CRYPTO_AUTH_ALG;
writel_relaxed(cfg, pce_dev->iobase + CRYPTO_SEG_CFG_REG);
/* write seg_size */
writel_relaxed(sreq->size, pce_dev->iobase + CRYPTO_SEG_SIZE_REG);
/* issue go to crypto */
writel_relaxed(1 << CRYPTO_GO, pce_dev->iobase + CRYPTO_GOPROC_REG);
/* Ensure previous instructions (setting the GO register)
* was completed before issuing a DMA transfer request
*/
mb();
return 0;
}
static int _ce_setup(struct qce_device *pce_dev, struct qce_req *q_req,
uint32_t totallen, uint32_t coffset)
{
uint32_t hmackey[HMAC_KEY_SIZE/sizeof(uint32_t)] = {
0, 0, 0, 0, 0};
uint32_t enckey32[MAX_CIPHER_KEY_SIZE/sizeof(uint32_t)] = {
0, 0, 0, 0, 0, 0, 0, 0};
uint32_t enciv32[MAX_IV_LENGTH / sizeof(uint32_t)] = {
0, 0, 0, 0};
uint32_t enck_size_in_word = q_req->encklen / sizeof(uint32_t);
int aes_key_chg;
int i, rc;
uint32_t aes_round_key[CRYPTO_AES_RNDKEYS];
uint32_t cfg;
uint32_t ivsize = q_req->ivsize;
rc = clk_enable(pce_dev->ce_clk);
if (rc)
return rc;
cfg = (1 << CRYPTO_FIRST) | (1 << CRYPTO_LAST);
if (q_req->op == QCE_REQ_AEAD) {
/* do authentication setup */
cfg |= (CRYPTO_AUTH_SIZE_HMAC_SHA1 << CRYPTO_AUTH_SIZE)|
(CRYPTO_AUTH_ALG_SHA << CRYPTO_AUTH_ALG);
/* write sha1 init vector */
writel_relaxed(_std_init_vector_sha1[0],
pce_dev->iobase + CRYPTO_AUTH_IV0_REG);
writel_relaxed(_std_init_vector_sha1[1],
pce_dev->iobase + CRYPTO_AUTH_IV1_REG);
writel_relaxed(_std_init_vector_sha1[2],
pce_dev->iobase + CRYPTO_AUTH_IV2_REG);
writel_relaxed(_std_init_vector_sha1[3],
pce_dev->iobase + CRYPTO_AUTH_IV3_REG);
writel_relaxed(_std_init_vector_sha1[4],
pce_dev->iobase + CRYPTO_AUTH_IV4_REG);
/* write hmac key */
_byte_stream_to_net_words(hmackey, q_req->authkey,
q_req->authklen);
writel_relaxed(hmackey[0], pce_dev->iobase +
CRYPTO_AUTH_IV5_REG);
writel_relaxed(hmackey[1], pce_dev->iobase +
CRYPTO_AUTH_IV6_REG);
writel_relaxed(hmackey[2], pce_dev->iobase +
CRYPTO_AUTH_IV7_REG);
writel_relaxed(hmackey[3], pce_dev->iobase +
CRYPTO_AUTH_IV8_REG);
writel_relaxed(hmackey[4], pce_dev->iobase +
CRYPTO_AUTH_IV9_REG);
writel_relaxed(0, pce_dev->iobase + CRYPTO_AUTH_BYTECNT0_REG);
writel_relaxed(0, pce_dev->iobase + CRYPTO_AUTH_BYTECNT1_REG);
/* write auth_seg_cfg */
writel_relaxed((totallen << CRYPTO_AUTH_SEG_SIZE) & 0xffff0000,
pce_dev->iobase + CRYPTO_AUTH_SEG_CFG_REG);
}
_byte_stream_to_net_words(enckey32, q_req->enckey, q_req->encklen);
switch (q_req->mode) {
case QCE_MODE_ECB:
cfg |= (CRYPTO_ENCR_MODE_ECB << CRYPTO_ENCR_MODE);
break;
case QCE_MODE_CBC:
cfg |= (CRYPTO_ENCR_MODE_CBC << CRYPTO_ENCR_MODE);
break;
case QCE_MODE_CTR:
default:
cfg |= (CRYPTO_ENCR_MODE_CTR << CRYPTO_ENCR_MODE);
break;
}
pce_dev->mode = q_req->mode;
switch (q_req->alg) {
case CIPHER_ALG_DES:
if (q_req->mode != QCE_MODE_ECB) {
_byte_stream_to_net_words(enciv32, q_req->iv, ivsize);
writel_relaxed(enciv32[0], pce_dev->iobase +
CRYPTO_CNTR0_IV0_REG);
writel_relaxed(enciv32[1], pce_dev->iobase +
CRYPTO_CNTR1_IV1_REG);
}
writel_relaxed(enckey32[0], pce_dev->iobase +
CRYPTO_DES_KEY0_REG);
writel_relaxed(enckey32[1], pce_dev->iobase +
CRYPTO_DES_KEY1_REG);
cfg |= ((CRYPTO_ENCR_KEY_SZ_DES << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_DES << CRYPTO_ENCR_ALG));
break;
case CIPHER_ALG_3DES:
if (q_req->mode != QCE_MODE_ECB) {
_byte_stream_to_net_words(enciv32, q_req->iv, ivsize);
writel_relaxed(enciv32[0], pce_dev->iobase +
CRYPTO_CNTR0_IV0_REG);
writel_relaxed(enciv32[1], pce_dev->iobase +
CRYPTO_CNTR1_IV1_REG);
}
writel_relaxed(enckey32[0], pce_dev->iobase +
CRYPTO_DES_KEY0_REG);
writel_relaxed(enckey32[1], pce_dev->iobase +
CRYPTO_DES_KEY1_REG);
writel_relaxed(enckey32[2], pce_dev->iobase +
CRYPTO_DES_KEY2_REG);
writel_relaxed(enckey32[3], pce_dev->iobase +
CRYPTO_DES_KEY3_REG);
writel_relaxed(enckey32[4], pce_dev->iobase +
CRYPTO_DES_KEY4_REG);
writel_relaxed(enckey32[5], pce_dev->iobase +
CRYPTO_DES_KEY5_REG);
cfg |= ((CRYPTO_ENCR_KEY_SZ_3DES << CRYPTO_ENCR_KEY_SZ) |
(CRYPTO_ENCR_ALG_DES << CRYPTO_ENCR_ALG));
break;
case CIPHER_ALG_AES:
default:
if (q_req->mode != QCE_MODE_ECB) {
_byte_stream_to_net_words(enciv32, q_req->iv, ivsize);
writel_relaxed(enciv32[0], pce_dev->iobase +
CRYPTO_CNTR0_IV0_REG);
writel_relaxed(enciv32[1], pce_dev->iobase +
CRYPTO_CNTR1_IV1_REG);
writel_relaxed(enciv32[2], pce_dev->iobase +
CRYPTO_CNTR2_IV2_REG);
writel_relaxed(enciv32[3], pce_dev->iobase +
CRYPTO_CNTR3_IV3_REG);
}
/* set number of counter bits */
writel_relaxed(0xffff, pce_dev->iobase + CRYPTO_CNTR_MASK_REG);
if (q_req->op == QCE_REQ_ABLK_CIPHER_NO_KEY) {
cfg |= (CRYPTO_ENCR_KEY_SZ_AES128 <<
CRYPTO_ENCR_KEY_SZ);
cfg |= CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG;
} else {
switch (q_req->encklen) {
case AES128_KEY_SIZE:
cfg |= (CRYPTO_ENCR_KEY_SZ_AES128 <<
CRYPTO_ENCR_KEY_SZ);
break;
case AES192_KEY_SIZE:
cfg |= (CRYPTO_ENCR_KEY_SZ_AES192 <<
CRYPTO_ENCR_KEY_SZ);
break;
case AES256_KEY_SIZE:
default:
cfg |= (CRYPTO_ENCR_KEY_SZ_AES256 <<
CRYPTO_ENCR_KEY_SZ);
/* check for null key. If null, use hw key*/
for (i = 0; i < enck_size_in_word; i++) {
if (enckey32[i] != 0)
break;
}
if (i == enck_size_in_word)
cfg |= 1 << CRYPTO_USE_HW_KEY;
break;
} /* end of switch (q_req->encklen) */
cfg |= CRYPTO_ENCR_ALG_AES << CRYPTO_ENCR_ALG;
if (pce_dev->aes_key_size != q_req->encklen)
aes_key_chg = 1;
else {
for (i = 0; i < enck_size_in_word; i++) {
if (enckey32[i] != pce_dev->aeskey[i])
break;
}
aes_key_chg = (i == enck_size_in_word) ? 0 : 1;
}
if (aes_key_chg) {
if (pce_dev->fastaes) {
for (i = 0; i < enck_size_in_word;
i++) {
writel_relaxed(enckey32[i],
pce_dev->iobase +
CRYPTO_AES_RNDKEY0 +
(i * sizeof(uint32_t)));
}
} else {
/* size in bit */
_aes_expand_key_schedule(
q_req->encklen * 8,
enckey32, aes_round_key);
for (i = 0; i < CRYPTO_AES_RNDKEYS;
i++) {
writel_relaxed(aes_round_key[i],
pce_dev->iobase +
CRYPTO_AES_RNDKEY0 +
(i * sizeof(uint32_t)));
}
}
pce_dev->aes_key_size = q_req->encklen;
for (i = 0; i < enck_size_in_word; i++)
pce_dev->aeskey[i] = enckey32[i];
} /*if (aes_key_chg) { */
} /* else of if (q_req->op == QCE_REQ_ABLK_CIPHER_NO_KEY) */
break;
} /* end of switch (q_req->mode) */
if (q_req->dir == QCE_ENCRYPT)
cfg |= (1 << CRYPTO_AUTH_POS);
cfg |= ((q_req->dir == QCE_ENCRYPT) ? 1 : 0) << CRYPTO_ENCODE;
/* write encr seg cfg */
writel_relaxed((q_req->cryptlen << CRYPTO_ENCR_SEG_SIZE) |
(coffset & 0xffff), /* cipher offset */
pce_dev->iobase + CRYPTO_ENCR_SEG_CFG_REG);
/* write seg cfg and size */
writel_relaxed(cfg, pce_dev->iobase + CRYPTO_SEG_CFG_REG);
writel_relaxed(totallen, pce_dev->iobase + CRYPTO_SEG_SIZE_REG);
/* issue go to crypto */
writel_relaxed(1 << CRYPTO_GO, pce_dev->iobase + CRYPTO_GOPROC_REG);
/* Ensure previous instructions (setting the GO register)
* was completed before issuing a DMA transfer request
*/
mb();
return 0;
};
static int _aead_complete(struct qce_device *pce_dev)
{
struct aead_request *areq;
struct crypto_aead *aead;
uint32_t ivsize;
uint32_t iv_out[4];
unsigned char iv[4 * sizeof(uint32_t)];
uint32_t status;
areq = (struct aead_request *) pce_dev->areq;
aead = crypto_aead_reqtfm(areq);
ivsize = crypto_aead_ivsize(aead);
if (areq->src != areq->dst) {
qce_dma_unmap_sg(pce_dev->pdev, areq->dst, pce_dev->dst_nents,
DMA_FROM_DEVICE);
}
qce_dma_unmap_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
dma_unmap_single(pce_dev->pdev, pce_dev->phy_iv_in,
ivsize, DMA_TO_DEVICE);
qce_dma_unmap_sg(pce_dev->pdev, areq->assoc, pce_dev->assoc_nents,
DMA_TO_DEVICE);
/* check ce error status */
status = readl_relaxed(pce_dev->iobase + CRYPTO_STATUS_REG);
if (status & (1 << CRYPTO_SW_ERR)) {
pce_dev->err++;
dev_err(pce_dev->pdev,
"Qualcomm Crypto Error at 0x%x, status%x\n",
pce_dev->phy_iobase, status);
_init_ce_engine(pce_dev);
clk_disable(pce_dev->ce_clk);
pce_dev->qce_cb(areq, pce_dev->dig_result, NULL, -ENXIO);
return 0;
};
/* get iv out */
if (pce_dev->mode == QCE_MODE_ECB) {
clk_disable(pce_dev->ce_clk);
pce_dev->qce_cb(areq, pce_dev->dig_result, NULL,
pce_dev->chan_ce_in_status |
pce_dev->chan_ce_out_status);
} else {
iv_out[0] = readl_relaxed(pce_dev->iobase +
CRYPTO_CNTR0_IV0_REG);
iv_out[1] = readl_relaxed(pce_dev->iobase +
CRYPTO_CNTR1_IV1_REG);
iv_out[2] = readl_relaxed(pce_dev->iobase +
CRYPTO_CNTR2_IV2_REG);
iv_out[3] = readl_relaxed(pce_dev->iobase +
CRYPTO_CNTR3_IV3_REG);
_net_words_to_byte_stream(iv_out, iv, sizeof(iv));
clk_disable(pce_dev->ce_clk);
pce_dev->qce_cb(areq, pce_dev->dig_result, iv,
pce_dev->chan_ce_in_status |
pce_dev->chan_ce_out_status);
};
return 0;
};
static void _sha_complete(struct qce_device *pce_dev)
{
struct ahash_request *areq;
uint32_t auth_data[2];
uint32_t status;
areq = (struct ahash_request *) pce_dev->areq;
qce_dma_unmap_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
DMA_TO_DEVICE);
/* check ce error status */
status = readl_relaxed(pce_dev->iobase + CRYPTO_STATUS_REG);
if (status & (1 << CRYPTO_SW_ERR)) {
pce_dev->err++;
dev_err(pce_dev->pdev,
"Qualcomm Crypto Error at 0x%x, status%x\n",
pce_dev->phy_iobase, status);
_init_ce_engine(pce_dev);
clk_disable(pce_dev->ce_clk);
pce_dev->qce_cb(areq, pce_dev->dig_result, NULL, -ENXIO);
return;
};
auth_data[0] = readl_relaxed(pce_dev->iobase +
CRYPTO_AUTH_BYTECNT0_REG);
auth_data[1] = readl_relaxed(pce_dev->iobase +
CRYPTO_AUTH_BYTECNT1_REG);
/* Ensure previous instruction (retriving byte count information)
* was completed before disabling the clk.
*/
mb();
clk_disable(pce_dev->ce_clk);
pce_dev->qce_cb(areq, pce_dev->dig_result, (unsigned char *)auth_data,
pce_dev->chan_ce_in_status);
};
static int _ablk_cipher_complete(struct qce_device *pce_dev)
{
struct ablkcipher_request *areq;
uint32_t iv_out[4];
unsigned char iv[4 * sizeof(uint32_t)];
uint32_t status;
areq = (struct ablkcipher_request *) pce_dev->areq;
if (areq->src != areq->dst) {
qce_dma_unmap_sg(pce_dev->pdev, areq->dst,
pce_dev->dst_nents, DMA_FROM_DEVICE);
}
qce_dma_unmap_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
/* check ce error status */
status = readl_relaxed(pce_dev->iobase + CRYPTO_STATUS_REG);
if (status & (1 << CRYPTO_SW_ERR)) {
pce_dev->err++;
dev_err(pce_dev->pdev,
"Qualcomm Crypto Error at 0x%x, status%x\n",
pce_dev->phy_iobase, status);
_init_ce_engine(pce_dev);
clk_disable(pce_dev->ce_clk);
pce_dev->qce_cb(areq, NULL, NULL, -ENXIO);
return 0;
};
/* get iv out */
if (pce_dev->mode == QCE_MODE_ECB) {
clk_disable(pce_dev->ce_clk);
pce_dev->qce_cb(areq, NULL, NULL, pce_dev->chan_ce_in_status |
pce_dev->chan_ce_out_status);
} else {
iv_out[0] = readl_relaxed(pce_dev->iobase +
CRYPTO_CNTR0_IV0_REG);
iv_out[1] = readl_relaxed(pce_dev->iobase +
CRYPTO_CNTR1_IV1_REG);
iv_out[2] = readl_relaxed(pce_dev->iobase +
CRYPTO_CNTR2_IV2_REG);
iv_out[3] = readl_relaxed(pce_dev->iobase +
CRYPTO_CNTR3_IV3_REG);
_net_words_to_byte_stream(iv_out, iv, sizeof(iv));
clk_disable(pce_dev->ce_clk);
pce_dev->qce_cb(areq, NULL, iv, pce_dev->chan_ce_in_status |
pce_dev->chan_ce_out_status);
}
return 0;
};
static int qce_split_and_insert_dm_desc(struct dmov_desc *pdesc,
unsigned int plen, unsigned int paddr, int *index)
{
while (plen > QCE_FIFO_SIZE) {
pdesc->len = QCE_FIFO_SIZE;
if (paddr > 0) {
pdesc->addr = paddr;
paddr += QCE_FIFO_SIZE;
}
plen -= pdesc->len;
if (plen > 0) {
*index = (*index) + 1;
if ((*index) >= QCE_MAX_NUM_DESC)
return -ENOMEM;
pdesc++;
}
}
if ((plen > 0) && (plen <= QCE_FIFO_SIZE)) {
pdesc->len = plen;
if (paddr > 0)
pdesc->addr = paddr;
}
return 0;
}
static int _chain_sg_buffer_in(struct qce_device *pce_dev,
struct scatterlist *sg, unsigned int nbytes)
{
unsigned int len;
unsigned int dlen;
struct dmov_desc *pdesc;
pdesc = pce_dev->ce_in_src_desc + pce_dev->ce_in_src_desc_index;
/*
* Two consective chunks may be handled by the old
* buffer descriptor.
*/
while (nbytes > 0) {
len = min(nbytes, sg_dma_len(sg));
dlen = pdesc->len & ADM_DESC_LENGTH_MASK;
nbytes -= len;
if (dlen == 0) {
pdesc->addr = sg_dma_address(sg);
pdesc->len = len;
if (pdesc->len > QCE_FIFO_SIZE) {
if (qce_split_and_insert_dm_desc(pdesc,
pdesc->len, sg_dma_address(sg),
&pce_dev->ce_in_src_desc_index))
return -EIO;
}
} else if (sg_dma_address(sg) == (pdesc->addr + dlen)) {
pdesc->len = dlen + len;
if (pdesc->len > QCE_FIFO_SIZE) {
if (qce_split_and_insert_dm_desc(pdesc,
pdesc->len, pdesc->addr,
&pce_dev->ce_in_src_desc_index))
return -EIO;
}
} else {
pce_dev->ce_in_src_desc_index++;
if (pce_dev->ce_in_src_desc_index >= QCE_MAX_NUM_DESC)
return -ENOMEM;
pdesc++;
pdesc->len = len;
pdesc->addr = sg_dma_address(sg);
if (pdesc->len > QCE_FIFO_SIZE) {
if (qce_split_and_insert_dm_desc(pdesc,
pdesc->len, sg_dma_address(sg),
&pce_dev->ce_in_src_desc_index))
return -EIO;
}
}
if (nbytes > 0)
sg = scatterwalk_sg_next(sg);
}
return 0;
}
static int _chain_pm_buffer_in(struct qce_device *pce_dev,
unsigned int pmem, unsigned int nbytes)
{
unsigned int dlen;
struct dmov_desc *pdesc;
pdesc = pce_dev->ce_in_src_desc + pce_dev->ce_in_src_desc_index;
dlen = pdesc->len & ADM_DESC_LENGTH_MASK;
if (dlen == 0) {
pdesc->addr = pmem;
pdesc->len = nbytes;
} else if (pmem == (pdesc->addr + dlen)) {
pdesc->len = dlen + nbytes;
} else {
pce_dev->ce_in_src_desc_index++;
if (pce_dev->ce_in_src_desc_index >= QCE_MAX_NUM_DESC)
return -ENOMEM;
pdesc++;
pdesc->len = nbytes;
pdesc->addr = pmem;
}
return 0;
}
static void _chain_buffer_in_init(struct qce_device *pce_dev)
{
struct dmov_desc *pdesc;
pce_dev->ce_in_src_desc_index = 0;
pce_dev->ce_in_dst_desc_index = 0;
pdesc = pce_dev->ce_in_src_desc;
pdesc->len = 0;
}
static void _ce_in_final(struct qce_device *pce_dev, int ncmd, unsigned total)
{
struct dmov_desc *pdesc;
dmov_sg *pcmd;
pdesc = pce_dev->ce_in_src_desc + pce_dev->ce_in_src_desc_index;
pdesc->len |= ADM_DESC_LAST;
pdesc = pce_dev->ce_in_dst_desc;
if (total > QCE_FIFO_SIZE) {
qce_split_and_insert_dm_desc(pdesc, total, 0,
&pce_dev->ce_in_dst_desc_index);
pdesc = pce_dev->ce_in_dst_desc + pce_dev->ce_in_dst_desc_index;
pdesc->len |= ADM_DESC_LAST;
} else
pdesc->len = ADM_DESC_LAST | total;
pcmd = (dmov_sg *) pce_dev->cmd_list_ce_in;
if (ncmd == 1)
pcmd->cmd |= CMD_LC;
else {
dmov_s *pscmd;
pcmd->cmd &= ~CMD_LC;
pcmd++;
pscmd = (dmov_s *)pcmd;
pscmd->cmd |= CMD_LC;
}
#ifdef QCE_DEBUG
dev_info(pce_dev->pdev, "_ce_in_final %d\n",
pce_dev->ce_in_src_desc_index);
#endif
}
#ifdef QCE_DEBUG
static void _ce_in_dump(struct qce_device *pce_dev)
{
int i;
struct dmov_desc *pdesc;
dev_info(pce_dev->pdev, "_ce_in_dump: src\n");
for (i = 0; i <= pce_dev->ce_in_src_desc_index; i++) {
pdesc = pce_dev->ce_in_src_desc + i;
dev_info(pce_dev->pdev, "%x , %x\n", pdesc->addr,
pdesc->len);
}
dev_info(pce_dev->pdev, "_ce_in_dump: dst\n");
for (i = 0; i <= pce_dev->ce_in_dst_desc_index; i++) {
pdesc = pce_dev->ce_in_dst_desc + i;
dev_info(pce_dev->pdev, "%x , %x\n", pdesc->addr,
pdesc->len);
}
};
static void _ce_out_dump(struct qce_device *pce_dev)
{
int i;
struct dmov_desc *pdesc;
dev_info(pce_dev->pdev, "_ce_out_dump: src\n");
for (i = 0; i <= pce_dev->ce_out_src_desc_index; i++) {
pdesc = pce_dev->ce_out_src_desc + i;
dev_info(pce_dev->pdev, "%x , %x\n", pdesc->addr,
pdesc->len);
}
dev_info(pce_dev->pdev, "_ce_out_dump: dst\n");
for (i = 0; i <= pce_dev->ce_out_dst_desc_index; i++) {
pdesc = pce_dev->ce_out_dst_desc + i;
dev_info(pce_dev->pdev, "%x , %x\n", pdesc->addr,
pdesc->len);
}
};
#endif
static int _chain_sg_buffer_out(struct qce_device *pce_dev,
struct scatterlist *sg, unsigned int nbytes)
{
unsigned int len;
unsigned int dlen;
struct dmov_desc *pdesc;
pdesc = pce_dev->ce_out_dst_desc + pce_dev->ce_out_dst_desc_index;
/*
* Two consective chunks may be handled by the old
* buffer descriptor.
*/
while (nbytes > 0) {
len = min(nbytes, sg_dma_len(sg));
dlen = pdesc->len & ADM_DESC_LENGTH_MASK;
nbytes -= len;
if (dlen == 0) {
pdesc->addr = sg_dma_address(sg);
pdesc->len = len;
if (pdesc->len > QCE_FIFO_SIZE) {
if (qce_split_and_insert_dm_desc(pdesc,
pdesc->len, sg_dma_address(sg),
&pce_dev->ce_out_dst_desc_index))
return -EIO;
}
} else if (sg_dma_address(sg) == (pdesc->addr + dlen)) {
pdesc->len = dlen + len;
if (pdesc->len > QCE_FIFO_SIZE) {
if (qce_split_and_insert_dm_desc(pdesc,
pdesc->len, pdesc->addr,
&pce_dev->ce_out_dst_desc_index))
return -EIO;
}
} else {
pce_dev->ce_out_dst_desc_index++;
if (pce_dev->ce_out_dst_desc_index >= QCE_MAX_NUM_DESC)
return -EIO;
pdesc++;
pdesc->len = len;
pdesc->addr = sg_dma_address(sg);
if (pdesc->len > QCE_FIFO_SIZE) {
if (qce_split_and_insert_dm_desc(pdesc,
pdesc->len, sg_dma_address(sg),
&pce_dev->ce_out_dst_desc_index))
return -EIO;
}
}
if (nbytes > 0)
sg = scatterwalk_sg_next(sg);
}
return 0;
}
static int _chain_pm_buffer_out(struct qce_device *pce_dev,
unsigned int pmem, unsigned int nbytes)
{
unsigned int dlen;
struct dmov_desc *pdesc;
pdesc = pce_dev->ce_out_dst_desc + pce_dev->ce_out_dst_desc_index;
dlen = pdesc->len & ADM_DESC_LENGTH_MASK;
if (dlen == 0) {
pdesc->addr = pmem;
pdesc->len = nbytes;
} else if (pmem == (pdesc->addr + dlen)) {
pdesc->len = dlen + nbytes;
} else {
pce_dev->ce_out_dst_desc_index++;
if (pce_dev->ce_out_dst_desc_index >= QCE_MAX_NUM_DESC)
return -EIO;
pdesc++;
pdesc->len = nbytes;
pdesc->addr = pmem;
}
return 0;
};
static void _chain_buffer_out_init(struct qce_device *pce_dev)
{
struct dmov_desc *pdesc;
pce_dev->ce_out_dst_desc_index = 0;
pce_dev->ce_out_src_desc_index = 0;
pdesc = pce_dev->ce_out_dst_desc;
pdesc->len = 0;
};
static void _ce_out_final(struct qce_device *pce_dev, int ncmd, unsigned total)
{
struct dmov_desc *pdesc;
dmov_sg *pcmd;
pdesc = pce_dev->ce_out_dst_desc + pce_dev->ce_out_dst_desc_index;
pdesc->len |= ADM_DESC_LAST;
pdesc = pce_dev->ce_out_src_desc;
if (total > QCE_FIFO_SIZE) {
qce_split_and_insert_dm_desc(pdesc, total, 0,
&pce_dev->ce_out_src_desc_index);
pdesc = pce_dev->ce_out_src_desc +
pce_dev->ce_out_src_desc_index;
pdesc->len |= ADM_DESC_LAST;
} else
pdesc->len = ADM_DESC_LAST | total;
pcmd = (dmov_sg *) pce_dev->cmd_list_ce_out;
if (ncmd == 1)
pcmd->cmd |= CMD_LC;
else {
dmov_s *pscmd;
pcmd->cmd &= ~CMD_LC;
pcmd++;
pscmd = (dmov_s *)pcmd;
pscmd->cmd |= CMD_LC;
}
#ifdef QCE_DEBUG
dev_info(pce_dev->pdev, "_ce_out_final %d\n",
pce_dev->ce_out_dst_desc_index);
#endif
};
static void _aead_ce_in_call_back(struct msm_dmov_cmd *cmd_ptr,
unsigned int result, struct msm_dmov_errdata *err)
{
struct qce_device *pce_dev;
pce_dev = (struct qce_device *) cmd_ptr->user;
if (result != ADM_STATUS_OK) {
dev_err(pce_dev->pdev, "Qualcomm ADM status error %x\n",
result);
pce_dev->chan_ce_in_status = -1;
} else
pce_dev->chan_ce_in_status = 0;
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_COMP;
if (pce_dev->chan_ce_out_state == QCE_CHAN_STATE_COMP) {
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_IDLE;
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_IDLE;
/* done */
_aead_complete(pce_dev);
}
};
static void _aead_ce_out_call_back(struct msm_dmov_cmd *cmd_ptr,
unsigned int result, struct msm_dmov_errdata *err)
{
struct qce_device *pce_dev;
pce_dev = (struct qce_device *) cmd_ptr->user;
if (result != ADM_STATUS_OK) {
dev_err(pce_dev->pdev, "Qualcomm ADM status error %x\n",
result);
pce_dev->chan_ce_out_status = -1;
} else {
pce_dev->chan_ce_out_status = 0;
};
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_COMP;
if (pce_dev->chan_ce_in_state == QCE_CHAN_STATE_COMP) {
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_IDLE;
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_IDLE;
/* done */
_aead_complete(pce_dev);
}
};
static void _sha_ce_in_call_back(struct msm_dmov_cmd *cmd_ptr,
unsigned int result, struct msm_dmov_errdata *err)
{
struct qce_device *pce_dev;
pce_dev = (struct qce_device *) cmd_ptr->user;
if (result != ADM_STATUS_OK) {
dev_err(pce_dev->pdev, "Qualcomm ADM status error %x\n",
result);
pce_dev->chan_ce_in_status = -1;
} else
pce_dev->chan_ce_in_status = 0;
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_IDLE;
_sha_complete(pce_dev);
};
static void _ablk_cipher_ce_in_call_back(struct msm_dmov_cmd *cmd_ptr,
unsigned int result, struct msm_dmov_errdata *err)
{
struct qce_device *pce_dev;
pce_dev = (struct qce_device *) cmd_ptr->user;
if (result != ADM_STATUS_OK) {
dev_err(pce_dev->pdev, "Qualcomm ADM status error %x\n",
result);
pce_dev->chan_ce_in_status = -1;
} else
pce_dev->chan_ce_in_status = 0;
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_COMP;
if (pce_dev->chan_ce_out_state == QCE_CHAN_STATE_COMP) {
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_IDLE;
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_IDLE;
/* done */
_ablk_cipher_complete(pce_dev);
}
};
static void _ablk_cipher_ce_out_call_back(struct msm_dmov_cmd *cmd_ptr,
unsigned int result, struct msm_dmov_errdata *err)
{
struct qce_device *pce_dev;
pce_dev = (struct qce_device *) cmd_ptr->user;
if (result != ADM_STATUS_OK) {
dev_err(pce_dev->pdev, "Qualcomm ADM status error %x\n",
result);
pce_dev->chan_ce_out_status = -1;
} else {
pce_dev->chan_ce_out_status = 0;
};
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_COMP;
if (pce_dev->chan_ce_in_state == QCE_CHAN_STATE_COMP) {
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_IDLE;
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_IDLE;
/* done */
_ablk_cipher_complete(pce_dev);
}
};
static int _setup_cmd_template(struct qce_device *pce_dev)
{
dmov_sg *pcmd;
dmov_s *pscmd;
struct dmov_desc *pdesc;
unsigned char *vaddr;
int i = 0;
/* Divide up the 4K coherent memory */
/* 1. ce_in channel 1st command src descriptors, 128 entries */
vaddr = pce_dev->coh_vmem;
vaddr = (unsigned char *) ALIGN(((unsigned int)vaddr), 16);
pce_dev->ce_in_src_desc = (struct dmov_desc *) vaddr;
pce_dev->phy_ce_in_src_desc = pce_dev->coh_pmem +
(vaddr - pce_dev->coh_vmem);
vaddr = vaddr + (sizeof(struct dmov_desc) * QCE_MAX_NUM_DESC);
/* 2. ce_in channel 1st command dst descriptor, 1 entry */
vaddr = (unsigned char *) ALIGN(((unsigned int)vaddr), 16);
pce_dev->ce_in_dst_desc = (struct dmov_desc *) vaddr;
pce_dev->phy_ce_in_dst_desc = pce_dev->coh_pmem +
(vaddr - pce_dev->coh_vmem);
vaddr = vaddr + (sizeof(struct dmov_desc) * QCE_MAX_NUM_DESC);
/*
* 3. ce_in channel command list of one scatter gather command
* and one simple command.
*/
pce_dev->cmd_list_ce_in = vaddr;
pce_dev->phy_cmd_list_ce_in = pce_dev->coh_pmem
+ (vaddr - pce_dev->coh_vmem);
vaddr = vaddr + sizeof(dmov_s) + sizeof(dmov_sg);
/* 4. authentication result. */
pce_dev->dig_result = vaddr;
pce_dev->phy_dig_result = pce_dev->coh_pmem +
(vaddr - pce_dev->coh_vmem);
vaddr = vaddr + SHA256_DIGESTSIZE;
/*
* 5. ce_out channel command list of one scatter gather command
* and one simple command.
*/
pce_dev->cmd_list_ce_out = vaddr;
pce_dev->phy_cmd_list_ce_out = pce_dev->coh_pmem
+ (vaddr - pce_dev->coh_vmem);
vaddr = vaddr + sizeof(dmov_s) + sizeof(dmov_sg);
/* 6. ce_out channel command src descriptors, 1 entry */
vaddr = (unsigned char *) ALIGN(((unsigned int)vaddr), 16);
pce_dev->ce_out_src_desc = (struct dmov_desc *) vaddr;
pce_dev->phy_ce_out_src_desc = pce_dev->coh_pmem
+ (vaddr - pce_dev->coh_vmem);
vaddr = vaddr + (sizeof(struct dmov_desc) * QCE_MAX_NUM_DESC);
/* 7. ce_out channel command dst descriptors, 128 entries. */
vaddr = (unsigned char *) ALIGN(((unsigned int)vaddr), 16);
pce_dev->ce_out_dst_desc = (struct dmov_desc *) vaddr;
pce_dev->phy_ce_out_dst_desc = pce_dev->coh_pmem
+ (vaddr - pce_dev->coh_vmem);
vaddr = vaddr + (sizeof(struct dmov_desc) * QCE_MAX_NUM_DESC);
/* 8. pad area. */
pce_dev->ce_pad = vaddr;
pce_dev->phy_ce_pad = pce_dev->coh_pmem +
(vaddr - pce_dev->coh_vmem);
vaddr = vaddr + ADM_CE_BLOCK_SIZE;
/* 9. ce_in channel command pointer list. */
vaddr = (unsigned char *) ALIGN(((unsigned int) vaddr), 16);
pce_dev->cmd_pointer_list_ce_in = (unsigned int *) vaddr;
pce_dev->phy_cmd_pointer_list_ce_in = pce_dev->coh_pmem +
(vaddr - pce_dev->coh_vmem);
vaddr = vaddr + sizeof(unsigned char *);
/* 10. ce_ou channel command pointer list. */
vaddr = (unsigned char *) ALIGN(((unsigned int) vaddr), 16);
pce_dev->cmd_pointer_list_ce_out = (unsigned int *) vaddr;
pce_dev->phy_cmd_pointer_list_ce_out = pce_dev->coh_pmem +
(vaddr - pce_dev->coh_vmem);
vaddr = vaddr + sizeof(unsigned char *);
/* 11. throw away area to store by-pass data from ce_out. */
pce_dev->ce_out_ignore = (unsigned char *) vaddr;
pce_dev->phy_ce_out_ignore = pce_dev->coh_pmem
+ (vaddr - pce_dev->coh_vmem);
pce_dev->ce_out_ignore_size = (2 * PAGE_SIZE) - (vaddr -
pce_dev->coh_vmem); /* at least 1.5 K of space */
/*
* The first command of command list ce_in is for the input of
* concurrent operation of encrypt/decrypt or for the input
* of authentication.
*/
pcmd = (dmov_sg *) pce_dev->cmd_list_ce_in;
/* swap byte and half word , dst crci , scatter gather */
pcmd->cmd = CMD_DST_SWAP_BYTES | CMD_DST_SWAP_SHORTS |
CMD_DST_CRCI(pce_dev->crci_in) | CMD_MODE_SG;
pdesc = pce_dev->ce_in_src_desc;
pdesc->addr = 0; /* to be filled in each operation */
pdesc->len = 0; /* to be filled in each operation */
pcmd->src_dscr = (unsigned) pce_dev->phy_ce_in_src_desc;
pdesc = pce_dev->ce_in_dst_desc;
for (i = 0; i < QCE_MAX_NUM_DESC; i++) {
pdesc->addr = (CRYPTO_DATA_SHADOW0 + pce_dev->phy_iobase);
pdesc->len = 0; /* to be filled in each operation */
pdesc++;
}
pcmd->dst_dscr = (unsigned) pce_dev->phy_ce_in_dst_desc;
pcmd->_reserved = LI_SG_CMD | SRC_INDEX_SG_CMD(0) |
DST_INDEX_SG_CMD(0);
pcmd++;
/*
* The second command is for the digested data of
* hashing operation only. For others, this command is not used.
*/
pscmd = (dmov_s *) pcmd;
/* last command, swap byte, half word, src crci, single */
pscmd->cmd = CMD_LC | CMD_SRC_SWAP_BYTES | CMD_SRC_SWAP_SHORTS |
CMD_SRC_CRCI(pce_dev->crci_hash) | CMD_MODE_SINGLE;
pscmd->src = (unsigned) (CRYPTO_AUTH_IV0_REG + pce_dev->phy_iobase);
pscmd->len = SHA256_DIGESTSIZE; /* to be filled. */
pscmd->dst = (unsigned) pce_dev->phy_dig_result;
/* setup command pointer list */
*(pce_dev->cmd_pointer_list_ce_in) = (CMD_PTR_LP | DMOV_CMD_LIST |
DMOV_CMD_ADDR((unsigned int)
pce_dev->phy_cmd_list_ce_in));
pce_dev->chan_ce_in_cmd->user = (void *) pce_dev;
pce_dev->chan_ce_in_cmd->exec_func = NULL;
pce_dev->chan_ce_in_cmd->cmdptr = DMOV_CMD_ADDR(
(unsigned int) pce_dev->phy_cmd_pointer_list_ce_in);
/*
* The first command in the command list ce_out.
* It is for encry/decryp output.
* If hashing only, ce_out is not used.
*/
pcmd = (dmov_sg *) pce_dev->cmd_list_ce_out;
/* swap byte, half word, source crci, scatter gather */
pcmd->cmd = CMD_SRC_SWAP_BYTES | CMD_SRC_SWAP_SHORTS |
CMD_SRC_CRCI(pce_dev->crci_out) | CMD_MODE_SG;
pdesc = pce_dev->ce_out_src_desc;
for (i = 0; i < QCE_MAX_NUM_DESC; i++) {
pdesc->addr = (CRYPTO_DATA_SHADOW0 + pce_dev->phy_iobase);
pdesc->len = 0; /* to be filled in each operation */
pdesc++;
}
pcmd->src_dscr = (unsigned) pce_dev->phy_ce_out_src_desc;
pdesc = pce_dev->ce_out_dst_desc;
pdesc->addr = 0; /* to be filled in each operation */
pdesc->len = 0; /* to be filled in each operation */
pcmd->dst_dscr = (unsigned) pce_dev->phy_ce_out_dst_desc;
pcmd->_reserved = LI_SG_CMD | SRC_INDEX_SG_CMD(0) |
DST_INDEX_SG_CMD(0);
pcmd++;
/*
* The second command is for digested data of esp operation.
* For ciphering, this command is not used.
*/
pscmd = (dmov_s *) pcmd;
/* last command, swap byte, half word, src crci, single */
pscmd->cmd = CMD_LC | CMD_SRC_SWAP_BYTES | CMD_SRC_SWAP_SHORTS |
CMD_SRC_CRCI(pce_dev->crci_hash) | CMD_MODE_SINGLE;
pscmd->src = (CRYPTO_AUTH_IV0_REG + pce_dev->phy_iobase);
pscmd->len = SHA1_DIGESTSIZE; /* we only support hmac(sha1) */
pscmd->dst = (unsigned) pce_dev->phy_dig_result;
/* setup command pointer list */
*(pce_dev->cmd_pointer_list_ce_out) = (CMD_PTR_LP | DMOV_CMD_LIST |
DMOV_CMD_ADDR((unsigned int)pce_dev->
phy_cmd_list_ce_out));
pce_dev->chan_ce_out_cmd->user = pce_dev;
pce_dev->chan_ce_out_cmd->exec_func = NULL;
pce_dev->chan_ce_out_cmd->cmdptr = DMOV_CMD_ADDR(
(unsigned int) pce_dev->phy_cmd_pointer_list_ce_out);
return 0;
};
static int _qce_start_dma(struct qce_device *pce_dev, bool ce_in, bool ce_out)
{
if (ce_in)
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_IN_PROG;
else
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_COMP;
if (ce_out)
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_IN_PROG;
else
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_COMP;
if (ce_in)
msm_dmov_enqueue_cmd(pce_dev->chan_ce_in,
pce_dev->chan_ce_in_cmd);
if (ce_out)
msm_dmov_enqueue_cmd(pce_dev->chan_ce_out,
pce_dev->chan_ce_out_cmd);
return 0;
};
static void _f9_complete(struct qce_device *pce_dev)
{
uint32_t mac_i;
uint32_t status;
dma_unmap_single(pce_dev->pdev, pce_dev->phy_ota_src,
pce_dev->ota_size, DMA_TO_DEVICE);
/* check ce error status */
status = readl_relaxed(pce_dev->iobase + CRYPTO_STATUS_REG);
if (status & (1 << CRYPTO_SW_ERR)) {
pce_dev->err++;
dev_err(pce_dev->pdev,
"Qualcomm Crypto Error at 0x%x, status%x\n",
pce_dev->phy_iobase, status);
_init_ce_engine(pce_dev);
pce_dev->qce_cb(pce_dev->areq, NULL, NULL, -ENXIO);
return;
};
mac_i = readl_relaxed(pce_dev->iobase + CRYPTO_AUTH_IV0_REG);
pce_dev->qce_cb(pce_dev->areq, (void *) mac_i, NULL,
pce_dev->chan_ce_in_status);
};
static void _f8_complete(struct qce_device *pce_dev)
{
uint32_t status;
if (pce_dev->phy_ota_dst != 0)
dma_unmap_single(pce_dev->pdev, pce_dev->phy_ota_dst,
pce_dev->ota_size, DMA_FROM_DEVICE);
if (pce_dev->phy_ota_src != 0)
dma_unmap_single(pce_dev->pdev, pce_dev->phy_ota_src,
pce_dev->ota_size, (pce_dev->phy_ota_dst) ?
DMA_TO_DEVICE : DMA_BIDIRECTIONAL);
/* check ce error status */
status = readl_relaxed(pce_dev->iobase + CRYPTO_STATUS_REG);
if (status & (1 << CRYPTO_SW_ERR)) {
pce_dev->err++;
dev_err(pce_dev->pdev,
"Qualcomm Crypto Error at 0x%x, status%x\n",
pce_dev->phy_iobase, status);
_init_ce_engine(pce_dev);
pce_dev->qce_cb(pce_dev->areq, NULL, NULL, -ENXIO);
return;
};
pce_dev->qce_cb(pce_dev->areq, NULL, NULL,
pce_dev->chan_ce_in_status |
pce_dev->chan_ce_out_status);
};
static void _f9_ce_in_call_back(struct msm_dmov_cmd *cmd_ptr,
unsigned int result, struct msm_dmov_errdata *err)
{
struct qce_device *pce_dev;
pce_dev = (struct qce_device *) cmd_ptr->user;
if (result != ADM_STATUS_OK) {
dev_err(pce_dev->pdev, "Qualcomm ADM status error %x\n",
result);
pce_dev->chan_ce_in_status = -1;
} else
pce_dev->chan_ce_in_status = 0;
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_IDLE;
_f9_complete(pce_dev);
};
static void _f8_ce_in_call_back(struct msm_dmov_cmd *cmd_ptr,
unsigned int result, struct msm_dmov_errdata *err)
{
struct qce_device *pce_dev;
pce_dev = (struct qce_device *) cmd_ptr->user;
if (result != ADM_STATUS_OK) {
dev_err(pce_dev->pdev, "Qualcomm ADM status error %x\n",
result);
pce_dev->chan_ce_in_status = -1;
} else
pce_dev->chan_ce_in_status = 0;
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_COMP;
if (pce_dev->chan_ce_out_state == QCE_CHAN_STATE_COMP) {
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_IDLE;
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_IDLE;
/* done */
_f8_complete(pce_dev);
}
};
static void _f8_ce_out_call_back(struct msm_dmov_cmd *cmd_ptr,
unsigned int result, struct msm_dmov_errdata *err)
{
struct qce_device *pce_dev;
pce_dev = (struct qce_device *) cmd_ptr->user;
if (result != ADM_STATUS_OK) {
dev_err(pce_dev->pdev, "Qualcomm ADM status error %x\n",
result);
pce_dev->chan_ce_out_status = -1;
} else {
pce_dev->chan_ce_out_status = 0;
};
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_COMP;
if (pce_dev->chan_ce_in_state == QCE_CHAN_STATE_COMP) {
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_IDLE;
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_IDLE;
/* done */
_f8_complete(pce_dev);
}
};
static int _ce_f9_setup(struct qce_device *pce_dev, struct qce_f9_req * req)
{
uint32_t cfg;
uint32_t ikey[OTA_KEY_SIZE/sizeof(uint32_t)];
_byte_stream_to_net_words(ikey, &req->ikey[0], OTA_KEY_SIZE);
writel_relaxed(ikey[0], pce_dev->iobase + CRYPTO_AUTH_IV0_REG);
writel_relaxed(ikey[1], pce_dev->iobase + CRYPTO_AUTH_IV1_REG);
writel_relaxed(ikey[2], pce_dev->iobase + CRYPTO_AUTH_IV2_REG);
writel_relaxed(ikey[3], pce_dev->iobase + CRYPTO_AUTH_IV3_REG);
writel_relaxed(req->last_bits, pce_dev->iobase + CRYPTO_AUTH_IV4_REG);
writel_relaxed(req->fresh, pce_dev->iobase + CRYPTO_AUTH_BYTECNT0_REG);
writel_relaxed(req->count_i, pce_dev->iobase +
CRYPTO_AUTH_BYTECNT1_REG);
/* write auth_seg_cfg */
writel_relaxed((uint32_t)req->msize << CRYPTO_AUTH_SEG_SIZE,
pce_dev->iobase + CRYPTO_AUTH_SEG_CFG_REG);
/* write seg_cfg */
cfg = (CRYPTO_AUTH_ALG_F9 << CRYPTO_AUTH_ALG) | (1 << CRYPTO_FIRST) |
(1 << CRYPTO_LAST);
if (req->algorithm == QCE_OTA_ALGO_KASUMI)
cfg |= (CRYPTO_AUTH_SIZE_UIA1 << CRYPTO_AUTH_SIZE);
else
cfg |= (CRYPTO_AUTH_SIZE_UIA2 << CRYPTO_AUTH_SIZE) ;
if (req->direction == QCE_OTA_DIR_DOWNLINK)
cfg |= 1 << CRYPTO_F9_DIRECTION;
writel_relaxed(cfg, pce_dev->iobase + CRYPTO_SEG_CFG_REG);
/* write seg_size */
writel_relaxed(req->msize, pce_dev->iobase + CRYPTO_SEG_SIZE_REG);
/* issue go to crypto */
writel_relaxed(1 << CRYPTO_GO, pce_dev->iobase + CRYPTO_GOPROC_REG);
/*
* barrier to ensure previous instructions
* (including GO) to CE finish before issue DMA transfer
* request.
*/
mb();
return 0;
};
static int _ce_f8_setup(struct qce_device *pce_dev, struct qce_f8_req *req,
bool key_stream_mode, uint16_t npkts, uint16_t cipher_offset,
uint16_t cipher_size)
{
uint32_t cfg;
uint32_t ckey[OTA_KEY_SIZE/sizeof(uint32_t)];
if ((key_stream_mode && (req->data_len & 0xf || npkts > 1)) ||
(req->bearer >= QCE_OTA_MAX_BEARER))
return -EINVAL;
/* write seg_cfg */
cfg = (CRYPTO_ENCR_ALG_F8 << CRYPTO_ENCR_ALG) | (1 << CRYPTO_FIRST) |
(1 << CRYPTO_LAST);
if (req->algorithm == QCE_OTA_ALGO_KASUMI)
cfg |= (CRYPTO_ENCR_KEY_SZ_UEA1 << CRYPTO_ENCR_KEY_SZ);
else
cfg |= (CRYPTO_ENCR_KEY_SZ_UEA2 << CRYPTO_ENCR_KEY_SZ) ;
if (key_stream_mode)
cfg |= 1 << CRYPTO_F8_KEYSTREAM_ENABLE;
if (req->direction == QCE_OTA_DIR_DOWNLINK)
cfg |= 1 << CRYPTO_F8_DIRECTION;
writel_relaxed(cfg, pce_dev->iobase + CRYPTO_SEG_CFG_REG);
/* write seg_size */
writel_relaxed(req->data_len, pce_dev->iobase + CRYPTO_SEG_SIZE_REG);
/* write 0 to auth_size, auth_offset */
writel_relaxed(0, pce_dev->iobase + CRYPTO_AUTH_SEG_CFG_REG);
/* write encr_seg_cfg seg_size, seg_offset */
writel_relaxed((((uint32_t) cipher_size) << CRYPTO_ENCR_SEG_SIZE) |
(cipher_offset & 0xffff),
pce_dev->iobase + CRYPTO_ENCR_SEG_CFG_REG);
/* write keys */
_byte_stream_to_net_words(ckey, &req->ckey[0], OTA_KEY_SIZE);
writel_relaxed(ckey[0], pce_dev->iobase + CRYPTO_DES_KEY0_REG);
writel_relaxed(ckey[1], pce_dev->iobase + CRYPTO_DES_KEY1_REG);
writel_relaxed(ckey[2], pce_dev->iobase + CRYPTO_DES_KEY2_REG);
writel_relaxed(ckey[3], pce_dev->iobase + CRYPTO_DES_KEY3_REG);
/* write cntr0_iv0 for countC */
writel_relaxed(req->count_c, pce_dev->iobase + CRYPTO_CNTR0_IV0_REG);
/* write cntr1_iv1 for nPkts, and bearer */
if (npkts == 1)
npkts = 0;
writel_relaxed(req->bearer << CRYPTO_CNTR1_IV1_REG_F8_BEARER |
npkts << CRYPTO_CNTR1_IV1_REG_F8_PKT_CNT,
pce_dev->iobase + CRYPTO_CNTR1_IV1_REG);
/* issue go to crypto */
writel_relaxed(1 << CRYPTO_GO, pce_dev->iobase + CRYPTO_GOPROC_REG);
/*
* barrier to ensure previous instructions
* (including GO) to CE finish before issue DMA transfer
* request.
*/
mb();
return 0;
};
int qce_aead_req(void *handle, struct qce_req *q_req)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
struct aead_request *areq = (struct aead_request *) q_req->areq;
struct crypto_aead *aead = crypto_aead_reqtfm(areq);
uint32_t ivsize = crypto_aead_ivsize(aead);
uint32_t totallen;
uint32_t pad_len;
uint32_t authsize = crypto_aead_authsize(aead);
int rc = 0;
q_req->ivsize = ivsize;
if (q_req->dir == QCE_ENCRYPT)
q_req->cryptlen = areq->cryptlen;
else
q_req->cryptlen = areq->cryptlen - authsize;
totallen = q_req->cryptlen + ivsize + areq->assoclen;
pad_len = ALIGN(totallen, ADM_CE_BLOCK_SIZE) - totallen;
_chain_buffer_in_init(pce_dev);
_chain_buffer_out_init(pce_dev);
pce_dev->assoc_nents = 0;
pce_dev->phy_iv_in = 0;
pce_dev->src_nents = 0;
pce_dev->dst_nents = 0;
pce_dev->assoc_nents = count_sg(areq->assoc, areq->assoclen);
qce_dma_map_sg(pce_dev->pdev, areq->assoc, pce_dev->assoc_nents,
DMA_TO_DEVICE);
if (_chain_sg_buffer_in(pce_dev, areq->assoc, areq->assoclen) < 0) {
rc = -ENOMEM;
goto bad;
}
/* cipher iv for input */
pce_dev->phy_iv_in = dma_map_single(pce_dev->pdev, q_req->iv,
ivsize, DMA_TO_DEVICE);
if (_chain_pm_buffer_in(pce_dev, pce_dev->phy_iv_in, ivsize) < 0) {
rc = -ENOMEM;
goto bad;
}
/* for output, ignore associated data and cipher iv */
if (_chain_pm_buffer_out(pce_dev, pce_dev->phy_ce_out_ignore,
ivsize + areq->assoclen) < 0) {
rc = -ENOMEM;
goto bad;
}
/* cipher input */
pce_dev->src_nents = count_sg(areq->src, q_req->cryptlen);
qce_dma_map_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
if (_chain_sg_buffer_in(pce_dev, areq->src, q_req->cryptlen) < 0) {
rc = -ENOMEM;
goto bad;
}
/* cipher output */
if (areq->src != areq->dst) {
pce_dev->dst_nents = count_sg(areq->dst, q_req->cryptlen);
qce_dma_map_sg(pce_dev->pdev, areq->dst, pce_dev->dst_nents,
DMA_FROM_DEVICE);
};
if (_chain_sg_buffer_out(pce_dev, areq->dst, q_req->cryptlen) < 0) {
rc = -ENOMEM;
goto bad;
}
/* pad data */
if (pad_len) {
if (_chain_pm_buffer_in(pce_dev, pce_dev->phy_ce_pad,
pad_len) < 0) {
rc = -ENOMEM;
goto bad;
}
if (_chain_pm_buffer_out(pce_dev, pce_dev->phy_ce_pad,
pad_len) < 0) {
rc = -ENOMEM;
goto bad;
}
}
/* finalize the ce_in and ce_out channels command lists */
_ce_in_final(pce_dev, 1, ALIGN(totallen, ADM_CE_BLOCK_SIZE));
_ce_out_final(pce_dev, 2, ALIGN(totallen, ADM_CE_BLOCK_SIZE));
/* set up crypto device */
rc = _ce_setup(pce_dev, q_req, totallen, ivsize + areq->assoclen);
if (rc < 0)
goto bad;
/* setup for callback, and issue command to adm */
pce_dev->areq = q_req->areq;
pce_dev->qce_cb = q_req->qce_cb;
pce_dev->chan_ce_in_cmd->complete_func = _aead_ce_in_call_back;
pce_dev->chan_ce_out_cmd->complete_func = _aead_ce_out_call_back;
rc = _qce_start_dma(pce_dev, true, true);
if (rc == 0)
return 0;
bad:
if (pce_dev->assoc_nents) {
qce_dma_unmap_sg(pce_dev->pdev, areq->assoc,
pce_dev->assoc_nents, DMA_TO_DEVICE);
}
if (pce_dev->phy_iv_in) {
dma_unmap_single(pce_dev->pdev, pce_dev->phy_iv_in,
ivsize, DMA_TO_DEVICE);
}
if (pce_dev->src_nents) {
qce_dma_unmap_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
}
if (pce_dev->dst_nents) {
qce_dma_unmap_sg(pce_dev->pdev, areq->dst, pce_dev->dst_nents,
DMA_FROM_DEVICE);
}
return rc;
}
EXPORT_SYMBOL(qce_aead_req);
int qce_ablk_cipher_req(void *handle, struct qce_req *c_req)
{
int rc = 0;
struct qce_device *pce_dev = (struct qce_device *) handle;
struct ablkcipher_request *areq = (struct ablkcipher_request *)
c_req->areq;
uint32_t pad_len = ALIGN(areq->nbytes, ADM_CE_BLOCK_SIZE)
- areq->nbytes;
_chain_buffer_in_init(pce_dev);
_chain_buffer_out_init(pce_dev);
pce_dev->src_nents = 0;
pce_dev->dst_nents = 0;
/* cipher input */
pce_dev->src_nents = count_sg(areq->src, areq->nbytes);
qce_dma_map_sg(pce_dev->pdev, areq->src, pce_dev->src_nents,
(areq->src == areq->dst) ? DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
if (_chain_sg_buffer_in(pce_dev, areq->src, areq->nbytes) < 0) {
rc = -ENOMEM;
goto bad;
}
/* cipher output */
if (areq->src != areq->dst) {
pce_dev->dst_nents = count_sg(areq->dst, areq->nbytes);
qce_dma_map_sg(pce_dev->pdev, areq->dst,
pce_dev->dst_nents, DMA_FROM_DEVICE);
};
if (_chain_sg_buffer_out(pce_dev, areq->dst, areq->nbytes) < 0) {
rc = -ENOMEM;
goto bad;
}
/* pad data */
if (pad_len) {
if (_chain_pm_buffer_in(pce_dev, pce_dev->phy_ce_pad,
pad_len) < 0) {
rc = -ENOMEM;
goto bad;
}
if (_chain_pm_buffer_out(pce_dev, pce_dev->phy_ce_pad,
pad_len) < 0) {
rc = -ENOMEM;
goto bad;
}
}
/* finalize the ce_in and ce_out channels command lists */
_ce_in_final(pce_dev, 1, areq->nbytes + pad_len);
_ce_out_final(pce_dev, 1, areq->nbytes + pad_len);
#ifdef QCE_DEBUG
_ce_in_dump(pce_dev);
_ce_out_dump(pce_dev);
#endif
/* set up crypto device */
rc = _ce_setup(pce_dev, c_req, areq->nbytes, 0);
if (rc < 0)
goto bad;
/* setup for callback, and issue command to adm */
pce_dev->areq = areq;
pce_dev->qce_cb = c_req->qce_cb;
pce_dev->chan_ce_in_cmd->complete_func =
_ablk_cipher_ce_in_call_back;
pce_dev->chan_ce_out_cmd->complete_func =
_ablk_cipher_ce_out_call_back;
rc = _qce_start_dma(pce_dev, true, true);
if (rc == 0)
return 0;
bad:
if (pce_dev->dst_nents) {
qce_dma_unmap_sg(pce_dev->pdev, areq->dst,
pce_dev->dst_nents, DMA_FROM_DEVICE);
}
if (pce_dev->src_nents) {
qce_dma_unmap_sg(pce_dev->pdev, areq->src,
pce_dev->src_nents,
(areq->src == areq->dst) ?
DMA_BIDIRECTIONAL :
DMA_TO_DEVICE);
}
return rc;
}
EXPORT_SYMBOL(qce_ablk_cipher_req);
int qce_process_sha_req(void *handle, struct qce_sha_req *sreq)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
int rc;
uint32_t pad_len = ALIGN(sreq->size, ADM_CE_BLOCK_SIZE) - sreq->size;
struct ahash_request *areq = (struct ahash_request *)sreq->areq;
_chain_buffer_in_init(pce_dev);
pce_dev->src_nents = count_sg(sreq->src, sreq->size);
qce_dma_map_sg(pce_dev->pdev, sreq->src, pce_dev->src_nents,
DMA_TO_DEVICE);
if (_chain_sg_buffer_in(pce_dev, sreq->src, sreq->size) < 0) {
rc = -ENOMEM;
goto bad;
}
if (pad_len) {
if (_chain_pm_buffer_in(pce_dev, pce_dev->phy_ce_pad,
pad_len) < 0) {
rc = -ENOMEM;
goto bad;
}
}
_ce_in_final(pce_dev, 2, sreq->size + pad_len);
#ifdef QCE_DEBUG
_ce_in_dump(pce_dev);
#endif
rc = _sha_ce_setup(pce_dev, sreq);
if (rc < 0)
goto bad;
pce_dev->areq = areq;
pce_dev->qce_cb = sreq->qce_cb;
pce_dev->chan_ce_in_cmd->complete_func = _sha_ce_in_call_back;
rc = _qce_start_dma(pce_dev, true, false);
if (rc == 0)
return 0;
bad:
if (pce_dev->src_nents) {
qce_dma_unmap_sg(pce_dev->pdev, sreq->src,
pce_dev->src_nents, DMA_TO_DEVICE);
}
return rc;
}
EXPORT_SYMBOL(qce_process_sha_req);
int qce_enable_clk(void *handle)
{
return 0;
}
EXPORT_SYMBOL(qce_enable_clk);
int qce_disable_clk(void *handle)
{
return 0;
}
EXPORT_SYMBOL(qce_disable_clk);
/*
* crypto engine open function.
*/
void *qce_open(struct platform_device *pdev, int *rc)
{
struct qce_device *pce_dev;
struct resource *resource;
struct clk *ce_clk;
pce_dev = kzalloc(sizeof(struct qce_device), GFP_KERNEL);
if (!pce_dev) {
*rc = -ENOMEM;
dev_err(&pdev->dev, "Can not allocate memory\n");
return NULL;
}
pce_dev->pdev = &pdev->dev;
ce_clk = clk_get(pce_dev->pdev, "core_clk");
if (IS_ERR(ce_clk)) {
kfree(pce_dev);
*rc = PTR_ERR(ce_clk);
return NULL;
}
pce_dev->ce_clk = ce_clk;
*rc = clk_enable(pce_dev->ce_clk);
if (*rc) {
kfree(pce_dev);
return NULL;
}
resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!resource) {
*rc = -ENXIO;
dev_err(pce_dev->pdev, "Missing MEM resource\n");
goto err;
};
pce_dev->phy_iobase = resource->start;
pce_dev->iobase = ioremap_nocache(resource->start,
resource->end - resource->start + 1);
if (!pce_dev->iobase) {
*rc = -ENOMEM;
dev_err(pce_dev->pdev, "Can not map io memory\n");
goto err;
}
pce_dev->chan_ce_in_cmd = kzalloc(sizeof(struct msm_dmov_cmd),
GFP_KERNEL);
pce_dev->chan_ce_out_cmd = kzalloc(sizeof(struct msm_dmov_cmd),
GFP_KERNEL);
if (pce_dev->chan_ce_in_cmd == NULL ||
pce_dev->chan_ce_out_cmd == NULL) {
dev_err(pce_dev->pdev, "Can not allocate memory\n");
*rc = -ENOMEM;
goto err;
}
resource = platform_get_resource_byname(pdev, IORESOURCE_DMA,
"crypto_channels");
if (!resource) {
*rc = -ENXIO;
dev_err(pce_dev->pdev, "Missing DMA channel resource\n");
goto err;
};
pce_dev->chan_ce_in = resource->start;
pce_dev->chan_ce_out = resource->end;
resource = platform_get_resource_byname(pdev, IORESOURCE_DMA,
"crypto_crci_in");
if (!resource) {
*rc = -ENXIO;
dev_err(pce_dev->pdev, "Missing DMA crci in resource\n");
goto err;
};
pce_dev->crci_in = resource->start;
resource = platform_get_resource_byname(pdev, IORESOURCE_DMA,
"crypto_crci_out");
if (!resource) {
*rc = -ENXIO;
dev_err(pce_dev->pdev, "Missing DMA crci out resource\n");
goto err;
};
pce_dev->crci_out = resource->start;
resource = platform_get_resource_byname(pdev, IORESOURCE_DMA,
"crypto_crci_hash");
if (!resource) {
*rc = -ENXIO;
dev_err(pce_dev->pdev, "Missing DMA crci hash resource\n");
goto err;
};
pce_dev->crci_hash = resource->start;
pce_dev->coh_vmem = dma_alloc_coherent(pce_dev->pdev,
2*PAGE_SIZE, &pce_dev->coh_pmem, GFP_KERNEL);
if (pce_dev->coh_vmem == NULL) {
*rc = -ENOMEM;
dev_err(pce_dev->pdev, "Can not allocate coherent memory.\n");
goto err;
}
_setup_cmd_template(pce_dev);
pce_dev->chan_ce_in_state = QCE_CHAN_STATE_IDLE;
pce_dev->chan_ce_out_state = QCE_CHAN_STATE_IDLE;
if (_init_ce_engine(pce_dev)) {
*rc = -ENXIO;
clk_disable(pce_dev->ce_clk);
goto err;
}
*rc = 0;
clk_disable(pce_dev->ce_clk);
pce_dev->err = 0;
return pce_dev;
err:
if (pce_dev)
qce_close(pce_dev);
return NULL;
}
EXPORT_SYMBOL(qce_open);
/*
* crypto engine close function.
*/
int qce_close(void *handle)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
if (handle == NULL)
return -ENODEV;
if (pce_dev->iobase)
iounmap(pce_dev->iobase);
if (pce_dev->coh_vmem)
dma_free_coherent(pce_dev->pdev, 2*PAGE_SIZE, pce_dev->coh_vmem,
pce_dev->coh_pmem);
kfree(pce_dev->chan_ce_in_cmd);
kfree(pce_dev->chan_ce_out_cmd);
clk_put(pce_dev->ce_clk);
kfree(handle);
return 0;
}
EXPORT_SYMBOL(qce_close);
int qce_hw_support(void *handle, struct ce_hw_support *ce_support)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
if (ce_support == NULL)
return -EINVAL;
if (pce_dev->hmac == 1)
ce_support->sha1_hmac_20 = true;
else
ce_support->sha1_hmac_20 = false;
ce_support->sha1_hmac = false;
ce_support->sha256_hmac = false;
ce_support->sha_hmac = false;
ce_support->cmac = false;
ce_support->aes_key_192 = true;
ce_support->aes_xts = false;
ce_support->aes_ccm = false;
ce_support->ota = pce_dev->ota;
ce_support->aligned_only = false;
ce_support->is_shared = false;
ce_support->bam = false;
return 0;
}
EXPORT_SYMBOL(qce_hw_support);
int qce_f8_req(void *handle, struct qce_f8_req *req,
void *cookie, qce_comp_func_ptr_t qce_cb)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
bool key_stream_mode;
dma_addr_t dst;
int rc;
uint32_t pad_len = ALIGN(req->data_len, ADM_CE_BLOCK_SIZE) -
req->data_len;
_chain_buffer_in_init(pce_dev);
_chain_buffer_out_init(pce_dev);
key_stream_mode = (req->data_in == NULL);
/* F8 cipher input */
if (key_stream_mode)
pce_dev->phy_ota_src = 0;
else {
pce_dev->phy_ota_src = dma_map_single(pce_dev->pdev,
req->data_in, req->data_len,
(req->data_in == req->data_out) ?
DMA_BIDIRECTIONAL : DMA_TO_DEVICE);
if (_chain_pm_buffer_in(pce_dev, pce_dev->phy_ota_src,
req->data_len) < 0) {
pce_dev->phy_ota_dst = 0;
rc = -ENOMEM;
goto bad;
}
}
/* F8 cipher output */
if (req->data_in != req->data_out) {
dst = dma_map_single(pce_dev->pdev, req->data_out,
req->data_len, DMA_FROM_DEVICE);
pce_dev->phy_ota_dst = dst;
} else {
dst = pce_dev->phy_ota_src;
pce_dev->phy_ota_dst = 0;
}
if (_chain_pm_buffer_out(pce_dev, dst, req->data_len) < 0) {
rc = -ENOMEM;
goto bad;
}
pce_dev->ota_size = req->data_len;
/* pad data */
if (pad_len) {
if (!key_stream_mode && _chain_pm_buffer_in(pce_dev,
pce_dev->phy_ce_pad, pad_len) < 0) {
rc = -ENOMEM;
goto bad;
}
if (_chain_pm_buffer_out(pce_dev, pce_dev->phy_ce_pad,
pad_len) < 0) {
rc = -ENOMEM;
goto bad;
}
}
/* finalize the ce_in and ce_out channels command lists */
if (!key_stream_mode)
_ce_in_final(pce_dev, 1, req->data_len + pad_len);
_ce_out_final(pce_dev, 1, req->data_len + pad_len);
/* set up crypto device */
rc = _ce_f8_setup(pce_dev, req, key_stream_mode, 1, 0, req->data_len);
if (rc < 0)
goto bad;
/* setup for callback, and issue command to adm */
pce_dev->areq = cookie;
pce_dev->qce_cb = qce_cb;
if (!key_stream_mode)
pce_dev->chan_ce_in_cmd->complete_func = _f8_ce_in_call_back;
pce_dev->chan_ce_out_cmd->complete_func = _f8_ce_out_call_back;
rc = _qce_start_dma(pce_dev, !(key_stream_mode), true);
if (rc == 0)
return 0;
bad:
if (pce_dev->phy_ota_dst != 0)
dma_unmap_single(pce_dev->pdev, pce_dev->phy_ota_dst,
req->data_len, DMA_FROM_DEVICE);
if (pce_dev->phy_ota_src != 0)
dma_unmap_single(pce_dev->pdev, pce_dev->phy_ota_src,
req->data_len,
(req->data_in == req->data_out) ?
DMA_BIDIRECTIONAL : DMA_TO_DEVICE);
return rc;
}
EXPORT_SYMBOL(qce_f8_req);
int qce_f8_multi_pkt_req(void *handle, struct qce_f8_multi_pkt_req *mreq,
void *cookie, qce_comp_func_ptr_t qce_cb)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
uint16_t num_pkt = mreq->num_pkt;
uint16_t cipher_start = mreq->cipher_start;
uint16_t cipher_size = mreq->cipher_size;
struct qce_f8_req *req = &mreq->qce_f8_req;
uint32_t total;
uint32_t pad_len;
dma_addr_t dst = 0;
int rc = 0;
total = num_pkt * req->data_len;
pad_len = ALIGN(total, ADM_CE_BLOCK_SIZE) - total;
_chain_buffer_in_init(pce_dev);
_chain_buffer_out_init(pce_dev);
/* F8 cipher input */
pce_dev->phy_ota_src = dma_map_single(pce_dev->pdev,
req->data_in, total,
(req->data_in == req->data_out) ?
DMA_BIDIRECTIONAL : DMA_TO_DEVICE);
if (_chain_pm_buffer_in(pce_dev, pce_dev->phy_ota_src,
total) < 0) {
pce_dev->phy_ota_dst = 0;
rc = -ENOMEM;
goto bad;
}
/* F8 cipher output */
if (req->data_in != req->data_out) {
dst = dma_map_single(pce_dev->pdev, req->data_out, total,
DMA_FROM_DEVICE);
pce_dev->phy_ota_dst = dst;
} else {
dst = pce_dev->phy_ota_src;
pce_dev->phy_ota_dst = 0;
}
if (_chain_pm_buffer_out(pce_dev, dst, total) < 0) {
rc = -ENOMEM;
goto bad;
}
pce_dev->ota_size = total;
/* pad data */
if (pad_len) {
if (_chain_pm_buffer_in(pce_dev, pce_dev->phy_ce_pad,
pad_len) < 0) {
rc = -ENOMEM;
goto bad;
}
if (_chain_pm_buffer_out(pce_dev, pce_dev->phy_ce_pad,
pad_len) < 0) {
rc = -ENOMEM;
goto bad;
}
}
/* finalize the ce_in and ce_out channels command lists */
_ce_in_final(pce_dev, 1, total + pad_len);
_ce_out_final(pce_dev, 1, total + pad_len);
/* set up crypto device */
rc = _ce_f8_setup(pce_dev, req, false, num_pkt, cipher_start,
cipher_size);
if (rc)
goto bad ;
/* setup for callback, and issue command to adm */
pce_dev->areq = cookie;
pce_dev->qce_cb = qce_cb;
pce_dev->chan_ce_in_cmd->complete_func = _f8_ce_in_call_back;
pce_dev->chan_ce_out_cmd->complete_func = _f8_ce_out_call_back;
rc = _qce_start_dma(pce_dev, true, true);
if (rc == 0)
return 0;
bad:
if (pce_dev->phy_ota_dst)
dma_unmap_single(pce_dev->pdev, pce_dev->phy_ota_dst, total,
DMA_FROM_DEVICE);
dma_unmap_single(pce_dev->pdev, pce_dev->phy_ota_src, total,
(req->data_in == req->data_out) ?
DMA_BIDIRECTIONAL : DMA_TO_DEVICE);
return rc;
}
EXPORT_SYMBOL(qce_f8_multi_pkt_req);
int qce_f9_req(void *handle, struct qce_f9_req *req, void *cookie,
qce_comp_func_ptr_t qce_cb)
{
struct qce_device *pce_dev = (struct qce_device *) handle;
int rc;
uint32_t pad_len = ALIGN(req->msize, ADM_CE_BLOCK_SIZE) - req->msize;
pce_dev->phy_ota_src = dma_map_single(pce_dev->pdev, req->message,
req->msize, DMA_TO_DEVICE);
_chain_buffer_in_init(pce_dev);
rc = _chain_pm_buffer_in(pce_dev, pce_dev->phy_ota_src, req->msize);
if (rc < 0) {
rc = -ENOMEM;
goto bad;
}
pce_dev->ota_size = req->msize;
if (pad_len) {
rc = _chain_pm_buffer_in(pce_dev, pce_dev->phy_ce_pad,
pad_len);
if (rc < 0) {
rc = -ENOMEM;
goto bad;
}
}
_ce_in_final(pce_dev, 2, req->msize + pad_len);
rc = _ce_f9_setup(pce_dev, req);
if (rc < 0)
goto bad;
/* setup for callback, and issue command to adm */
pce_dev->areq = cookie;
pce_dev->qce_cb = qce_cb;
pce_dev->chan_ce_in_cmd->complete_func = _f9_ce_in_call_back;
rc = _qce_start_dma(pce_dev, true, false);
if (rc == 0)
return 0;
bad:
dma_unmap_single(pce_dev->pdev, pce_dev->phy_ota_src,
req->msize, DMA_TO_DEVICE);
return rc;
}
EXPORT_SYMBOL(qce_f9_req);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("Crypto Engine driver");
Reference in New Issue View Git Blame Copy Permalink