Lines Matching refs:task
269 SDT_PROBE_DEFINE1(sdt, sun8i_crypto, task, ctor__success,
270 "struct sun8i_crypto_task *"/*task*/);
271 SDT_PROBE_DEFINE1(sdt, sun8i_crypto, task, ctor__failure,
273 SDT_PROBE_DEFINE1(sdt, sun8i_crypto, task, dtor,
274 "struct sun8i_crypto_task *"/*task*/);
275 SDT_PROBE_DEFINE1(sdt, sun8i_crypto, task, get,
276 "struct sun8i_crypto_task *"/*task*/);
277 SDT_PROBE_DEFINE1(sdt, sun8i_crypto, task, put,
278 "struct sun8i_crypto_task *"/*task*/);
280 SDT_PROBE_DEFINE6(sdt, sun8i_crypto, task, load,
281 "struct sun8i_crypto_task *"/*task*/,
287 SDT_PROBE_DEFINE3(sdt, sun8i_crypto, task, misaligned,
288 "struct sun8i_crypto_task *"/*task*/,
291 SDT_PROBE_DEFINE2(sdt, sun8i_crypto, task, done,
292 "struct sun8i_crypto_task *"/*task*/,
297 "struct sun8i_crypto_task *"/*task*/,
301 "struct sun8i_crypto_task *"/*task*/,
324 "struct sun8i_crypto_task *"/*task*/);
408 * busy with a task as we prepare another task for when it's
510 struct sun8i_crypto_task *task = vtask;
514 /* Create a DMA buffer for the task descriptor. */
515 error = sun8i_crypto_allocbuf(sc, sizeof(*task->ct_desc),
516 &task->ct_descbuf, dmaflags);
519 task->ct_desc = task->ct_descbuf.cb_kva;
523 &task->ct_ivbuf, dmaflags);
526 task->ct_iv = task->ct_ivbuf.cb_kva;
528 &task->ct_ctrbuf, dmaflags);
531 task->ct_ctr = task->ct_ctrbuf.cb_kva;
533 /* Create a DMA map for the task descriptor and preload it. */
534 error = bus_dmamap_create(sc->sc_dmat, sizeof(*task->ct_desc), 1,
535 sizeof(*task->ct_desc), 0, dmaflags, &task->ct_descmap);
538 error = bus_dmamap_load(sc->sc_dmat, task->ct_descmap, task->ct_desc,
539 sizeof(*task->ct_desc), NULL, BUS_DMA_WAITOK);
545 SUN8I_CRYPTO_MAXKEYBYTES, 0, dmaflags, &task->ct_keymap);
549 SUN8I_CRYPTO_MAXIVBYTES, 0, dmaflags, &task->ct_ivmap);
553 SUN8I_CRYPTO_MAXCTRBYTES, 0, dmaflags, &task->ct_ctrmap);
560 &task->ct_srcmap);
565 &task->ct_dstmap);
570 SDT_PROBE1(sdt, sun8i_crypto, task, ctor__success, task);
574 bus_dmamap_destroy(sc->sc_dmat, task->ct_dstmap);
575 fail9: bus_dmamap_destroy(sc->sc_dmat, task->ct_srcmap);
576 fail8: bus_dmamap_destroy(sc->sc_dmat, task->ct_ctrmap);
577 fail7: bus_dmamap_destroy(sc->sc_dmat, task->ct_ivmap);
578 fail6: bus_dmamap_destroy(sc->sc_dmat, task->ct_keymap);
579 fail5: bus_dmamap_unload(sc->sc_dmat, task->ct_descmap);
580 fail4: bus_dmamap_destroy(sc->sc_dmat, task->ct_descmap);
581 fail3: sun8i_crypto_freebuf(sc, SUN8I_CRYPTO_MAXIVBYTES, &task->ct_ivbuf);
582 fail2: sun8i_crypto_freebuf(sc, SUN8I_CRYPTO_MAXCTRBYTES, &task->ct_ctrbuf);
583 fail1: sun8i_crypto_freebuf(sc, sizeof(*task->ct_desc), &task->ct_descbuf);
584 fail0: SDT_PROBE1(sdt, sun8i_crypto, task, ctor__failure, error);
592 struct sun8i_crypto_task *task = vtask;
594 SDT_PROBE1(sdt, sun8i_crypto, task, dtor, task);
598 bus_dmamap_destroy(sc->sc_dmat, task->ct_dstmap);
599 bus_dmamap_destroy(sc->sc_dmat, task->ct_srcmap);
600 bus_dmamap_destroy(sc->sc_dmat, task->ct_ctrmap);
601 bus_dmamap_destroy(sc->sc_dmat, task->ct_ivmap);
602 bus_dmamap_destroy(sc->sc_dmat, task->ct_keymap);
603 bus_dmamap_unload(sc->sc_dmat, task->ct_descmap);
604 bus_dmamap_destroy(sc->sc_dmat, task->ct_descmap);
605 sun8i_crypto_freebuf(sc, SUN8I_CRYPTO_MAXIVBYTES, &task->ct_ivbuf);
606 sun8i_crypto_freebuf(sc, SUN8I_CRYPTO_MAXCTRBYTES, &task->ct_ctrbuf);
607 sun8i_crypto_freebuf(sc, sizeof(*task->ct_desc), &task->ct_descbuf);
613 * Allocate a task that will call callback(sc, task, cookie,
616 * needed to submit the task if this succeeds (although task
625 struct sun8i_crypto_task *task;
627 /* Allocate a task, or fail if we can't. */
628 task = pool_cache_get(sc->sc_taskpool, pflags);
629 if (task == NULL)
633 task->ct_flags = 0;
634 task->ct_callback = callback;
635 task->ct_cookie = cookie;
637 out: SDT_PROBE1(sdt, sun8i_crypto, task, get, task);
638 return task;
642 * sun8i_crypto_task_invalid(sc, task, cookie, error)
644 * Callback for a task not currently in use, to detect errors.
648 struct sun8i_crypto_task *task, void *cookie, int error)
653 panic("task for callback %p used after free", callback);
657 * sun8i_crypto_task_put(sc, task)
659 * Free a task obtained with sun8i_crypto_task_get.
663 struct sun8i_crypto_task *task)
666 SDT_PROBE1(sdt, sun8i_crypto, task, put, task);
668 task->ct_cookie = task->ct_callback;
669 task->ct_callback = &sun8i_crypto_task_invalid;
670 pool_cache_put(sc->sc_taskpool, task);
674 * sun8i_crypto_task_load(sc, task, nbytes, tdqc, tdqs, tdqa)
676 * Set up the task descriptor after the relevant DMA maps have
681 * XXX Teach this to support task chains.
685 struct sun8i_crypto_task *task, uint32_t nbytes,
688 struct sun8i_crypto_taskdesc *desc = task->ct_desc;
696 /* Always enable interrupt for the task. */
703 if (task->ct_flags & TASK_KEY) {
704 bus_dmamap_t keymap = task->ct_keymap;
710 if (task->ct_flags & TASK_IV) {
711 bus_dmamap_t ivmap = task->ct_ivmap;
717 if (task->ct_flags & TASK_CTR) {
718 bus_dmamap_t ctrmap = task->ct_ctrmap;
725 if (task->ct_flags & TASK_BYTES)
730 if (task->ct_flags & TASK_SRC) {
731 bus_dmamap_t srcmap = task->ct_srcmap;
732 KASSERT(srcmap->dm_mapsize == task->ct_dstmap->dm_mapsize);
733 error = sun8i_crypto_task_scatter(task, desc->td_src, srcmap,
741 error = sun8i_crypto_task_scatter(task, desc->td_dst, task->ct_dstmap,
745 bus_dmamap_sync(sc->sc_dmat, task->ct_dstmap, 0, nbytes,
748 task->ct_nbytes = nbytes;
753 out: SDT_PROBE6(sdt, sun8i_crypto, task, load,
754 task, tdqc, tdqs, tdqa, desc, error);
759 * sun8i_crypto_task_scatter(task, adrlen, map, nbytes)
761 * Set up a task's scatter/gather vector -- src or dst -- with the
766 sun8i_crypto_task_scatter(struct sun8i_crypto_task *task,
781 SDT_PROBE3(sdt, sun8i_crypto, task, misaligned,
782 task,
808 * sun8i_crypto_task_load_trng(task, nbytes)
810 * Set up the task descriptor for a transfer of nbytes from the
815 struct sun8i_crypto_task *task, uint32_t nbytes)
820 KASSERT((task->ct_flags & TASK_KEY) == 0);
821 KASSERT((task->ct_flags & TASK_IV) == 0);
822 KASSERT((task->ct_flags & TASK_CTR) == 0);
823 KASSERT((task->ct_flags & TASK_SRC) == 0);
825 /* Set up the task descriptor queue control words. */
830 return sun8i_crypto_task_load(sc, task, nbytes, tdqc, 0, 0);
835 struct sun8i_crypto_task *task,
841 KASSERT(task->ct_flags & TASK_KEY);
842 KASSERT((task->ct_flags & TASK_IV) == 0);
843 KASSERT((task->ct_flags & TASK_CTR) == 0);
844 KASSERT(task->ct_flags & TASK_SRC);
846 /* Set up the task descriptor queue control word. */
854 KASSERT(task->ct_keymap->dm_segs[0].ds_len == 16);
857 KASSERT(task->ct_keymap->dm_segs[0].ds_len == 24);
860 KASSERT(task->ct_keymap->dm_segs[0].ds_len == 32);
873 return sun8i_crypto_task_load(sc, task, nbytes, tdqc, tdqs, 0);
877 * sun8i_crypto_submit(sc, task)
879 * Submit a task to the crypto engine after it has been loaded
881 * eventually call the task's callback.
885 struct sun8i_crypto_task *task)
909 task->ct_desc->td_cid = htole32(i);
915 bus_dmamap_sync(sc->sc_dmat, task->ct_descmap, 0,
916 sizeof(*task->ct_desc), BUS_DMASYNC_PREWRITE);
936 /* Set the task descriptor queue address. */
938 task->ct_descmap->dm_segs[0].ds_addr);
964 sc->sc_chan[i].cc_task = task;
972 sc, task, error);
975 sc, task, i);
1026 * Ensure that crypto engine thread context work to invoke task
1045 * Thread-context worker: Invoke all task callbacks for which the
1072 * operations (which we do) use the same task channels, so we
1117 * Invoke all task callbacks for the channels in done or esr, or
1136 /* Nope. Do we have a task to time out? */
1170 * Notify the task of completion. May release the lock
1192 * Notify the callback for the task on channel i, if there is one,
1198 struct sun8i_crypto_task *task;
1206 /* Claim the task if there is one; bail if not. */
1207 if ((task = sc->sc_chan[i].cc_task) == NULL) {
1208 device_printf(sc->sc_dev, "channel %u: no task but error=%d\n",
1225 bus_dmamap_sync(sc->sc_dmat, task->ct_descmap, 0,
1226 sizeof(*task->ct_desc), BUS_DMASYNC_POSTWRITE);
1232 nbytes = task->ct_nbytes;
1233 bus_dmamap_sync(sc->sc_dmat, task->ct_dstmap, 0, nbytes,
1235 if (task->ct_flags & TASK_SRC)
1236 bus_dmamap_sync(sc->sc_dmat, task->ct_srcmap, 0, nbytes,
1238 if (task->ct_flags & TASK_CTR)
1239 bus_dmamap_sync(sc->sc_dmat, task->ct_ctrmap, 0,
1240 task->ct_ctrmap->dm_segs[0].ds_len, BUS_DMASYNC_POSTREAD);
1241 if (task->ct_flags & TASK_IV)
1242 bus_dmamap_sync(sc->sc_dmat, task->ct_ivmap, 0,
1243 task->ct_ivmap->dm_segs[0].ds_len, BUS_DMASYNC_POSTWRITE);
1244 if (task->ct_flags & TASK_KEY)
1246 bus_dmamap_sync(sc->sc_dmat, task->ct_keymap, 0,
1247 task->ct_keymap->dm_segs[0].ds_len, BUS_DMASYNC_POSTWRITE);
1251 SDT_PROBE2(sdt, sun8i_crypto, task, done, task, error);
1252 (*task->ct_callback)(sc, task, task->ct_cookie, error);
1316 struct sun8i_crypto_task *task;
1330 /* Create a task to reuse. */
1331 task = rng->cr_task = sun8i_crypto_task_get(sc, sun8i_crypto_rng_done,
1334 aprint_error_dev(self, "failed to allocate RNG task\n");
1340 error = bus_dmamap_load(sc->sc_dmat, task->ct_dstmap,
1374 bus_dmamap_unload(sc->sc_dmat, task->ct_dstmap);
1375 fail2: sun8i_crypto_task_put(sc, task);
1391 struct sun8i_crypto_task *task = rng->cr_task;
1406 /* Load the task descriptor. */
1407 error = sun8i_crypto_task_load_trng(sc, task, SUN8I_CRYPTO_RNGBYTES);
1412 error = sun8i_crypto_submit(sc, task);
1426 struct sun8i_crypto_task *task, void *cookie, int error)
1484 struct sun8i_crypto_task *task;
1511 /* Allocate a task descriptor. */
1512 task = selftest->cs_task = sun8i_crypto_task_get(sc,
1524 error = bus_dmamap_load(sc->sc_dmat, task->ct_keymap,
1528 task->ct_flags |= TASK_KEY;
1530 error = bus_dmamap_load(sc->sc_dmat, task->ct_srcmap,
1534 task->ct_flags |= TASK_SRC;
1536 error = bus_dmamap_load(sc->sc_dmat, task->ct_dstmap,
1541 /* Set up the task descriptor. */
1542 error = sun8i_crypto_task_load_aesecb(sc, task, nbytes,
1548 error = sun8i_crypto_submit(sc, task);
1569 fail7: bus_dmamap_unload(sc->sc_dmat, task->ct_dstmap);
1570 fail6: bus_dmamap_unload(sc->sc_dmat, task->ct_srcmap);
1571 fail5: bus_dmamap_unload(sc->sc_dmat, task->ct_keymap);
1572 fail4: sun8i_crypto_task_put(sc, task);
1607 struct sun8i_crypto_task *task, void *cookie, int error)
1637 out: bus_dmamap_unload(sc->sc_dmat, task->ct_dstmap);
1638 bus_dmamap_unload(sc->sc_dmat, task->ct_srcmap);
1639 bus_dmamap_unload(sc->sc_dmat, task->ct_keymap);
1640 sun8i_crypto_task_put(sc, task);
1700 struct sun8i_crypto_task *task;
1733 /* Allocate a task. */
1734 task = req->cu_task = sun8i_crypto_task_get(sc,
1736 if (task == NULL) {
1741 /* Set the task up for TRNG to our buffer. */
1742 error = bus_dmamap_load(sc->sc_dmat, task->ct_dstmap,
1746 error = sun8i_crypto_task_load_trng(sc, task, SUN8I_CRYPTO_RNGBYTES);
1751 error = sun8i_crypto_submit(sc, task);
1800 out3: bus_dmamap_unload(sc->sc_dmat, task->ct_dstmap);
1801 out2: sun8i_crypto_task_put(sc, task);
1811 struct sun8i_crypto_task *task, void *cookie, int error)
1835 bus_dmamap_unload(sc->sc_dmat, task->ct_dstmap);
1836 sun8i_crypto_task_put(sc, task);
2113 struct sun8i_crypto_task *task;
2185 /* Get a task, or fail with ERESTART if we can't. */
2186 task = sun8i_crypto_task_get(sc, &sun8i_crypto_callback, crp,
2188 if (task == NULL) {
2204 error = bus_dmamap_load(sc->sc_dmat, task->ct_keymap,
2208 task->ct_flags |= TASK_KEY;
2223 cprng_fast(task->ct_iv, ivlen);
2224 iv = task->ct_iv;
2266 memcpy(task->ct_iv, block, 16);
2267 iv = task->ct_iv;
2272 error = bus_dmamap_load(sc->sc_dmat, task->ct_ivmap, iv, ivlen,
2276 task->ct_flags |= TASK_IV;
2285 error = bus_dmamap_load_mbuf(sc->sc_dmat, task->ct_srcmap, m,
2289 task->ct_flags |= TASK_SRC;
2293 error = bus_dmamap_load_mbuf(sc->sc_dmat, task->ct_dstmap, m,
2302 error = bus_dmamap_load_uio(sc->sc_dmat, task->ct_srcmap, uio,
2306 task->ct_flags |= TASK_SRC;
2310 error = bus_dmamap_load_uio(sc->sc_dmat, task->ct_dstmap, uio,
2485 /* Set up the task descriptor. */
2486 error = sun8i_crypto_task_load(sc, task, crd->crd_len,
2492 error = sun8i_crypto_submit(sc, task);
2497 SDT_PROBE4(sdt, sun8i_crypto, process, queued, sc, crp, hint, task);
2500 fail2: bus_dmamap_unload(sc->sc_dmat, task->ct_dstmap);
2501 fail1: if (task->ct_flags & TASK_SRC)
2502 bus_dmamap_unload(sc->sc_dmat, task->ct_srcmap);
2503 if (task->ct_flags & TASK_CTR)
2504 bus_dmamap_unload(sc->sc_dmat, task->ct_ctrmap);
2505 if (task->ct_flags & TASK_IV)
2506 bus_dmamap_unload(sc->sc_dmat, task->ct_ivmap);
2507 if (task->ct_flags & TASK_KEY)
2508 bus_dmamap_unload(sc->sc_dmat, task->ct_keymap);
2509 sun8i_crypto_task_put(sc, task);
2519 * sun8i_crypto_callback(sc, task, cookie, error)
2521 * Completion callback for a task submitted via opencrypto.
2522 * Release the task and pass the error on to opencrypto with
2527 struct sun8i_crypto_task *task, void *cookie, int error)
2539 bus_dmamap_unload(sc->sc_dmat, task->ct_dstmap);
2540 bus_dmamap_unload(sc->sc_dmat, task->ct_srcmap);
2541 if (task->ct_flags & TASK_CTR)
2542 bus_dmamap_unload(sc->sc_dmat, task->ct_ctrmap);
2543 if (task->ct_flags & TASK_IV)
2544 bus_dmamap_unload(sc->sc_dmat, task->ct_ivmap);
2545 if (task->ct_flags & TASK_KEY)
2546 bus_dmamap_unload(sc->sc_dmat, task->ct_keymap);
2547 sun8i_crypto_task_put(sc, task);
Indexes created Mon Sep 29 21:09:56 GMT 2025