9b4d140639
Support for the Security and RSA blocks on XLP SoC. Even though the XLP supports many more algorithms, only the ones supported in OCF have been added. Submitted by: Venkatesh J. V. (venkatesh at netlogicmicro com)
557 lines
15 KiB
C
557 lines
15 KiB
C
/*-
|
|
* 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.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/cdefs.h>
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/errno.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/module.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/mutex.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/random.h>
|
|
#include <sys/rman.h>
|
|
#include <sys/uio.h>
|
|
#include <sys/kobj.h>
|
|
|
|
#include <dev/pci/pcivar.h>
|
|
|
|
#include <opencrypto/cryptodev.h>
|
|
|
|
#include "cryptodev_if.h"
|
|
|
|
#include <vm/vm.h>
|
|
#include <vm/pmap.h>
|
|
|
|
#include <mips/nlm/hal/haldefs.h>
|
|
#include <mips/nlm/hal/iomap.h>
|
|
#include <mips/nlm/xlp.h>
|
|
#include <mips/nlm/hal/sys.h>
|
|
#include <mips/nlm/hal/fmn.h>
|
|
#include <mips/nlm/hal/nlmsaelib.h>
|
|
#include <mips/nlm/dev/sec/nlmrsalib.h>
|
|
#include <mips/nlm/dev/sec/rsa_ucode.h>
|
|
#include <mips/nlm/hal/cop2.h>
|
|
#include <mips/nlm/hal/mips-extns.h>
|
|
#include <mips/nlm/msgring.h>
|
|
|
|
#ifdef NLM_RSA_DEBUG
|
|
int print_krp_params(struct cryptkop *krp);
|
|
#endif
|
|
|
|
static int xlp_rsa_init(struct xlp_rsa_softc *sc, int node);
|
|
static int xlp_rsa_newsession(device_t , uint32_t *, struct cryptoini *);
|
|
static int xlp_rsa_freesession(device_t , uint64_t);
|
|
static int xlp_rsa_kprocess(device_t , struct cryptkop *, int);
|
|
static int xlp_get_rsa_opsize(struct xlp_rsa_command *cmd, unsigned int bits);
|
|
static void xlp_free_cmd_params(struct xlp_rsa_command *cmd);
|
|
static int xlp_rsa_inp2hwformat(uint8_t *src, uint8_t *dst,
|
|
uint32_t paramsize, uint8_t result);
|
|
|
|
static int xlp_rsa_probe(device_t);
|
|
static int xlp_rsa_attach(device_t);
|
|
static int xlp_rsa_detach(device_t);
|
|
|
|
static device_method_t xlp_rsa_methods[] = {
|
|
/* device interface */
|
|
DEVMETHOD(device_probe, xlp_rsa_probe),
|
|
DEVMETHOD(device_attach, xlp_rsa_attach),
|
|
DEVMETHOD(device_detach, xlp_rsa_detach),
|
|
|
|
/* bus interface */
|
|
DEVMETHOD(bus_print_child, bus_generic_print_child),
|
|
DEVMETHOD(bus_driver_added, bus_generic_driver_added),
|
|
|
|
/* crypto device methods */
|
|
DEVMETHOD(cryptodev_newsession, xlp_rsa_newsession),
|
|
DEVMETHOD(cryptodev_freesession,xlp_rsa_freesession),
|
|
DEVMETHOD(cryptodev_kprocess, xlp_rsa_kprocess),
|
|
|
|
DEVMETHOD_END
|
|
};
|
|
|
|
static driver_t xlp_rsa_driver = {
|
|
"nlmrsa",
|
|
xlp_rsa_methods,
|
|
sizeof(struct xlp_rsa_softc)
|
|
};
|
|
static devclass_t xlp_rsa_devclass;
|
|
|
|
DRIVER_MODULE(nlmrsa, pci, xlp_rsa_driver, xlp_rsa_devclass, 0, 0);
|
|
MODULE_DEPEND(nlmrsa, crypto, 1, 1, 1);
|
|
|
|
void
|
|
nlm_xlprsaecc_msgring_handler(int vc, int size, int code, int src_id,
|
|
struct nlm_fmn_msg *msg, void *data);
|
|
|
|
#ifdef NLM_RSA_DEBUG
|
|
int
|
|
print_krp_params(struct cryptkop *krp)
|
|
{
|
|
int i;
|
|
|
|
printf("krp->krp_op :%d\n",krp->krp_op);
|
|
printf("krp->krp_status :%d\n",krp->krp_status);
|
|
printf("krp->krp_iparams:%d\n",krp->krp_iparams);
|
|
printf("krp->krp_oparams:%d\n",krp->krp_oparams);
|
|
for (i=0;i<krp->krp_iparams+krp->krp_oparams;i++) {
|
|
printf("krp->krp_param[%d].crp_p :0x%llx\n",i,
|
|
(unsigned long long)krp->krp_param[i].crp_p);
|
|
printf("krp->krp_param[%d].crp_nbits :%d\n",i,
|
|
krp->krp_param[i].crp_nbits);
|
|
printf("krp->krp_param[%d].crp_nbytes :%d\n",i,
|
|
(krp->krp_param[i].crp_nbits+7)/8);
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
xlp_rsa_init(struct xlp_rsa_softc *sc, int node)
|
|
{
|
|
struct xlp_rsa_command *cmd = NULL;
|
|
uint32_t size, fbvc, dstvc, endsel, regval;
|
|
struct nlm_fmn_msg m;
|
|
int err, ret, i;
|
|
uint64_t base;
|
|
|
|
/* Register interrupt handler for the RSA/ECC CMS messages */
|
|
if (register_msgring_handler(sc->rsaecc_vc_start,
|
|
sc->rsaecc_vc_end, nlm_xlprsaecc_msgring_handler, sc) != 0) {
|
|
err = -1;
|
|
printf("Couldn't register rsa/ecc msgring handler\n");
|
|
goto errout;
|
|
}
|
|
m.msg[0] = m.msg[1] = m.msg[2] = m.msg[3] = 0;
|
|
fbvc = nlm_cpuid() / CMS_MAX_VCPU_VC;
|
|
/* Do the CMS credit initialization */
|
|
/* Currently it is configured by default to 50 when kernel comes up */
|
|
|
|
if ((cmd = malloc(sizeof(struct xlp_rsa_command), M_DEVBUF,
|
|
M_NOWAIT | M_ZERO)) == NULL) {
|
|
err = ENOMEM;
|
|
printf("Failed to allocate mem for cmd\n");
|
|
goto errout;
|
|
}
|
|
size = sizeof(nlm_rsa_ucode_data);
|
|
if ((cmd->rsasrc = malloc(size, M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) {
|
|
err = ENOMEM;
|
|
printf("Failed to allocate mem for cmd->rsasrc\n");
|
|
goto errout;
|
|
}
|
|
if (((uintptr_t)cmd->rsasrc & (XLP_L2L3_CACHELINE_SIZE - 1))) {
|
|
err = EINVAL;
|
|
printf("cmd->rsasrc is not cacheline aligned\n");
|
|
goto errout;
|
|
}
|
|
memcpy(cmd->rsasrc, (uint8_t *)nlm_rsa_ucode_data, size);
|
|
m.msg[0] = nlm_crypto_form_rsa_ecc_fmn_entry0(1, 0x70, 0,
|
|
vtophys(cmd->rsasrc));
|
|
m.msg[1] = nlm_crypto_form_rsa_ecc_fmn_entry1(0, 1, fbvc,
|
|
vtophys(cmd->rsasrc));
|
|
/* Software scratch pad */
|
|
m.msg[2] = (uintptr_t)cmd;
|
|
|
|
for (dstvc = sc->rsaecc_vc_start; dstvc <= sc->rsaecc_vc_end; dstvc++) {
|
|
ret = nlm_fmn_msgsend(dstvc, 3, FMN_SWCODE_RSA, &m);
|
|
if (ret != 0) {
|
|
err = -1;
|
|
printf("%s: msgsnd failed (%x)\n", __func__, ret);
|
|
goto errout;
|
|
}
|
|
}
|
|
/* Configure so that all VCs send request to all RSA pipes */
|
|
base = nlm_get_rsa_regbase(node);
|
|
if (nlm_is_xlp3xx()) {
|
|
endsel = 1;
|
|
regval = 0xFFFF;
|
|
} else {
|
|
endsel = 3;
|
|
regval = 0x07FFFFFF;
|
|
}
|
|
for (i = 0; i < endsel; i++)
|
|
nlm_write_rsa_reg(base, RSA_ENG_SEL_0 + i, regval);
|
|
return (0);
|
|
errout:
|
|
xlp_free_cmd_params(cmd);
|
|
return (err);
|
|
}
|
|
|
|
/* This function is called from an interrupt handler */
|
|
void
|
|
nlm_xlprsaecc_msgring_handler(int vc, int size, int code, int src_id,
|
|
struct nlm_fmn_msg *msg, void *data)
|
|
{
|
|
struct xlp_rsa_command *cmd = NULL;
|
|
struct xlp_rsa_softc *sc = NULL;
|
|
|
|
KASSERT(code == FMN_SWCODE_RSA,
|
|
("%s: bad code = %d, expected code = %d\n", __FUNCTION__, code,
|
|
FMN_SWCODE_RSA));
|
|
|
|
sc = (struct xlp_rsa_softc *)data;
|
|
KASSERT(src_id >= sc->rsaecc_vc_start && src_id <= sc->rsaecc_vc_end,
|
|
("%s: bad src_id = %d, expect %d - %d\n", __FUNCTION__,
|
|
src_id, sc->rsaecc_vc_start, sc->rsaecc_vc_end));
|
|
|
|
cmd = (struct xlp_rsa_command *)(uintptr_t)msg->msg[1];
|
|
KASSERT(cmd != NULL, ("%s:cmd not received properly\n",
|
|
__FUNCTION__));
|
|
|
|
KASSERT(RSA_ERROR(msg->msg[0]) == 0,
|
|
("%s: Message rcv msg0 %llx msg1 %llx err %x \n", __FUNCTION__,
|
|
(unsigned long long)msg->msg[0], (unsigned long long)msg->msg[1],
|
|
(int)RSA_ERROR(msg->msg[0])));
|
|
|
|
xlp_rsa_inp2hwformat(((uint8_t *)cmd->rsasrc+
|
|
(cmd->rsaopsize*cmd->krp->krp_iparams)),
|
|
cmd->krp->krp_param[cmd->krp->krp_iparams].crp_p,
|
|
((cmd->krp->krp_param[cmd->krp->krp_iparams].crp_nbits+7)/8), 1);
|
|
|
|
if (cmd->krp != NULL)
|
|
crypto_kdone(cmd->krp);
|
|
|
|
xlp_free_cmd_params(cmd);
|
|
|
|
return;
|
|
}
|
|
|
|
static int
|
|
xlp_rsa_probe(device_t dev)
|
|
{
|
|
struct xlp_rsa_softc *sc;
|
|
|
|
if (pci_get_vendor(dev) == PCI_VENDOR_NETLOGIC &&
|
|
pci_get_device(dev) == PCI_DEVICE_ID_NLM_RSA) {
|
|
sc = device_get_softc(dev);
|
|
return (BUS_PROBE_DEFAULT);
|
|
}
|
|
return (ENXIO);
|
|
}
|
|
|
|
/*
|
|
* Attach an interface that successfully probed.
|
|
*/
|
|
static int
|
|
xlp_rsa_attach(device_t dev)
|
|
{
|
|
struct xlp_rsa_softc *sc = device_get_softc(dev);
|
|
uint64_t base;
|
|
int qstart, qnum;
|
|
int freq, node;
|
|
|
|
sc->sc_dev = dev;
|
|
|
|
node = nlm_get_device_node(pci_get_slot(dev));
|
|
freq = nlm_set_device_frequency(node, DFS_DEVICE_RSA, 250);
|
|
if (bootverbose)
|
|
device_printf(dev, "RSA Freq: %dMHz\n", freq);
|
|
if(pci_get_device(dev) == PCI_DEVICE_ID_NLM_RSA) {
|
|
device_set_desc(dev, "XLP RSA/ECC Accelerator");
|
|
if ((sc->sc_cid = crypto_get_driverid(dev,
|
|
CRYPTOCAP_F_HARDWARE)) < 0) {
|
|
printf("xlp_rsaecc-err:couldn't get the driver id\n");
|
|
goto error_exit;
|
|
}
|
|
if (crypto_kregister(sc->sc_cid, CRK_MOD_EXP, 0) != 0)
|
|
printf("register failed for CRK_MOD_EXP\n");
|
|
|
|
base = nlm_get_rsa_pcibase(node);
|
|
qstart = nlm_qidstart(base);
|
|
qnum = nlm_qnum(base);
|
|
sc->rsaecc_vc_start = qstart;
|
|
sc->rsaecc_vc_end = qstart + qnum - 1;
|
|
}
|
|
if (xlp_rsa_init(sc, node) != 0)
|
|
goto error_exit;
|
|
device_printf(dev, "RSA Initialization complete!\n");
|
|
return (0);
|
|
|
|
error_exit:
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
/*
|
|
* Detach an interface that successfully probed.
|
|
*/
|
|
static int
|
|
xlp_rsa_detach(device_t dev)
|
|
{
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Allocate a new 'session' and return an encoded session id. 'sidp'
|
|
* contains our registration id, and should contain an encoded session
|
|
* id on successful allocation.
|
|
*/
|
|
static int
|
|
xlp_rsa_newsession(device_t dev, u_int32_t *sidp, struct cryptoini *cri)
|
|
{
|
|
struct xlp_rsa_softc *sc = device_get_softc(dev);
|
|
int sesn;
|
|
struct xlp_rsa_session *ses = NULL;
|
|
|
|
if (sidp == NULL || cri == NULL || sc == NULL)
|
|
return (EINVAL);
|
|
|
|
if (sc->sc_sessions == NULL) {
|
|
ses = sc->sc_sessions = malloc(sizeof(struct xlp_rsa_session),
|
|
M_DEVBUF, M_NOWAIT);
|
|
if (ses == NULL)
|
|
return (ENOMEM);
|
|
sesn = 0;
|
|
sc->sc_nsessions = 1;
|
|
} else {
|
|
for (sesn = 0; sesn < sc->sc_nsessions; sesn++) {
|
|
if (!sc->sc_sessions[sesn].hs_used) {
|
|
ses = &sc->sc_sessions[sesn];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ses == NULL) {
|
|
sesn = sc->sc_nsessions;
|
|
ses = malloc((sesn + 1)*sizeof(struct xlp_rsa_session),
|
|
M_DEVBUF, M_NOWAIT);
|
|
if (ses == NULL)
|
|
return (ENOMEM);
|
|
bcopy(sc->sc_sessions, ses, sesn * sizeof(*ses));
|
|
bzero(sc->sc_sessions, sesn * sizeof(*ses));
|
|
free(sc->sc_sessions, M_DEVBUF);
|
|
sc->sc_sessions = ses;
|
|
ses = &sc->sc_sessions[sesn];
|
|
sc->sc_nsessions++;
|
|
}
|
|
}
|
|
bzero(ses, sizeof(*ses));
|
|
ses->sessionid = sesn;
|
|
ses->hs_used = 1;
|
|
|
|
*sidp = XLP_RSA_SID(device_get_unit(sc->sc_dev), sesn);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Deallocate a session.
|
|
* XXX this routine should run a zero'd mac/encrypt key into context ram.
|
|
* XXX to blow away any keys already stored there.
|
|
*/
|
|
static int
|
|
xlp_rsa_freesession(device_t dev, u_int64_t tid)
|
|
{
|
|
struct xlp_rsa_softc *sc = device_get_softc(dev);
|
|
int session;
|
|
u_int32_t sid = CRYPTO_SESID2LID(tid);
|
|
|
|
if (sc == NULL)
|
|
return (EINVAL);
|
|
|
|
session = XLP_RSA_SESSION(sid);
|
|
if (session >= sc->sc_nsessions)
|
|
return (EINVAL);
|
|
|
|
sc->sc_sessions[session].hs_used = 0;
|
|
return (0);
|
|
}
|
|
|
|
static void
|
|
xlp_free_cmd_params(struct xlp_rsa_command *cmd)
|
|
{
|
|
if (cmd->rsasrc != NULL)
|
|
free(cmd->rsasrc, M_DEVBUF);
|
|
if (cmd != NULL)
|
|
free(cmd, M_DEVBUF);
|
|
return;
|
|
}
|
|
|
|
static int
|
|
xlp_get_rsa_opsize(struct xlp_rsa_command *cmd, unsigned int bits)
|
|
{
|
|
if (bits == 0)
|
|
return (-1);
|
|
/* XLP hardware expects always a fixed size with unused bytes
|
|
* zeroed out in the input data */
|
|
if (bits <= 512) {
|
|
cmd->rsatype = 0x40;
|
|
cmd->rsaopsize = (512/8);
|
|
return (0);
|
|
} else if ((bits > 512) && (bits <= 1024)) {
|
|
cmd->rsatype = 0x41;
|
|
cmd->rsaopsize = (1024/8);
|
|
return (0);
|
|
} else if ((bits > 1024) && (bits <= 2048)) {
|
|
cmd->rsatype = 0x42;
|
|
cmd->rsaopsize = (2048/8);
|
|
return (0);
|
|
} else if ((bits > 2048) && (bits <= 4096)) {
|
|
cmd->rsatype = 0x43;
|
|
cmd->rsaopsize = (4096/8);
|
|
return (0);
|
|
} else if ((bits > 4096) && (bits <= 8192)) {
|
|
cmd->rsatype = 0x44;
|
|
cmd->rsaopsize = (8192/8);
|
|
return (0);
|
|
} else {
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
static int
|
|
xlp_rsa_inp2hwformat(uint8_t *src, uint8_t *dst, uint32_t paramsize,
|
|
uint8_t result)
|
|
{
|
|
uint32_t pdwords, pbytes;
|
|
int i=0, j=0, k=0;
|
|
|
|
pdwords = (paramsize / 8);
|
|
pbytes = (paramsize % 8);
|
|
|
|
for (i = 0, k = 0; i < pdwords; i++) {
|
|
/* copy dwords of inp/hw to hw/out format */
|
|
for (j = 7; j >= 0; j--, k++)
|
|
dst[(i*8)+j] = src[k];
|
|
}
|
|
if (pbytes) {
|
|
if (!result) {
|
|
/* copy rem bytes of input data to hw format */
|
|
for (j = 7; k < paramsize; j--, k++)
|
|
dst[(i*8)+j] = src[k];
|
|
} else {
|
|
/* copy rem bytes of hw data to exp output format */
|
|
for (j = 7; k < paramsize; j--, k++)
|
|
dst[k] = src[(i*8)+j];
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
nlm_crypto_complete_rsa_request(struct xlp_rsa_softc *sc,
|
|
struct xlp_rsa_command *cmd)
|
|
{
|
|
unsigned int fbvc;
|
|
struct nlm_fmn_msg m;
|
|
int ret;
|
|
|
|
fbvc = nlm_cpuid() / CMS_MAX_VCPU_VC;
|
|
m.msg[0] = m.msg[1] = m.msg[2] = m.msg[3] = 0;
|
|
|
|
m.msg[0] = nlm_crypto_form_rsa_ecc_fmn_entry0(1, cmd->rsatype,
|
|
cmd->rsafn, vtophys(cmd->rsasrc));
|
|
m.msg[1] = nlm_crypto_form_rsa_ecc_fmn_entry1(0, 1, fbvc,
|
|
vtophys(cmd->rsasrc + (cmd->rsaopsize * cmd->krp->krp_iparams)));
|
|
/* Software scratch pad */
|
|
m.msg[2] = (uintptr_t)cmd;
|
|
|
|
/* Send the message to rsa engine vc */
|
|
ret = nlm_fmn_msgsend(sc->rsaecc_vc_start, 3, FMN_SWCODE_RSA, &m);
|
|
if (ret != 0) {
|
|
#ifdef NLM_SEC_DEBUG
|
|
printf("%s: msgsnd failed (%x)\n", __func__, ret);
|
|
#endif
|
|
return (ERESTART);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
xlp_rsa_kprocess(device_t dev, struct cryptkop *krp, int hint)
|
|
{
|
|
struct xlp_rsa_softc *sc = device_get_softc(dev);
|
|
struct xlp_rsa_command *cmd = NULL;
|
|
int err = -1, i;
|
|
|
|
if (krp == NULL || krp->krp_callback == NULL)
|
|
return (EINVAL);
|
|
|
|
if ((cmd = malloc(sizeof(struct xlp_rsa_command), M_DEVBUF,
|
|
M_NOWAIT | M_ZERO)) == NULL) {
|
|
err = ENOMEM;
|
|
goto errout;
|
|
}
|
|
cmd->krp = krp;
|
|
|
|
#ifdef NLM_RSA_DEBUG
|
|
print_krp_params(krp);
|
|
#endif
|
|
switch (krp->krp_op) {
|
|
case CRK_MOD_EXP:
|
|
if (krp->krp_iparams == 3 && krp->krp_oparams == 1)
|
|
break;
|
|
goto errout;
|
|
default:
|
|
printf("Op:%d not yet supported\n", krp->krp_op);
|
|
goto errout;
|
|
}
|
|
|
|
if ((xlp_get_rsa_opsize(cmd,
|
|
krp->krp_param[krp->krp_iparams-1].crp_nbits)) != 0) {
|
|
err = EINVAL;
|
|
goto errout;
|
|
}
|
|
cmd->rsafn = 0; /* Mod Exp */
|
|
if ((cmd->rsasrc = malloc((cmd->rsaopsize *
|
|
(krp->krp_iparams+krp->krp_oparams)), M_DEVBUF,
|
|
M_NOWAIT | M_ZERO)) == NULL) {
|
|
err = ENOMEM;
|
|
goto errout;
|
|
}
|
|
if (((uintptr_t)cmd->rsasrc & (XLP_L2L3_CACHELINE_SIZE - 1))) {
|
|
err = EINVAL;
|
|
goto errout;
|
|
}
|
|
|
|
for (i=0;i<krp->krp_iparams;i++) {
|
|
KASSERT(krp->krp_param[i].crp_nbits != 0,
|
|
("%s: parameter[%d]'s length is zero\n", __FUNCTION__, i));
|
|
xlp_rsa_inp2hwformat(krp->krp_param[i].crp_p,
|
|
((uint8_t *)cmd->rsasrc+(i*cmd->rsaopsize)),
|
|
((krp->krp_param[i].crp_nbits+7)/8), 0);
|
|
}
|
|
if (nlm_crypto_complete_rsa_request(sc, cmd) != 0)
|
|
goto errout;
|
|
|
|
return (0);
|
|
errout:
|
|
xlp_free_cmd_params(cmd);
|
|
krp->krp_status = err;
|
|
crypto_kdone(krp);
|
|
return (err);
|
|
}
|