path: root/sys/mips/nlm/hal/nlmsaelib.h

/*-
 * Copyright (c) 2003-2012 Broadcom Corporation
 * All Rights Reserved
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY BROADCOM ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL BROADCOM OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * $FreeBSD$
 */

#ifndef _NLM_HAL_CRYPTO_H_
#define _NLM_HAL_CRYPTO_H_

#define	SAE_CFG_REG		0x00
#define SAE_ENG_SEL_0		0x01
#define SAE_ENG_SEL_1		0x02
#define SAE_ENG_SEL_2		0x03
#define SAE_ENG_SEL_3		0x04
#define SAE_ENG_SEL_4		0x05
#define SAE_ENG_SEL_5		0x06
#define SAE_ENG_SEL_6		0x07
#define SAE_ENG_SEL_7		0x08

#define	RSA_CFG_REG		0x00
#define RSA_ENG_SEL_0		0x01
#define RSA_ENG_SEL_1		0x02
#define RSA_ENG_SEL_2		0x03

#define nlm_read_sec_reg(b, r)		nlm_read_reg(b, r)
#define nlm_write_sec_reg(b, r, v)	nlm_write_reg(b, r, v)
#define nlm_get_sec_pcibase(node)	nlm_pcicfg_base(XLP_IO_SEC_OFFSET(node))
#define nlm_get_sec_regbase(node)        \
                        (nlm_get_sec_pcibase(node) + XLP_IO_PCI_HDRSZ)

#define nlm_read_rsa_reg(b, r)		nlm_read_reg(b, r)
#define nlm_write_rsa_reg(b, r, v)	nlm_write_reg(b, r, v)
#define nlm_get_rsa_pcibase(node)	nlm_pcicfg_base(XLP_IO_RSA_OFFSET(node))
#define nlm_get_rsa_regbase(node)        \
                        (nlm_get_rsa_pcibase(node) + XLP_IO_PCI_HDRSZ)

#define nlm_pcibase_sec(node)     nlm_pcicfg_base(XLP_IO_SEC_OFFSET(node))
#define nlm_qidstart_sec(node)    nlm_qidstart_kseg(nlm_pcibase_sec(node))
#define nlm_qnum_sec(node)        nlm_qnum_kseg(nlm_pcibase_sec(node))

/*
 * Since buffer allocation for crypto at kernel is done as malloc, each
 * segment size is given as page size which is 4K by default
 */
#define NLM_CRYPTO_MAX_SEG_LEN 	PAGE_SIZE

#define MAX_KEY_LEN_IN_DW		20

#define left_shift64(x, bitshift, numofbits)			\
    ((uint64_t)(x) << (bitshift))

#define left_shift64_mask(x, bitshift, numofbits)			\
    (((uint64_t)(x) & ((1ULL << (numofbits)) - 1)) << (bitshift))

/**
* @brief cipher algorithms
* @ingroup crypto
*/
enum nlm_cipher_algo {
	NLM_CIPHER_BYPASS = 0,
	NLM_CIPHER_DES = 1,
	NLM_CIPHER_3DES = 2,     
	NLM_CIPHER_AES128 = 3,
	NLM_CIPHER_AES192 = 4,
	NLM_CIPHER_AES256 = 5, 	
	NLM_CIPHER_ARC4 = 6,     
	NLM_CIPHER_KASUMI_F8 = 7,
	NLM_CIPHER_SNOW3G_F8 = 8,     
	NLM_CIPHER_CAMELLIA128 = 9, 
	NLM_CIPHER_CAMELLIA192 = 0xA, 
	NLM_CIPHER_CAMELLIA256 = 0xB, 
	NLM_CIPHER_MAX = 0xC,
};

/**
* @brief cipher modes
* @ingroup crypto
*/
enum nlm_cipher_mode {
	NLM_CIPHER_MODE_ECB = 0,
	NLM_CIPHER_MODE_CBC = 1,
	NLM_CIPHER_MODE_CFB = 2,
	NLM_CIPHER_MODE_OFB = 3,
	NLM_CIPHER_MODE_CTR = 4,
	NLM_CIPHER_MODE_AES_F8 = 5,
	NLM_CIPHER_MODE_GCM = 6,
	NLM_CIPHER_MODE_CCM = 7,
	NLM_CIPHER_MODE_UNDEFINED1 = 8,
	NLM_CIPHER_MODE_UNDEFINED2 = 9,
	NLM_CIPHER_MODE_LRW = 0xA,
	NLM_CIPHER_MODE_XTS = 0xB,
	NLM_CIPHER_MODE_MAX = 0xC,
};

/**
* @brief hash algorithms
* @ingroup crypto
*/
enum nlm_hash_algo {
	NLM_HASH_BYPASS = 0,
	NLM_HASH_MD5 = 1,
	NLM_HASH_SHA = 2,
	NLM_HASH_UNDEFINED = 3,
	NLM_HASH_AES128 = 4,
	NLM_HASH_AES192 = 5,
	NLM_HASH_AES256 = 6,
	NLM_HASH_KASUMI_F9 = 7,
	NLM_HASH_SNOW3G_F9 = 8,
	NLM_HASH_CAMELLIA128 = 9,
	NLM_HASH_CAMELLIA192 = 0xA,
	NLM_HASH_CAMELLIA256 = 0xB,
	NLM_HASH_GHASH = 0xC,
	NLM_HASH_MAX = 0xD
};

/**
* @brief hash modes
* @ingroup crypto
*/
enum nlm_hash_mode {
	NLM_HASH_MODE_SHA1 = 0,	/* Only SHA */
	NLM_HASH_MODE_SHA224 = 1,	/* Only SHA */
	NLM_HASH_MODE_SHA256 = 2,	/* Only SHA */
	NLM_HASH_MODE_SHA384 = 3,	/* Only SHA */
	NLM_HASH_MODE_SHA512 = 4,	/* Only SHA */
	NLM_HASH_MODE_CMAC = 5,	/* AES and Camellia */
	NLM_HASH_MODE_XCBC = 6,	/* AES and Camellia */
	NLM_HASH_MODE_CBC_MAC = 7,	/* AES and Camellia */
	NLM_HASH_MODE_CCM = 8,	/* AES */
	NLM_HASH_MODE_GCM = 9,	/* AES */
	NLM_HASH_MODE_MAX = 0xA,
}; 

/**
* @brief crypto control descriptor, should be cache aligned
* @ingroup crypto
*/
struct nlm_crypto_pkt_ctrl {
	uint64_t desc0;
	/* combination of cipher and hash keys */
	uint64_t key[MAX_KEY_LEN_IN_DW];
	uint32_t cipherkeylen; 
	uint32_t hashkeylen; 
	uint32_t taglen;
};

/**
* @brief crypto packet descriptor, should be cache aligned  
* @ingroup crypto
*/
struct nlm_crypto_pkt_param {
	uint64_t desc0;
 	uint64_t desc1;
	uint64_t desc2;
	uint64_t desc3;
	uint64_t segment[1][2];
};

static __inline__ uint64_t
nlm_crypto_form_rsa_ecc_fmn_entry0(unsigned int l3alloc, unsigned int type, 
    unsigned int func, uint64_t srcaddr)
{
	return (left_shift64(l3alloc, 61, 1) | 
	    left_shift64(type, 46, 7) |
	    left_shift64(func, 40, 6) |
	    left_shift64(srcaddr, 0, 40));
}

static __inline__ uint64_t
nlm_crypto_form_rsa_ecc_fmn_entry1(unsigned int dstclobber,
    unsigned int l3alloc, unsigned int fbvc, uint64_t dstaddr)
{
	return (left_shift64(dstclobber, 62, 1) |
	    left_shift64(l3alloc, 61, 1) |
	    left_shift64(fbvc, 40, 12) |
	    left_shift64(dstaddr, 0, 40));
}

/**
* @brief Generate cypto control descriptor
* @ingroup crypto
* hmac : 1 for hash with hmac 
* hashalg, see hash_alg enums
* hashmode, see hash_mode enums
* cipherhalg, see  cipher_alg enums
* ciphermode, see  cipher_mode enums
* arc4_cipherkeylen : length of arc4 cipher key, 0 is interpreted as 32 
* arc4_keyinit : 
* cfbmask : cipher text for feedback, 
*           0(1 bit), 1(2 bits), 2(4 bits), 3(8 bits), 4(16bits), 5(32 bits),
*           6(64 bits), 7(128 bits)
*/
static __inline__ uint64_t
nlm_crypto_form_pkt_ctrl_desc(unsigned int hmac, unsigned int hashalg,
    unsigned int hashmode, unsigned int cipheralg, unsigned int ciphermode,
    unsigned int arc4_cipherkeylen, unsigned int arc4_keyinit,
    unsigned int cfbmask)
{
	return (left_shift64(hmac, 61, 1) | 
	    left_shift64(hashalg, 52, 8) | 
	    left_shift64(hashmode, 43, 8) | 
	    left_shift64(cipheralg, 34, 8) | 
	    left_shift64(ciphermode, 25, 8) | 
	    left_shift64(arc4_cipherkeylen, 18, 5) | 
	    left_shift64(arc4_keyinit, 17, 1) | 
	    left_shift64(cfbmask, 0, 3));
}
/**
* @brief Generate cypto packet descriptor 0
* @ingroup crypto
* tls : 1 (tls enabled) 0(tls disabled)
* hash_source : 1 (encrypted data is sent to the auth engine)
*               0 (plain data is sent to the auth engine)
* hashout_l3alloc : 1 (auth output is transited through l3 cache)
* encrypt : 1 (for encrypt) 0 (for decrypt)
* ivlen : iv length in bytes
* hashdst_addr : hash out physical address, byte aligned
*/
static __inline__ uint64_t
nlm_crypto_form_pkt_desc0(unsigned int tls, unsigned int hash_source,
    unsigned int hashout_l3alloc, unsigned int encrypt, unsigned int ivlen,
    uint64_t hashdst_addr)
{
	return (left_shift64(tls, 63, 1) |
	    left_shift64(hash_source, 62, 1) |
	    left_shift64(hashout_l3alloc, 60, 1) |
	    left_shift64(encrypt, 59, 1) |
	    left_shift64_mask((ivlen - 1), 41, 16) |
	    left_shift64(hashdst_addr, 0, 40));
}

/**
* @brief Generate cypto packet descriptor 1
* @ingroup crypto
* cipherlen : cipher length in bytes
* hashlen : hash length in bytes
*/
static __inline__ uint64_t
nlm_crypto_form_pkt_desc1(unsigned int cipherlen, unsigned int hashlen)
{
	return (left_shift64_mask((cipherlen - 1), 32, 32) |
	    left_shift64_mask((hashlen - 1), 0, 32));
}	

/**
* @brief Generate cypto packet descriptor 2
* @ingroup crypto
* ivoff : iv offset, offset from start of src data addr
* ciperbit_cnt : number of valid bits in the last input byte to the cipher,
*                0 (8 bits), 1 (1 bit)..7 (7 bits)
* cipheroff : cipher offset, offset from start of src data addr
* hashbit_cnt : number of valid bits in the last input byte to the auth
*              0 (8 bits), 1 (1 bit)..7 (7 bits)
* hashclobber : 1 (hash output will be written as multiples of cachelines, no
*              read modify write)
* hashoff : hash offset, offset from start of src data addr
*/

static __inline__ uint64_t
nlm_crypto_form_pkt_desc2(unsigned int ivoff, unsigned int cipherbit_cnt,
    unsigned int cipheroff, unsigned int hashbit_cnt, unsigned int hashclobber,
    unsigned int hashoff)
{
	return (left_shift64(ivoff , 45, 16) |
	    left_shift64(cipherbit_cnt, 42, 3) |
	    left_shift64(cipheroff, 22, 16) |
	    left_shift64(hashbit_cnt, 19, 3) |
	    left_shift64(hashclobber, 18, 1) |
	    left_shift64(hashoff, 0, 16));
}

/**
* @brief Generate cypto packet descriptor 3
* @ingroup crypto
* designer_vc : designer freeback fmn destination id
* taglen : length in bits of the tag generated by the auth engine
*          md5 (128 bits), sha1 (160), sha224 (224), sha384 (384),
*          sha512 (512), Kasumi (32), snow3g (32), gcm (128)
* hmacpad : 1 if hmac padding is already done 
*/
static  __inline__ uint64_t
nlm_crypto_form_pkt_desc3(unsigned int designer_vc, unsigned int taglen,
    unsigned int arc4_state_save_l3, unsigned int arc4_save_state,
    unsigned int hmacpad)
{
	return (left_shift64(designer_vc, 48, 16) |
	    left_shift64(taglen, 11, 16) |
	    left_shift64(arc4_state_save_l3, 8, 1) |
	    left_shift64(arc4_save_state, 6, 1) |
	    left_shift64(hmacpad, 5, 1));
}

/**
* @brief Generate cypto packet descriptor 4
* @ingroup crypto
* srcfraglen : length of the source fragment(header + data + tail) in bytes
* srcfragaddr : physical address of the srouce fragment
*/
static __inline__ uint64_t
nlm_crypto_form_pkt_desc4(uint64_t srcfraglen,
    unsigned int srcfragaddr )
{
	return (left_shift64_mask((srcfraglen - 1), 48, 16) |
	    left_shift64(srcfragaddr, 0, 40));
}

/**
* @brief Generate cypto packet descriptor 5
* @ingroup crypto
* dstfraglen : length of the dst fragment(header + data + tail) in bytes
* chipherout_l3alloc : 1(cipher output is transited through l3 cache)
* cipherclobber : 1 (cipher output will be written as multiples of cachelines,
*                 no read modify write)
* chiperdst_addr : physical address of the cipher destination address
*/
static __inline__ uint64_t
nlm_crypto_form_pkt_desc5(unsigned int dstfraglen,
    unsigned int cipherout_l3alloc, unsigned int cipherclobber,
    uint64_t cipherdst_addr)

{
	return (left_shift64_mask((dstfraglen - 1), 48, 16) |
	    left_shift64(cipherout_l3alloc, 46, 1) |
	    left_shift64(cipherclobber, 41, 1) |
	    left_shift64(cipherdst_addr, 0, 40));
}

/**
  * @brief Generate crypto packet fmn message entry 0
  * @ingroup crypto
  * freeback_vc: freeback response destination address
  * designer_fblen : Designer freeback length, 1 - 4
  * designerdesc_valid : designer desc valid or not
  * cipher_keylen : cipher key length in bytes
  * ctrldesc_addr : physicall address of the control descriptor
  */
static __inline__ uint64_t
nlm_crypto_form_pkt_fmn_entry0(unsigned int freeback_vc,
    unsigned int designer_fblen, unsigned int designerdesc_valid,
    unsigned int cipher_keylen, uint64_t cntldesc_addr)
{
	return (left_shift64(freeback_vc, 48, 16) |
	    left_shift64_mask(designer_fblen - 1, 46, 2) |
	    left_shift64(designerdesc_valid, 45, 1) |
	    left_shift64_mask(((cipher_keylen + 7) >> 3), 40, 5) |
	    left_shift64(cntldesc_addr >> 6, 0, 34));
}

/**
  * @brief Generate crypto packet fmn message entry 1
  * @ingroup crypto
  * arc4load_state : 1 if load state required 0 otherwise
  * hash_keylen : hash key length in bytes
  * pktdesc_size : packet descriptor size in bytes
  * pktdesc_addr : physicall address of the packet descriptor
  */
static __inline__ uint64_t
nlm_crypto_form_pkt_fmn_entry1(unsigned int arc4load_state,
    unsigned int hash_keylen, unsigned int pktdesc_size,
    uint64_t pktdesc_addr)
{
	return (left_shift64(arc4load_state, 63, 1) |
	    left_shift64_mask(((hash_keylen + 7) >> 3), 56, 5) |
	    left_shift64_mask(((pktdesc_size >> 4) - 1), 43, 12) |
	    left_shift64(pktdesc_addr >> 6, 0, 34));
}

static __inline__ int
nlm_crypto_get_hklen_taglen(enum nlm_hash_algo hashalg,
    enum nlm_hash_mode hashmode, unsigned int *taglen, unsigned int *hklen)
{
	if (hashalg == NLM_HASH_MD5) {
		*taglen = 128;
		*hklen  = 64;
	} else if (hashalg == NLM_HASH_SHA) {
		switch (hashmode) {
		case NLM_HASH_MODE_SHA1: 
			*taglen = 160;
			*hklen  = 64;
			break;
		case NLM_HASH_MODE_SHA224: 
			*taglen = 224;
			*hklen  = 64;
			break;
		case NLM_HASH_MODE_SHA256: 
			*taglen = 256;
			*hklen  = 64;
			break;
		case NLM_HASH_MODE_SHA384: 
			*taglen = 384;
			*hklen  = 128;
			break;
		case NLM_HASH_MODE_SHA512: 
			*taglen = 512;
			*hklen  = 128;
			break;
		default:
			printf("Error : invalid shaid (%s)\n", __func__);
			return (-1);
		}
	} else if (hashalg == NLM_HASH_KASUMI_F9) {
		*taglen = 32;
		*hklen  = 0;
	} else if (hashalg == NLM_HASH_SNOW3G_F9) {
		*taglen = 32;
		*hklen  = 0;
	} else if (hashmode == NLM_HASH_MODE_XCBC) {
		*taglen = 128;
		*hklen  = 0;
	} else if (hashmode == NLM_HASH_MODE_GCM) {
		*taglen = 128;
		*hklen  = 0;
	} else if (hashalg == NLM_HASH_BYPASS) {
		*taglen = 0;
		*hklen  = 0;
	} else {
		printf("Error:Hash alg/mode not found\n");
		return (-1);
	}

	/* TODO : Add remaining cases */
	return (0);
}

/**
* @brief Generate fill cryto control info structure
* @ingroup crypto
* hmac : 1 for hash with hmac 
* hashalg: see above,  hash_alg enums
* hashmode: see above, hash_mode enums
* cipherhalg: see above,  cipher_alg enums
* ciphermode: see above, cipher_mode enums
*
*/
static __inline__ int
nlm_crypto_fill_pkt_ctrl(struct nlm_crypto_pkt_ctrl *ctrl, unsigned int hmac,
    enum nlm_hash_algo hashalg, enum nlm_hash_mode hashmode,
    enum nlm_cipher_algo cipheralg, enum nlm_cipher_mode ciphermode,
    unsigned char *cipherkey, unsigned int cipherkeylen,
    unsigned char *hashkey, unsigned int hashkeylen)
{
	unsigned int taglen = 0, hklen = 0;

	ctrl->desc0 = nlm_crypto_form_pkt_ctrl_desc(hmac, hashalg, hashmode, 
	    cipheralg, ciphermode, 0, 0, 0);
	memset(ctrl->key, 0, sizeof(ctrl->key));
	if (cipherkey)
		memcpy(ctrl->key, cipherkey, cipherkeylen);
	if (hashkey)
		memcpy((unsigned char *)&ctrl->key[(cipherkeylen + 7) / 8],
			    hashkey, hashkeylen);
	if (nlm_crypto_get_hklen_taglen(hashalg, hashmode, &taglen, &hklen)
	    < 0)
		return (-1);

	ctrl->cipherkeylen = cipherkeylen;
	ctrl->hashkeylen = hklen;
	ctrl->taglen = taglen;
	
	/* TODO : add the invalid checks and return error */
	return (0);
}

/**
* @brief Top level function for generation pkt desc 0 to 3 for cipher auth
* @ingroup crypto
* ctrl : pointer to control structure
* param : pointer to the param structure
* encrypt : 1(for encrypt) 0(for decrypt)
* hash_source : 1(encrypted data is sent to the auth engine) 0(plain data is
*		sent to the auth engine)
* ivoff : iv offset from start of data
* ivlen : iv length in bytes
* hashoff : hash offset from start of data
* hashlen : hash length in bytes
* hmacpad : hmac padding required or not, 1 if already padded
* cipheroff : cipher offset from start of data
* cipherlen : cipher length in bytes
* hashdst_addr : hash destination physical address
*/
static __inline__ void
nlm_crypto_fill_cipher_auth_pkt_param(struct nlm_crypto_pkt_ctrl *ctrl,
    struct nlm_crypto_pkt_param *param, unsigned int encrypt,
    unsigned int hash_source, unsigned int ivoff, unsigned int ivlen,
    unsigned int hashoff, unsigned int hashlen, unsigned int hmacpad,
    unsigned int cipheroff, unsigned int cipherlen, unsigned char *hashdst_addr)
{
	param->desc0 = nlm_crypto_form_pkt_desc0(0, hash_source, 1, encrypt,
			   ivlen, vtophys(hashdst_addr));
	param->desc1 = nlm_crypto_form_pkt_desc1(cipherlen, hashlen);
	param->desc2 = nlm_crypto_form_pkt_desc2(ivoff, 0, cipheroff, 0, 0,
			   hashoff);
	param->desc3 = nlm_crypto_form_pkt_desc3(0, ctrl->taglen, 0, 0,
			   hmacpad);
}

/**
* @brief Top level function for generation pkt desc 0 to 3 for cipher operation
* @ingroup crypto
* ctrl : pointer to control structure
* param : pointer to the param structure
* encrypt : 1(for encrypt) 0(for decrypt)
* ivoff : iv offset from start of data
* ivlen : iv length in bytes
* cipheroff : cipher offset from start of data
* cipherlen : cipher length in bytes
*/

		
static __inline__ void
nlm_crypto_fill_cipher_pkt_param(struct nlm_crypto_pkt_ctrl *ctrl,
    struct nlm_crypto_pkt_param *param, unsigned int encrypt,
    unsigned int ivoff, unsigned int ivlen, unsigned int cipheroff,
    unsigned int cipherlen)
{
	param->desc0 = nlm_crypto_form_pkt_desc0(0, 0, 0, encrypt, ivlen, 0ULL);
	param->desc1 = nlm_crypto_form_pkt_desc1(cipherlen, 1);
	param->desc2 = nlm_crypto_form_pkt_desc2(ivoff, 0, cipheroff, 0, 0, 0);
	param->desc3 = nlm_crypto_form_pkt_desc3(0, ctrl->taglen, 0, 0, 0);
}

/**
* @brief Top level function for generation pkt desc 0 to 3 for auth operation
* @ingroup crypto
* ctrl : pointer to control structure
* param : pointer to the param structure
* hashoff : hash offset from start of data
* hashlen : hash length in bytes
* hmacpad : hmac padding required or not, 1 if already padded
* hashdst_addr : hash destination physical address
*/
static __inline__ void
nlm_crypto_fill_auth_pkt_param(struct nlm_crypto_pkt_ctrl *ctrl,
    struct nlm_crypto_pkt_param *param, unsigned int hashoff,
    unsigned int hashlen, unsigned int hmacpad, unsigned char *hashdst_addr)
{
	param->desc0 = nlm_crypto_form_pkt_desc0(0, 0, 1, 0, 1,
			   vtophys(hashdst_addr));
	param->desc1 = nlm_crypto_form_pkt_desc1(1, hashlen);
	param->desc2 = nlm_crypto_form_pkt_desc2(0, 0, 0, 0, 0, hashoff);
	param->desc3 = nlm_crypto_form_pkt_desc3(0, ctrl->taglen, 0, 0,
			   hmacpad);
}

static __inline__ unsigned int
nlm_crypto_fill_src_seg(struct nlm_crypto_pkt_param *param, int seg,
    unsigned char *input, unsigned int inlen)
{
	unsigned off = 0, len = 0;
	unsigned int remlen = inlen;

	for (; remlen > 0;) {
		len = remlen > NLM_CRYPTO_MAX_SEG_LEN ?
		    NLM_CRYPTO_MAX_SEG_LEN : remlen;
		param->segment[seg][0] = nlm_crypto_form_pkt_desc4(len,
		    vtophys(input + off));
		remlen -= len;
		off += len;
		seg++;
	}
	return (seg);
}

static __inline__ unsigned int
nlm_crypto_fill_dst_seg(struct nlm_crypto_pkt_param *param, 
		int seg, unsigned char *output, unsigned int outlen)
{
	unsigned off = 0, len = 0;
	unsigned int remlen = outlen;

	for (; remlen > 0;) {
		len = remlen > NLM_CRYPTO_MAX_SEG_LEN ?
		    NLM_CRYPTO_MAX_SEG_LEN : remlen;
		param->segment[seg][1] = nlm_crypto_form_pkt_desc5(len, 1, 0,
		    vtophys(output + off));
		remlen -= len;
		off += len;
		seg++;
	}
	return (seg);
}

#endif