2 * Octeon Crypto for OCF
4 * Written by David McCullough <david_mccullough@securecomputing.com>
5 * Copyright (C) 2009 David McCullough
9 * The free distribution and use of this software in both source and binary
10 * form is allowed (with or without changes) provided that:
12 * 1. distributions of this source code include the above copyright
13 * notice, this list of conditions and the following disclaimer;
15 * 2. distributions in binary form include the above copyright
16 * notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other associated materials;
19 * 3. the copyright holder's name is not used to endorse products
20 * built using this software without specific written permission.
24 * This software is provided 'as is' with no explicit or implied warranties
25 * in respect of its properties, including, but not limited to, correctness
26 * and/or fitness for purpose.
27 * ---------------------------------------------------------------------------
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
33 #include <sys/param.h>
34 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/module.h>
38 #include <sys/malloc.h>
42 #include <opencrypto/cryptodev.h>
44 #include <contrib/octeon-sdk/cvmx.h>
46 #include <mips/cavium/cryptocteon/cryptocteonvar.h>
48 #include "cryptodev_if.h"
50 struct cryptocteon_softc {
51 int32_t sc_cid; /* opencrypto id */
52 struct octo_sess **sc_sessions;
56 int cryptocteon_debug = 0;
57 TUNABLE_INT("hw.cryptocteon.debug", &cryptocteon_debug);
59 static void cryptocteon_identify(driver_t *, device_t);
60 static int cryptocteon_probe(device_t);
61 static int cryptocteon_attach(device_t);
63 static int cryptocteon_process(device_t, struct cryptop *, int);
64 static int cryptocteon_newsession(device_t, u_int32_t *, struct cryptoini *);
65 static int cryptocteon_freesession(device_t, u_int64_t);
68 cryptocteon_identify(driver_t *drv, device_t parent)
70 if (octeon_has_feature(OCTEON_FEATURE_CRYPTO))
71 BUS_ADD_CHILD(parent, 0, "cryptocteon", 0);
75 cryptocteon_probe(device_t dev)
77 device_set_desc(dev, "Octeon Secure Coprocessor");
82 cryptocteon_attach(device_t dev)
84 struct cryptocteon_softc *sc;
86 sc = device_get_softc(dev);
88 sc->sc_cid = crypto_get_driverid(dev, CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SYNC);
90 device_printf(dev, "crypto_get_driverid ret %d\n", sc->sc_cid);
94 crypto_register(sc->sc_cid, CRYPTO_MD5_HMAC, 0, 0);
95 crypto_register(sc->sc_cid, CRYPTO_SHA1_HMAC, 0, 0);
96 crypto_register(sc->sc_cid, CRYPTO_DES_CBC, 0, 0);
97 crypto_register(sc->sc_cid, CRYPTO_3DES_CBC, 0, 0);
98 crypto_register(sc->sc_cid, CRYPTO_AES_CBC, 0, 0);
104 * Generate a new octo session. We artifically limit it to a single
105 * hash/cipher or hash-cipher combo just to make it easier, most callers
106 * do not expect more than this anyway.
109 cryptocteon_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri)
111 struct cryptoini *c, *encini = NULL, *macini = NULL;
112 struct cryptocteon_softc *sc;
113 struct octo_sess **ocd;
116 sc = device_get_softc(dev);
118 if (sid == NULL || cri == NULL || sc == NULL)
122 * To keep it simple, we only handle hash, cipher or hash/cipher in a
123 * session, you cannot currently do multiple ciphers/hashes in one
124 * session even though it would be possibel to code this driver to
127 for (i = 0, c = cri; c && i < 2; i++) {
128 if (c->cri_alg == CRYPTO_MD5_HMAC ||
129 c->cri_alg == CRYPTO_SHA1_HMAC ||
130 c->cri_alg == CRYPTO_NULL_HMAC) {
136 if (c->cri_alg == CRYPTO_DES_CBC ||
137 c->cri_alg == CRYPTO_3DES_CBC ||
138 c->cri_alg == CRYPTO_AES_CBC ||
139 c->cri_alg == CRYPTO_NULL_CBC) {
147 if (!macini && !encini) {
148 dprintf("%s,%d - EINVAL bad cipher/hash or combination\n",
153 dprintf("%s,%d - EINVAL cannot handle chained cipher/hash combos\n",
159 * So we have something we can do, lets setup the session
162 if (sc->sc_sessions) {
163 for (i = 1; i < sc->sc_sesnum; i++)
164 if (sc->sc_sessions[i] == NULL)
167 i = 1; /* NB: to silence compiler warning */
169 if (sc->sc_sessions == NULL || i == sc->sc_sesnum) {
170 if (sc->sc_sessions == NULL) {
171 i = 1; /* We leave sc->sc_sessions[0] empty */
172 sc->sc_sesnum = CRYPTO_SW_SESSIONS;
176 ocd = malloc(sc->sc_sesnum * sizeof(struct octo_sess *),
177 M_DEVBUF, M_NOWAIT | M_ZERO);
179 /* Reset session number */
180 if (sc->sc_sesnum == CRYPTO_SW_SESSIONS)
184 dprintf("%s,%d: ENOBUFS\n", __FILE__, __LINE__);
188 /* Copy existing sessions */
189 if (sc->sc_sessions) {
190 memcpy(ocd, sc->sc_sessions,
191 (sc->sc_sesnum / 2) * sizeof(struct octo_sess *));
192 free(sc->sc_sessions, M_DEVBUF);
195 sc->sc_sessions = ocd;
198 ocd = &sc->sc_sessions[i];
201 *ocd = malloc(sizeof(struct octo_sess), M_DEVBUF, M_NOWAIT | M_ZERO);
203 cryptocteon_freesession(NULL, i);
204 dprintf("%s,%d: ENOBUFS\n", __FILE__, __LINE__);
208 if (encini && encini->cri_key) {
209 (*ocd)->octo_encklen = (encini->cri_klen + 7) / 8;
210 memcpy((*ocd)->octo_enckey, encini->cri_key, (*ocd)->octo_encklen);
213 if (macini && macini->cri_key) {
214 (*ocd)->octo_macklen = (macini->cri_klen + 7) / 8;
215 memcpy((*ocd)->octo_mackey, macini->cri_key, (*ocd)->octo_macklen);
218 (*ocd)->octo_mlen = 0;
219 if (encini && encini->cri_mlen)
220 (*ocd)->octo_mlen = encini->cri_mlen;
221 else if (macini && macini->cri_mlen)
222 (*ocd)->octo_mlen = macini->cri_mlen;
224 (*ocd)->octo_mlen = 12;
227 * point c at the enc if it exists, otherwise the mac
229 c = encini ? encini : macini;
231 switch (c->cri_alg) {
233 case CRYPTO_3DES_CBC:
234 (*ocd)->octo_ivsize = 8;
235 switch (macini ? macini->cri_alg : -1) {
236 case CRYPTO_MD5_HMAC:
237 (*ocd)->octo_encrypt = octo_des_cbc_md5_encrypt;
238 (*ocd)->octo_decrypt = octo_des_cbc_md5_decrypt;
239 octo_calc_hash(0, macini->cri_key, (*ocd)->octo_hminner,
240 (*ocd)->octo_hmouter);
242 case CRYPTO_SHA1_HMAC:
243 (*ocd)->octo_encrypt = octo_des_cbc_sha1_encrypt;
244 (*ocd)->octo_decrypt = octo_des_cbc_sha1_encrypt;
245 octo_calc_hash(1, macini->cri_key, (*ocd)->octo_hminner,
246 (*ocd)->octo_hmouter);
249 (*ocd)->octo_encrypt = octo_des_cbc_encrypt;
250 (*ocd)->octo_decrypt = octo_des_cbc_decrypt;
253 cryptocteon_freesession(NULL, i);
254 dprintf("%s,%d: EINVALn", __FILE__, __LINE__);
259 (*ocd)->octo_ivsize = 16;
260 switch (macini ? macini->cri_alg : -1) {
261 case CRYPTO_MD5_HMAC:
262 (*ocd)->octo_encrypt = octo_aes_cbc_md5_encrypt;
263 (*ocd)->octo_decrypt = octo_aes_cbc_md5_decrypt;
264 octo_calc_hash(0, macini->cri_key, (*ocd)->octo_hminner,
265 (*ocd)->octo_hmouter);
267 case CRYPTO_SHA1_HMAC:
268 (*ocd)->octo_encrypt = octo_aes_cbc_sha1_encrypt;
269 (*ocd)->octo_decrypt = octo_aes_cbc_sha1_decrypt;
270 octo_calc_hash(1, macini->cri_key, (*ocd)->octo_hminner,
271 (*ocd)->octo_hmouter);
274 (*ocd)->octo_encrypt = octo_aes_cbc_encrypt;
275 (*ocd)->octo_decrypt = octo_aes_cbc_decrypt;
278 cryptocteon_freesession(NULL, i);
279 dprintf("%s,%d: EINVALn", __FILE__, __LINE__);
283 case CRYPTO_MD5_HMAC:
284 (*ocd)->octo_encrypt = octo_null_md5_encrypt;
285 (*ocd)->octo_decrypt = octo_null_md5_encrypt;
286 octo_calc_hash(0, macini->cri_key, (*ocd)->octo_hminner,
287 (*ocd)->octo_hmouter);
289 case CRYPTO_SHA1_HMAC:
290 (*ocd)->octo_encrypt = octo_null_sha1_encrypt;
291 (*ocd)->octo_decrypt = octo_null_sha1_encrypt;
292 octo_calc_hash(1, macini->cri_key, (*ocd)->octo_hminner,
293 (*ocd)->octo_hmouter);
296 cryptocteon_freesession(NULL, i);
297 dprintf("%s,%d: EINVALn", __FILE__, __LINE__);
301 (*ocd)->octo_encalg = encini ? encini->cri_alg : -1;
302 (*ocd)->octo_macalg = macini ? macini->cri_alg : -1;
311 cryptocteon_freesession(device_t dev, u_int64_t tid)
313 struct cryptocteon_softc *sc;
314 u_int32_t sid = CRYPTO_SESID2LID(tid);
316 sc = device_get_softc(dev);
321 if (sid > sc->sc_sesnum || sc->sc_sessions == NULL ||
322 sc->sc_sessions[sid] == NULL)
325 /* Silently accept and return */
329 if (sc->sc_sessions[sid])
330 free(sc->sc_sessions[sid], M_DEVBUF);
331 sc->sc_sessions[sid] = NULL;
339 cryptocteon_process(device_t dev, struct cryptop *crp, int hint)
341 struct cryptodesc *crd;
342 struct octo_sess *od;
344 size_t iovcnt, iovlen;
345 struct mbuf *m = NULL;
346 struct uio *uiop = NULL;
347 struct cryptodesc *enccrd = NULL, *maccrd = NULL;
348 unsigned char *ivp = NULL;
349 unsigned char iv_data[HASH_MAX_LEN];
350 int auth_off = 0, auth_len = 0, crypt_off = 0, crypt_len = 0, icv_off = 0;
351 struct cryptocteon_softc *sc;
353 sc = device_get_softc(dev);
355 if (sc == NULL || crp == NULL)
360 if (crp->crp_desc == NULL || crp->crp_buf == NULL) {
361 dprintf("%s,%d: EINVAL\n", __FILE__, __LINE__);
362 crp->crp_etype = EINVAL;
366 lid = crp->crp_sid & 0xffffffff;
367 if (lid >= sc->sc_sesnum || lid == 0 || sc->sc_sessions == NULL ||
368 sc->sc_sessions[lid] == NULL) {
369 crp->crp_etype = ENOENT;
370 dprintf("%s,%d: ENOENT\n", __FILE__, __LINE__);
373 od = sc->sc_sessions[lid];
376 * do some error checking outside of the loop for m and IOV processing
377 * this leaves us with valid m or uiop pointers for later
379 if (crp->crp_flags & CRYPTO_F_IMBUF) {
382 m = (struct mbuf *) crp->crp_buf;
383 for (frags = 0; m != NULL; frags++)
386 if (frags >= UIO_MAXIOV) {
387 printf("%s,%d: %d frags > UIO_MAXIOV", __FILE__, __LINE__, frags);
391 m = (struct mbuf *) crp->crp_buf;
392 } else if (crp->crp_flags & CRYPTO_F_IOV) {
393 uiop = (struct uio *) crp->crp_buf;
394 if (uiop->uio_iovcnt > UIO_MAXIOV) {
395 printf("%s,%d: %d uio_iovcnt > UIO_MAXIOV", __FILE__, __LINE__,
401 /* point our enccrd and maccrd appropriately */
403 if (crd->crd_alg == od->octo_encalg) enccrd = crd;
404 if (crd->crd_alg == od->octo_macalg) maccrd = crd;
407 if (crd->crd_alg == od->octo_encalg) enccrd = crd;
408 if (crd->crd_alg == od->octo_macalg) maccrd = crd;
412 crp->crp_etype = EINVAL;
413 dprintf("%s,%d: ENOENT - descriptors do not match session\n",
419 if (enccrd->crd_flags & CRD_F_IV_EXPLICIT) {
420 ivp = enccrd->crd_iv;
423 crypto_copydata(crp->crp_flags, crp->crp_buf,
424 enccrd->crd_inject, od->octo_ivsize, (caddr_t) ivp);
428 auth_off = maccrd->crd_skip;
429 auth_len = maccrd->crd_len;
430 icv_off = maccrd->crd_inject;
433 crypt_off = enccrd->crd_skip;
434 crypt_len = enccrd->crd_len;
435 } else { /* if (maccrd) */
436 auth_off = maccrd->crd_skip;
437 auth_len = maccrd->crd_len;
438 icv_off = maccrd->crd_inject;
442 * setup the I/O vector to cover the buffer
444 if (crp->crp_flags & CRYPTO_F_IMBUF) {
449 od->octo_iov[iovcnt].iov_base = mtod(m, void *);
450 od->octo_iov[iovcnt].iov_len = m->m_len;
453 iovlen += od->octo_iov[iovcnt++].iov_len;
455 } else if (crp->crp_flags & CRYPTO_F_IOV) {
457 for (iovcnt = 0; iovcnt < uiop->uio_iovcnt; iovcnt++) {
458 od->octo_iov[iovcnt].iov_base = uiop->uio_iov[iovcnt].iov_base;
459 od->octo_iov[iovcnt].iov_len = uiop->uio_iov[iovcnt].iov_len;
461 iovlen += od->octo_iov[iovcnt].iov_len;
464 iovlen = crp->crp_ilen;
465 od->octo_iov[0].iov_base = crp->crp_buf;
466 od->octo_iov[0].iov_len = crp->crp_ilen;
472 * setup a new explicit key
475 if (enccrd->crd_flags & CRD_F_KEY_EXPLICIT) {
476 od->octo_encklen = (enccrd->crd_klen + 7) / 8;
477 memcpy(od->octo_enckey, enccrd->crd_key, od->octo_encklen);
481 if (maccrd->crd_flags & CRD_F_KEY_EXPLICIT) {
482 od->octo_macklen = (maccrd->crd_klen + 7) / 8;
483 memcpy(od->octo_mackey, maccrd->crd_key, od->octo_macklen);
484 od->octo_mackey_set = 0;
486 if (!od->octo_mackey_set) {
487 octo_calc_hash(maccrd->crd_alg == CRYPTO_MD5_HMAC ? 0 : 1,
488 maccrd->crd_key, od->octo_hminner, od->octo_hmouter);
489 od->octo_mackey_set = 1;
494 if (!enccrd || (enccrd->crd_flags & CRD_F_ENCRYPT))
495 (*od->octo_encrypt)(od, od->octo_iov, iovcnt, iovlen,
496 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
498 (*od->octo_decrypt)(od, od->octo_iov, iovcnt, iovlen,
499 auth_off, auth_len, crypt_off, crypt_len, icv_off, ivp);
506 static device_method_t cryptocteon_methods[] = {
508 DEVMETHOD(device_identify, cryptocteon_identify),
509 DEVMETHOD(device_probe, cryptocteon_probe),
510 DEVMETHOD(device_attach, cryptocteon_attach),
512 /* crypto device methods */
513 DEVMETHOD(cryptodev_newsession, cryptocteon_newsession),
514 DEVMETHOD(cryptodev_freesession,cryptocteon_freesession),
515 DEVMETHOD(cryptodev_process, cryptocteon_process),
520 static driver_t cryptocteon_driver = {
523 sizeof (struct cryptocteon_softc),
525 static devclass_t cryptocteon_devclass;
526 DRIVER_MODULE(cryptocteon, nexus, cryptocteon_driver, cryptocteon_devclass, 0, 0);