/*      $NetBSD: mvcesa.c,v 1.6 2022/05/22 11:39:27 riastradh Exp $     */
/*
* Copyright (c) 2008 KIYOHARA Takashi
* 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 THE AUTHOR ``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 THE AUTHOR 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>
__KERNEL_RCSID(0, "$NetBSD: mvcesa.c,v 1.6 2022/05/22 11:39:27 riastradh Exp $");

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/cprng.h>
#include <sys/device.h>
#include <sys/endian.h>
#include <sys/errno.h>
#include <sys/mbuf.h>
#include <sys/md5.h>
#include <sys/uio.h>
#include <sys/sha1.h>

#include <opencrypto/cryptodev.h>
#include <opencrypto/xform.h>

#include <dev/marvell/marvellreg.h>
#include <dev/marvell/marvellvar.h>
#include <dev/marvell/mvcesareg.h>

#include "locators.h"

#define MVCESA_SESSION(sid)             ((sid) & 0x0fffffff)
#define MVCESA_SID(crd, sesn)           (((crd) << 28) | ((sesn) & 0x0fffffff))


struct mvcesa_session {
       int ses_used;

       int ses_klen;
       uint32_t ses_key[8];

       uint32_t ses_hminner[5];        /* HMAC inner state */
       uint32_t ses_hmouter[5];        /* HMAC outer state */
};

struct mvcesa_softc {
       device_t sc_dev;

       bus_space_tag_t sc_iot;
       bus_space_handle_t sc_ioh;
       bus_dma_tag_t sc_dmat;

       int sc_cid;
       int sc_nsessions;
       struct mvcesa_session *sc_sessions;
};

static int mvcesa_match(device_t, cfdata_t, void *);
static void mvcesa_attach(device_t, device_t, void *);

static int mvcesa_intr(void *);

static int mvcesa_newsession(void *, u_int32_t *, struct cryptoini *);
static void mvcesa_freesession(void *, u_int64_t);
static int mvcesa_process(void *, struct cryptop *, int);

static int mvcesa_authentication(struct mvcesa_softc *, struct mvcesa_session *,
                                uint32_t, uint32_t *, uint32_t *, uint64_t,
                                int, int, char *, struct mbuf *, struct uio *);
static int mvcesa_des_encdec(struct mvcesa_softc *, struct mvcesa_session *,
                            uint32_t, uint32_t, uint32_t, uint32_t *, int, int,
                            char *, struct mbuf *, struct uio *);


CFATTACH_DECL_NEW(mvcesa_gt, sizeof(struct mvcesa_softc),
   mvcesa_match, mvcesa_attach, NULL, NULL);
CFATTACH_DECL_NEW(mvcesa_mbus, sizeof(struct mvcesa_softc),
   mvcesa_match, mvcesa_attach, NULL, NULL);


/* ARGSUSED */
static int
mvcesa_match(device_t parent, cfdata_t match, void *aux)
{
       struct marvell_attach_args *mva = aux;

       if (strcmp(mva->mva_name, match->cf_name) != 0)
               return 0;
       if (mva->mva_offset == MVA_OFFSET_DEFAULT ||
           mva->mva_irq == MVA_IRQ_DEFAULT)
               return 0;

       mva->mva_size = MVCESA_SIZE;
       return 1;
}

/* ARGSUSED */
static void
mvcesa_attach(device_t parent, device_t self, void *aux)
{
       struct mvcesa_softc *sc = device_private(self);
       struct marvell_attach_args *mva = aux;

       aprint_normal(
           ": Marvell Cryptographic Engines and Security Accelerator\n");
       aprint_naive("\n");

       sc->sc_dev = self;
       sc->sc_iot = mva->mva_iot;
       /* Map I/O registers */
       if (bus_space_subregion(mva->mva_iot, mva->mva_ioh, mva->mva_offset,
           mva->mva_size, &sc->sc_ioh)) {
               aprint_error_dev(self, "can't map registers\n");
               return;
       }
       sc->sc_dmat = mva->mva_dmat;

       sc->sc_nsessions = 0;

       /* Setup Opencrypto stuff */
       sc->sc_cid = crypto_get_driverid(0);
       if (sc->sc_cid < 0) {
               aprint_error_dev(self, "couldn't get crypto driver id\n");
               return;
       }
       crypto_register(sc->sc_cid, CRYPTO_DES_CBC, 0, 0,
           mvcesa_newsession, mvcesa_freesession, mvcesa_process, sc);
       crypto_register(sc->sc_cid, CRYPTO_3DES_CBC, 0, 0,
           mvcesa_newsession, mvcesa_freesession, mvcesa_process, sc);
#if __DMA_notyet__
/*
* Don't know how to process to AES CBC in PIO-mode.
* I havn't found IV registers.
*/
       crypto_register(sc->sc_cid, CRYPTO_AES_CBC, 0, 0,
           mvcesa_newsession, mvcesa_freesession, mvcesa_process, sc);
#endif
       crypto_register(sc->sc_cid, CRYPTO_SHA1, 0, 0,
           mvcesa_newsession, mvcesa_freesession, mvcesa_process, sc);
       crypto_register(sc->sc_cid, CRYPTO_SHA1_HMAC, 0, 0,
           mvcesa_newsession, mvcesa_freesession, mvcesa_process, sc);
       crypto_register(sc->sc_cid, CRYPTO_MD5, 0, 0,
           mvcesa_newsession, mvcesa_freesession, mvcesa_process, sc);
       crypto_register(sc->sc_cid, CRYPTO_MD5_HMAC, 0, 0,
           mvcesa_newsession, mvcesa_freesession, mvcesa_process, sc);

       /* Clear and establish interrupt */
       bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_IC, 0);
       marvell_intr_establish(mva->mva_irq, IPL_NET, mvcesa_intr, sc);

       bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_IM, 0);
}


static int
mvcesa_intr(void *arg)
{
#if 0
       struct mvcesa_softc *sc = (struct mvcesa_softc *)arg;
#endif
       int handled = 0;

       return handled;
}


/*
* Opencrypto functions
*/
/*
* 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
mvcesa_newsession(void *arg, u_int32_t *sidp, struct cryptoini *cri)
{
       struct mvcesa_softc *sc = (struct mvcesa_softc *)arg;
       struct cryptoini *c;
       struct mvcesa_session *ses = NULL;
       int sesn, count, enc, mac, i;

       KASSERT(sc != NULL /*, ("mvcesa_newsession: null softc")*/);
       if (sidp == NULL || cri == NULL || sc == NULL)
               return EINVAL;

       for (sesn = 0; sesn < sc->sc_nsessions; sesn++)
               if (sc->sc_sessions[sesn].ses_used == 0) {
                       ses = sc->sc_sessions + sesn;
                       break;
               }

       if (ses == NULL) {
               sesn = sc->sc_nsessions;
               ses = malloc((sesn + 1) * sizeof(*ses), M_DEVBUF, M_NOWAIT);
               if (ses == NULL)
                       return ENOMEM;
               if (sesn != 0) {
                       memcpy(ses, sc->sc_sessions, sesn * sizeof(*ses));
                       memset(sc->sc_sessions, 0, sesn * sizeof(*ses));
                       free(sc->sc_sessions, M_DEVBUF);
               }
               sc->sc_sessions = ses;
               ses = sc->sc_sessions + sesn;
               sc->sc_nsessions++;
       }
       memset(ses, 0, sizeof(*ses));

       count = 0;
       enc = mac = 0;
       for (c = cri; c != NULL; c = c->cri_next) {
               switch (c->cri_alg) {
               case CRYPTO_DES_CBC:
               case CRYPTO_3DES_CBC:
                       if (enc)
                               return EINVAL;
                       enc = 1;

                       /* Go ahead and compute key in CESA's byte order */
                       ses->ses_klen = c->cri_klen;
                       memcpy(ses->ses_key, c->cri_key, c->cri_klen / 8);
                       switch (c->cri_alg) {
                       case CRYPTO_3DES_CBC:
                               ses->ses_key[5] = htobe32(ses->ses_key[5]);
                               ses->ses_key[4] = htobe32(ses->ses_key[4]);
                               ses->ses_key[3] = htobe32(ses->ses_key[3]);
                               ses->ses_key[2] = htobe32(ses->ses_key[2]);

                               /* FALLTHROUGH */
                       case CRYPTO_DES_CBC:
                               ses->ses_key[1] = htobe32(ses->ses_key[1]);
                               ses->ses_key[0] = htobe32(ses->ses_key[0]);
                       }
                       break;

               case CRYPTO_SHA1_HMAC:
               case CRYPTO_MD5_HMAC:
               {
                       MD5_CTX md5ctx;
                       SHA1_CTX sha1ctx;
                       int klen_bytes = c->cri_klen / 8;

                       KASSERT(c->cri_klen == 512);

                       for (i = 0; i < klen_bytes; i++)
                               c->cri_key[i] ^= HMAC_IPAD_VAL;
                       if (c->cri_alg == CRYPTO_MD5_HMAC_96) {
                               MD5Init(&md5ctx);
                               MD5Update(&md5ctx, c->cri_key, klen_bytes);
                               MD5Update(&md5ctx, hmac_ipad_buffer,
                                   HMAC_BLOCK_LEN - klen_bytes);
                               memcpy(ses->ses_hminner, md5ctx.state,
                                   sizeof(md5ctx.state));
                       } else {
                               SHA1Init(&sha1ctx);
                               SHA1Update(&sha1ctx, c->cri_key, klen_bytes);
                               SHA1Update(&sha1ctx, hmac_ipad_buffer,
                                   HMAC_BLOCK_LEN - klen_bytes);
                               memcpy(ses->ses_hminner, sha1ctx.state,
                                   sizeof(sha1ctx.state));
                       }

                       for (i = 0; i < klen_bytes; i++)
                               c->cri_key[i] ^=
                                   (HMAC_IPAD_VAL ^ HMAC_OPAD_VAL);
                       if (c->cri_alg == CRYPTO_MD5_HMAC_96) {
                               MD5Init(&md5ctx);
                               MD5Update(&md5ctx, c->cri_key, klen_bytes);
                               MD5Update(&md5ctx, hmac_opad_buffer,
                                   HMAC_BLOCK_LEN - klen_bytes);
                               memcpy(ses->ses_hmouter, md5ctx.state,
                                   sizeof(md5ctx.state));
                       } else {
                               SHA1Init(&sha1ctx);
                               SHA1Update(&sha1ctx, c->cri_key, klen_bytes);
                               SHA1Update(&sha1ctx, hmac_opad_buffer,
                                   HMAC_BLOCK_LEN - klen_bytes);
                               memcpy(ses->ses_hmouter, sha1ctx.state,
                                   sizeof(sha1ctx.state));
                       }

                       for (i = 0; i < klen_bytes; i++)
                               c->cri_key[i] ^= HMAC_OPAD_VAL;
               }
                       /* FALLTHROUGH */

               case CRYPTO_SHA1:
               case CRYPTO_MD5:
                       if (mac)
                               return EINVAL;
                       mac = 1;
               }
               count++;
       }
       if (count > 2) {
               mvcesa_freesession(sc, sesn);
               return EINVAL;
       }

       *sidp = MVCESA_SID(device_unit(sc->sc_dev), sesn);
       ses->ses_used = 1;

       return 0;
}

/*
* Deallocate a session.
*/
static void
mvcesa_freesession(void *arg, u_int64_t tid)
{
       struct mvcesa_softc *sc = (struct mvcesa_softc *)arg;
       int session;
       uint32_t sid = ((uint32_t)tid) & 0xffffffff;

       session = MVCESA_SESSION(sid);
       KASSERTMSG(session >= 0, "session=%d", session);
       KASSERTMSG(session < sc->sc_nsessions, "session=%d nsessions=%d",
           session, sc->sc_nsessions);

       memset(&sc->sc_sessions[session], 0, sizeof(sc->sc_sessions[session]));
}

static int
mvcesa_process(void *arg, struct cryptop *crp, int hint)
{
       struct mvcesa_softc *sc = arg;
       struct mvcesa_session *ses;
       struct cryptodesc *crd;
       struct mbuf *m = NULL;
       struct uio *uio = NULL;
       int session;
       char *buf = NULL;

       session = MVCESA_SESSION(crp->crp_sid);
       KASSERTMSG(session < sc->sc_nsessions, "session=%d nsessions=%d",
           session, sc->sc_nsessions);
       ses = &sc->sc_sessions[session];

       if (crp->crp_flags & CRYPTO_F_IMBUF)
               m = (struct mbuf *)crp->crp_buf;
       else if (crp->crp_flags & CRYPTO_F_IOV)
               uio = (struct uio *)crp->crp_buf;
       else
               buf = (char *)crp->crp_buf;

       if (0 /* DMA support */) {
               /* not yet... */

               goto done;
       }

       /* PIO operation */

       for (crd = crp->crp_desc; crd; crd = crd->crd_next) {
               switch (crd->crd_alg) {
               case CRYPTO_DES_CBC:
               case CRYPTO_3DES_CBC:
               {
                       uint32_t alg, mode, dir, *iv, ivbuf[2];

                       mode = MVCESA_DESE_C_DESMODE_CBC;
                       if (crd->crd_alg == CRYPTO_DES_CBC)
                               alg = MVCESA_DESE_C_ALGORITHM_DES;
                       else {  /* CRYPTO_3DES_CBC */
                               alg = MVCESA_DESE_C_ALGORITHM_3DES;
                               mode |= MVCESA_DESE_C_3DESMODE_EDE;
                       }
                       if (crd->crd_flags & CRD_F_ENCRYPT) {
                               dir = MVCESA_DESE_C_DIRECTION_ENC;
                               if (crd->crd_flags & CRD_F_IV_EXPLICIT)
                                       iv = (uint32_t *)crd->crd_iv;
                               else {
                                       cprng_fast(ivbuf, sizeof(ivbuf));
                                       iv = ivbuf;
                               }
                               if (!(crd->crd_flags & CRD_F_IV_PRESENT)) {
                                       if (m != NULL)
                                               m_copyback(m, crd->crd_inject,
                                                   8, iv);
                                       else if (uio != NULL)
                                               cuio_copyback(uio,
                                                   crd->crd_inject, 8, iv);
                               }
                       } else {
                               dir = MVCESA_DESE_C_DIRECTION_DEC;
                               if (crd->crd_flags & CRD_F_IV_EXPLICIT)
                                       iv = (uint32_t *)crd->crd_iv;
                               else {
                                       if (m != NULL)
                                               m_copydata(m, crd->crd_inject,
                                                   8, ivbuf);
                                       else if (uio != NULL)
                                               cuio_copydata(uio,
                                                   crd->crd_inject, 8, ivbuf);
                                       iv = ivbuf;
                               }
                       }

                       crp->crp_etype = mvcesa_des_encdec(sc, ses,
                           alg, mode, dir, iv, crd->crd_skip, crd->crd_len,
                           buf, m, uio);
                       break;
               }

               case CRYPTO_SHA1:
               case CRYPTO_SHA1_HMAC:
               case CRYPTO_MD5:
               case CRYPTO_MD5_HMAC:
               {
                       uint64_t bits;
                       uint32_t alg, *iv = NULL, digest[512 / 8 / 4], dlen;

                       if (crd->crd_alg == CRYPTO_SHA1 ||
                           crd->crd_alg == CRYPTO_SHA1_HMAC) {
                               alg = MVCESA_SHA1MD5I_AC_ALGORITHM_SHA1;
                               dlen = 160;
                       } else {        /* CRYPTO_MD5 || CRYPTO_MD5_HMAC */
                               alg = MVCESA_SHA1MD5I_AC_ALGORITHM_MD5;
                               dlen = 128;
                       }
                       bits = crd->crd_len << 3;
                       if (crd->crd_alg == CRYPTO_SHA1_HMAC ||
                           crd->crd_alg == CRYPTO_MD5_HMAC) {
                               iv = ses->ses_hminner;
                               bits += 512;
                       }

                       crp->crp_etype = mvcesa_authentication(sc, ses,
                           alg, iv, digest, bits, crd->crd_skip, crd->crd_len,
                           buf, m, uio);
                       if (crp->crp_etype != 0)
                               break;

                       if (crd->crd_alg == CRYPTO_SHA1_HMAC ||
                           crd->crd_alg == CRYPTO_MD5_HMAC)
                               crp->crp_etype = mvcesa_authentication(sc,
                                   ses, alg, ses->ses_hmouter, digest,
                                   512 + dlen, 0, dlen, (char *)digest, NULL,
                                   NULL);
                       if (crp->crp_etype != 0)
                               break;

                       /* Inject the authentication data */
                       if (buf != NULL)
                               memcpy(buf + crd->crd_inject, digest, dlen / 8);
                       else if (m != NULL)
                               m_copyback(m, crd->crd_inject, dlen / 8,
                                   digest);
                       else if (uio != NULL)
                               memcpy(crp->crp_mac, digest, dlen / 8);
               }
               }
               if (crp->crp_etype != 0)
                       break;
       }

done:
       DPRINTF(("request %08x done\n", (uint32_t)crp));
       crypto_done(crp);
       return 0;
}


static int
mvcesa_authentication(struct mvcesa_softc *sc, struct mvcesa_session *ses,
                     uint32_t alg, uint32_t *iv, uint32_t *digest,
                     uint64_t bits, int skip, int len, char *buf,
                     struct mbuf *m, struct uio *uio)
{
       uint32_t cmd, bswp, data = 0;
       int dlen, off, i, s;

       /*
        * SHA/MD5 algorithms work in 512-bit chunks, equal to 16 words.
        */

       KASSERT(!(len & (512 - 1)) || bits != 0);
       KASSERT(buf != NULL || m != NULL || uio != NULL);

       cmd = bus_space_read_4(sc->sc_iot, sc->sc_ioh, MVCESA_SHA1MD5I_AC);
       if (!(cmd & MVCESA_SHA1MD5I_AC_TERMINATION))
               return ERESTART;

       bswp = 0;
       if (alg == MVCESA_SHA1MD5I_AC_ALGORITHM_SHA1) {
               dlen = 160;
               bits = htobe64(bits);
#if BYTE_ORDER == LITTLE_ENDIAN
               bswp = MVCESA_SHA1MD5I_AC_DATABYTESWAP |
                   MVCESA_SHA1MD5I_AC_IVBYTESWAP;
#endif
       } else {        /* MVCESA_SHA1MD5I_AC_ALGORITHM_MD5 */
               dlen = 128;
               bits = htole64(bits);
#if BYTE_ORDER == BIG_ENDIAN
               bswp = MVCESA_SHA1MD5I_AC_DATABYTESWAP |
                   MVCESA_SHA1MD5I_AC_IVBYTESWAP;
#endif
       }
       bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_SHA1MD5I_AC,
           alg | bswp | MVCESA_SHA1MD5I_AC_MODE_USEIV);

       if (iv != NULL)
               bus_space_write_region_4(sc->sc_iot, sc->sc_ioh,
                   MVCESA_SHA1MD5I_IVDA, iv, dlen / 4);

       off = i = 0;
       while (1 /* CONSTCOND */) {
               data = 0;
               if (buf != NULL)
                       for (i = 0; i < 512 / 8 && off + i < len; i += s) {
                               s = uimin(sizeof(data), len - off - i);
                               memcpy(&data, buf + skip + off + i, s);
                               if (s == sizeof(data))
                                       bus_space_write_4(sc->sc_iot,
                                           sc->sc_ioh, MVCESA_SHA1MD5I_DI,
                                           data);
                       }
               else if (m != NULL)
                       for (i = 0; i < 512 / 8 && off + i < len; i += s) {
                               s = uimin(sizeof(data), len - off - i);
                               m_copydata(m, skip + off + i, s, &data);
                               if (s == sizeof(data))
                                       bus_space_write_4(sc->sc_iot,
                                           sc->sc_ioh, MVCESA_SHA1MD5I_DI,
                                           data);
                       }
               else if (uio != NULL)
                       for (i = 0; i < 512 / 8 && off + i < len; i += s) {
                               s = uimin(sizeof(data), len - off - i);
                               cuio_copydata(uio, skip + off + i, s, &data);
                               if (s == sizeof(data))
                                       bus_space_write_4(sc->sc_iot,
                                           sc->sc_ioh, MVCESA_SHA1MD5I_DI,
                                           data);
                       }

               off += i;
               if (i < 512 / 8)
                       break;

               do {
                       cmd = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
                           MVCESA_SHA1MD5I_AC);
               } while (!(cmd & MVCESA_SHA1MD5I_AC_TERMINATION));

               bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_SHA1MD5I_AC,
                   alg | bswp | MVCESA_SHA1MD5I_AC_MODE_CONTINUE);
       }

       if (i < 512 / 8) {
               *((char *)&data + (i % 4)) = 0x80;
               bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_SHA1MD5I_DI,
                   data);
               i = (i & ~3) + 4;

               /* Do pad to 512 bits, if chunk size is more than 448 bits. */
               if (i > 448 / 8) {
                       for (; i < 512 / 8; i += 4)
                               bus_space_write_4(sc->sc_iot, sc->sc_ioh,
                                   MVCESA_SHA1MD5I_DI, 0);
                       do {
                               cmd = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
                                   MVCESA_SHA1MD5I_AC);
                       } while (!(cmd & MVCESA_SHA1MD5I_AC_TERMINATION));
                       i = 0;
               }
               for (; i < 448 / 8; i += 4)
                       bus_space_write_4(sc->sc_iot, sc->sc_ioh,
                           MVCESA_SHA1MD5I_DI, 0);

               /* Set total bits */
               bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_SHA1MD5I_BCL,
                   bits & 0xffffffff);
               bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_SHA1MD5I_BCH,
                   bits >> 32);
               do {
                       cmd = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
                           MVCESA_SHA1MD5I_AC);
               } while (!(cmd & MVCESA_SHA1MD5I_AC_TERMINATION));
       }

       if (digest != NULL) {
               /* Read digest */
               bus_space_read_region_4(sc->sc_iot, sc->sc_ioh,
                   MVCESA_SHA1MD5I_IVDA, digest, dlen / 8 / 4);
#if BYTE_ORDER == LITTLE_ENDIAN
               if (alg == MVCESA_SHA1MD5I_AC_ALGORITHM_SHA1)
                       for (i = 0; i < dlen / 8 / 4; i++)
                               digest[i] = be32toh(digest[i]);
#else
               if (alg == MVCESA_SHA1MD5I_AC_ALGORITHM_MD5)
                       for (i = 0; i < dlen / 8 / 4; i++)
                               digest[i] = le32toh(digest[i]);
#endif
       }
       return 0;
}

static int
mvcesa_des_encdec(struct mvcesa_softc *sc, struct mvcesa_session *ses,
                 uint32_t alg, uint32_t mode, uint32_t dir, uint32_t *iv,
                 int skip, int len, char *buf, struct mbuf *m, struct uio *uio)
{
       uint64_t iblk, oblk;
       uint32_t cmd, bswp = 0;
       int i, o, s;

       KASSERT(buf != NULL || m != NULL || uio != NULL);

       cmd = bus_space_read_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_C);
       if (!(cmd & MVCESA_DESE_C_TERMINATION))
               return ERESTART;

#if BYTE_ORDER == LITTLE_ENDIAN
       bswp = MVCESA_DESE_C_DATABYTESWAP | MVCESA_DESE_C_IVBYTESWAP   |
           MVCESA_DESE_C_OUTBYTESWAP;
#endif
       bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_C,
           dir | alg | mode | bswp | MVCESA_DESE_C_ALLTERMINATION);

       bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_K0L,
           ses->ses_key[1]);
       bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_K0H,
           ses->ses_key[0]);
       if (alg == MVCESA_DESE_C_ALGORITHM_3DES) {
               bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_K1L,
                   ses->ses_key[3]);
               bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_K1H,
                   ses->ses_key[2]);
               bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_K2L,
                   ses->ses_key[5]);
               bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_K2H,
                   ses->ses_key[4]);
       }

       bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_IVL, iv[1]);
       bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_IVH, iv[0]);

       i = o = 0;
       while (i < len) {
               s = uimin(sizeof(iblk), len - i);
               iblk = 0;

               if (buf != NULL)
                       memcpy(&iblk, buf + skip + i, s);
               else if (m != NULL)
                       m_copydata(m, skip + i, s, &iblk);
               else if (uio != NULL)
                       cuio_copydata(uio, skip + i, s, &iblk);

               /*
                * We have the pipeline that two data enters.
                */

               while (1 /* CONSTCOND */) {
                       cmd = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
                           MVCESA_DESE_C);
                       if (cmd & MVCESA_DESE_C_ALLTERMINATION)
                               /* Engine is ready.  Can write two data. */
                               break;
                       if (cmd & MVCESA_DESE_C_READALLOW) {
                               oblk = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
                                   MVCESA_DESE_DOH);
                               /* XXXX: needs barrier? */
                               oblk |= (uint64_t)bus_space_read_4(sc->sc_iot,
                                   sc->sc_ioh, MVCESA_DESE_DOL) << 32;

                               if (buf != NULL)
                                       memcpy(buf + skip + o, &oblk,
                                           sizeof(oblk));
                               else if (m != NULL)
                                       m_copydata(m, skip + o, sizeof(oblk),
                                           &oblk);
                               else if (uio != NULL)
                                       cuio_copyback(uio, skip + o,
                                           sizeof(oblk), &oblk);
                               o += sizeof(oblk);

                               /* Can write one data */
                               break;
                       }
               }

               /*
                * Encryption/Decryption calculation time is 9 cycles in DES
                * mode and 25 cycles in 3DES mode.
                */
               bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_DBL,
                   iblk >> 32);
               /* XXXX: needs barrier? */
               bus_space_write_4(sc->sc_iot, sc->sc_ioh, MVCESA_DESE_DBH,
                   iblk & 0xffffffff);
               i += s;
       }

       while (1 /* CONSTCOND */) {
               cmd = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
                   MVCESA_DESE_C);
               if (cmd & (MVCESA_DESE_C_READALLOW |
                                       MVCESA_DESE_C_ALLTERMINATION)) {
                       oblk = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
                           MVCESA_DESE_DOH);
                       /* XXXX: needs barrier? */
                       oblk |= (uint64_t)bus_space_read_4(sc->sc_iot,
                           sc->sc_ioh, MVCESA_DESE_DOL) << 32;

                       if (cmd & MVCESA_DESE_C_ALLTERMINATION) {
                               /* We can read IV from Data Out Registers. */
                               if (dir == MVCESA_DESE_C_DIRECTION_ENC)
                                       o -= sizeof(oblk);
                               else
                                       break;
                       }
                       if (buf != NULL)
                               memcpy(buf + skip + o, &oblk, sizeof(oblk));
                       else if (m != NULL)
                               m_copydata(m, skip + o, sizeof(oblk), &oblk);
                       else if (uio != NULL)
                               cuio_copyback(uio, skip + o, sizeof(oblk),
                                   &oblk);
                       o += sizeof(oblk);
                       if (cmd & MVCESA_DESE_C_ALLTERMINATION)
                               break;
               }
       }

       return 0;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.