// SPDX-License-Identifier: GPL-2.0 #include #include #include #include "nitrox_common.h" #include "nitrox_dev.h" #include "nitrox_req.h" #include "nitrox_csr.h" /* SLC_STORE_INFO */ #define MIN_UDD_LEN 16 /* PKT_IN_HDR + SLC_STORE_INFO */ #define FDATA_SIZE 32 /* Base destination port for the solicited requests */ #define SOLICIT_BASE_DPORT 256 #define REQ_NOT_POSTED 1 #define REQ_BACKLOG 2 #define REQ_POSTED 3 /* * Response codes from SE microcode * 0x00 - Success * Completion with no error * 0x43 - ERR_GC_DATA_LEN_INVALID * Invalid Data length if Encryption Data length is * less than 16 bytes for AES-XTS and AES-CTS. * 0x45 - ERR_GC_CTX_LEN_INVALID * Invalid context length: CTXL != 23 words. * 0x4F - ERR_GC_DOCSIS_CIPHER_INVALID * DOCSIS support is enabled with other than * AES/DES-CBC mode encryption. * 0x50 - ERR_GC_DOCSIS_OFFSET_INVALID * Authentication offset is other than 0 with * Encryption IV source = 0. * Authentication offset is other than 8 (DES)/16 (AES) * with Encryption IV source = 1 * 0x51 - ERR_GC_CRC32_INVALID_SELECTION * CRC32 is enabled for other than DOCSIS encryption. * 0x52 - ERR_GC_AES_CCM_FLAG_INVALID * Invalid flag options in AES-CCM IV. */ static inline int incr_index(int index, int count, int max) { if ((index + count) >= max) index = index + count - max; else index += count; return index; } static void softreq_unmap_sgbufs(struct nitrox_softreq *sr) { struct nitrox_device *ndev = sr->ndev; struct device *dev = DEV(ndev); dma_unmap_sg(dev, sr->in.sg, sg_nents(sr->in.sg), DMA_BIDIRECTIONAL); dma_unmap_single(dev, sr->in.sgcomp_dma, sr->in.sgcomp_len, DMA_TO_DEVICE); kfree(sr->in.sgcomp); sr->in.sg = NULL; sr->in.sgmap_cnt = 0; dma_unmap_sg(dev, sr->out.sg, sg_nents(sr->out.sg), DMA_BIDIRECTIONAL); dma_unmap_single(dev, sr->out.sgcomp_dma, sr->out.sgcomp_len, DMA_TO_DEVICE); kfree(sr->out.sgcomp); sr->out.sg = NULL; sr->out.sgmap_cnt = 0; } static void softreq_destroy(struct nitrox_softreq *sr) { softreq_unmap_sgbufs(sr); kfree(sr); } /** * create_sg_component - create SG componets for N5 device. * @sr: Request structure * @sgtbl: SG table * @map_nents: number of dma mapped entries * * Component structure * * 63 48 47 32 31 16 15 0 * -------------------------------------- * | LEN0 | LEN1 | LEN2 | LEN3 | * |------------------------------------- * | PTR0 | * -------------------------------------- * | PTR1 | * -------------------------------------- * | PTR2 | * -------------------------------------- * | PTR3 | * -------------------------------------- * * Returns 0 if success or a negative errno code on error. */ static int create_sg_component(struct nitrox_softreq *sr, struct nitrox_sgtable *sgtbl, int map_nents) { struct nitrox_device *ndev = sr->ndev; struct nitrox_sgcomp *sgcomp; struct scatterlist *sg; dma_addr_t dma; size_t sz_comp; int i, j, nr_sgcomp; nr_sgcomp = roundup(map_nents, 4) / 4; /* each component holds 4 dma pointers */ sz_comp = nr_sgcomp * sizeof(*sgcomp); sgcomp = kzalloc(sz_comp, sr->gfp); if (!sgcomp) return -ENOMEM; sgtbl->sgcomp = sgcomp; sg = sgtbl->sg; /* populate device sg component */ for (i = 0; i < nr_sgcomp; i++) { for (j = 0; j < 4 && sg; j++) { sgcomp[i].len[j] = cpu_to_be16(sg_dma_len(sg)); sgcomp[i].dma[j] = cpu_to_be64(sg_dma_address(sg)); sg = sg_next(sg); } } /* map the device sg component */ dma = dma_map_single(DEV(ndev), sgtbl->sgcomp, sz_comp, DMA_TO_DEVICE); if (dma_mapping_error(DEV(ndev), dma)) { kfree(sgtbl->sgcomp); sgtbl->sgcomp = NULL; return -ENOMEM; } sgtbl->sgcomp_dma = dma; sgtbl->sgcomp_len = sz_comp; return 0; } /** * dma_map_inbufs - DMA map input sglist and creates sglist component * for N5 device. * @sr: Request structure * @req: Crypto request structre * * Returns 0 if successful or a negative errno code on error. */ static int dma_map_inbufs(struct nitrox_softreq *sr, struct se_crypto_request *req) { struct device *dev = DEV(sr->ndev); struct scatterlist *sg; int i, nents, ret = 0; nents = dma_map_sg(dev, req->src, sg_nents(req->src), DMA_BIDIRECTIONAL); if (!nents) return -EINVAL; for_each_sg(req->src, sg, nents, i) sr->in.total_bytes += sg_dma_len(sg); sr->in.sg = req->src; sr->in.sgmap_cnt = nents; ret = create_sg_component(sr, &sr->in, sr->in.sgmap_cnt); if (ret) goto incomp_err; return 0; incomp_err: dma_unmap_sg(dev, req->src, sg_nents(req->src), DMA_BIDIRECTIONAL); sr->in.sgmap_cnt = 0; return ret; } static int dma_map_outbufs(struct nitrox_softreq *sr, struct se_crypto_request *req) { struct device *dev = DEV(sr->ndev); int nents, ret = 0; nents = dma_map_sg(dev, req->dst, sg_nents(req->dst), DMA_BIDIRECTIONAL); if (!nents) return -EINVAL; sr->out.sg = req->dst; sr->out.sgmap_cnt = nents; ret = create_sg_component(sr, &sr->out, sr->out.sgmap_cnt); if (ret) goto outcomp_map_err; return 0; outcomp_map_err: dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_BIDIRECTIONAL); sr->out.sgmap_cnt = 0; sr->out.sg = NULL; return ret; } static inline int softreq_map_iobuf(struct nitrox_softreq *sr, struct se_crypto_request *creq) { int ret; ret = dma_map_inbufs(sr, creq); if (ret) return ret; ret = dma_map_outbufs(sr, creq); if (ret) softreq_unmap_sgbufs(sr); return ret; } static inline void backlog_list_add(struct nitrox_softreq *sr, struct nitrox_cmdq *cmdq) { INIT_LIST_HEAD(&sr->backlog); spin_lock_bh(&cmdq->backlog_qlock); list_add_tail(&sr->backlog, &cmdq->backlog_head); atomic_inc(&cmdq->backlog_count); atomic_set(&sr->status, REQ_BACKLOG); spin_unlock_bh(&cmdq->backlog_qlock); } static inline void response_list_add(struct nitrox_softreq *sr, struct nitrox_cmdq *cmdq) { INIT_LIST_HEAD(&sr->response); spin_lock_bh(&cmdq->resp_qlock); list_add_tail(&sr->response, &cmdq->response_head); spin_unlock_bh(&cmdq->resp_qlock); } static inline void response_list_del(struct nitrox_softreq *sr, struct nitrox_cmdq *cmdq) { spin_lock_bh(&cmdq->resp_qlock); list_del(&sr->response); spin_unlock_bh(&cmdq->resp_qlock); } static struct nitrox_softreq * get_first_response_entry(struct nitrox_cmdq *cmdq) { return list_first_entry_or_null(&cmdq->response_head, struct nitrox_softreq, response); } static inline bool cmdq_full(struct nitrox_cmdq *cmdq, int qlen) { if (atomic_inc_return(&cmdq->pending_count) > qlen) { atomic_dec(&cmdq->pending_count); /* sync with other cpus */ smp_mb__after_atomic(); return true; } /* sync with other cpus */ smp_mb__after_atomic(); return false; } /** * post_se_instr - Post SE instruction to Packet Input ring * @sr: Request structure * @cmdq: Command queue structure * * Returns 0 if successful or a negative error code, * if no space in ring. */ static void post_se_instr(struct nitrox_softreq *sr, struct nitrox_cmdq *cmdq) { struct nitrox_device *ndev = sr->ndev; int idx; u8 *ent; spin_lock_bh(&cmdq->cmd_qlock); idx = cmdq->write_idx; /* copy the instruction */ ent = cmdq->base + (idx * cmdq->instr_size); memcpy(ent, &sr->instr, cmdq->instr_size); atomic_set(&sr->status, REQ_POSTED); response_list_add(sr, cmdq); sr->tstamp = jiffies; /* flush the command queue updates */ dma_wmb(); /* Ring doorbell with count 1 */ writeq(1, cmdq->dbell_csr_addr); cmdq->write_idx = incr_index(idx, 1, ndev->qlen); spin_unlock_bh(&cmdq->cmd_qlock); /* increment the posted command count */ atomic64_inc(&ndev->stats.posted); } static int post_backlog_cmds(struct nitrox_cmdq *cmdq) { struct nitrox_device *ndev = cmdq->ndev; struct nitrox_softreq *sr, *tmp; int ret = 0; if (!atomic_read(&cmdq->backlog_count)) return 0; spin_lock_bh(&cmdq->backlog_qlock); list_for_each_entry_safe(sr, tmp, &cmdq->backlog_head, backlog) { /* submit until space available */ if (unlikely(cmdq_full(cmdq, ndev->qlen))) { ret = -ENOSPC; break; } /* delete from backlog list */ list_del(&sr->backlog); atomic_dec(&cmdq->backlog_count); /* sync with other cpus */ smp_mb__after_atomic(); /* post the command */ post_se_instr(sr, cmdq); } spin_unlock_bh(&cmdq->backlog_qlock); return ret; } static int nitrox_enqueue_request(struct nitrox_softreq *sr) { struct nitrox_cmdq *cmdq = sr->cmdq; struct nitrox_device *ndev = sr->ndev; /* try to post backlog requests */ post_backlog_cmds(cmdq); if (unlikely(cmdq_full(cmdq, ndev->qlen))) { if (!(sr->flags & CRYPTO_TFM_REQ_MAY_BACKLOG)) { /* increment drop count */ atomic64_inc(&ndev->stats.dropped); return -ENOSPC; } /* add to backlog list */ backlog_list_add(sr, cmdq); return -EINPROGRESS; } post_se_instr(sr, cmdq); return -EINPROGRESS; } /** * nitrox_process_se_request - Send request to SE core * @ndev: NITROX device * @req: Crypto request * @callback: Completion callback * @cb_arg: Completion callback arguments * * Returns 0 on success, or a negative error code. */ int nitrox_process_se_request(struct nitrox_device *ndev, struct se_crypto_request *req, completion_t callback, void *cb_arg) { struct nitrox_softreq *sr; dma_addr_t ctx_handle = 0; int qno, ret = 0; if (!nitrox_ready(ndev)) return -ENODEV; sr = kzalloc(sizeof(*sr), req->gfp); if (!sr) return -ENOMEM; sr->ndev = ndev; sr->flags = req->flags; sr->gfp = req->gfp; sr->callback = callback; sr->cb_arg = cb_arg; atomic_set(&sr->status, REQ_NOT_POSTED); sr->resp.orh = req->orh; sr->resp.completion = req->comp; ret = softreq_map_iobuf(sr, req); if (ret) { kfree(sr); return ret; } /* get the context handle */ if (req->ctx_handle) { struct ctx_hdr *hdr; u8 *ctx_ptr; ctx_ptr = (u8 *)(uintptr_t)req->ctx_handle; hdr = (struct ctx_hdr *)(ctx_ptr - sizeof(struct ctx_hdr)); ctx_handle = hdr->ctx_dma; } /* select the queue */ qno = smp_processor_id() % ndev->nr_queues; sr->cmdq = &ndev->pkt_inq[qno]; /* * 64-Byte Instruction Format * * ---------------------- * | DPTR0 | 8 bytes * ---------------------- * | PKT_IN_INSTR_HDR | 8 bytes * ---------------------- * | PKT_IN_HDR | 16 bytes * ---------------------- * | SLC_INFO | 16 bytes * ---------------------- * | Front data | 16 bytes * ---------------------- */ /* fill the packet instruction */ /* word 0 */ sr->instr.dptr0 = cpu_to_be64(sr->in.sgcomp_dma); /* word 1 */ sr->instr.ih.value = 0; sr->instr.ih.s.g = 1; sr->instr.ih.s.gsz = sr->in.sgmap_cnt; sr->instr.ih.s.ssz = sr->out.sgmap_cnt; sr->instr.ih.s.fsz = FDATA_SIZE + sizeof(struct gphdr); sr->instr.ih.s.tlen = sr->instr.ih.s.fsz + sr->in.total_bytes; sr->instr.ih.bev = cpu_to_be64(sr->instr.ih.value); /* word 2 */ sr->instr.irh.value[0] = 0; sr->instr.irh.s.uddl = MIN_UDD_LEN; /* context length in 64-bit words */ sr->instr.irh.s.ctxl = (req->ctrl.s.ctxl / 8); /* offset from solicit base port 256 */ sr->instr.irh.s.destport = SOLICIT_BASE_DPORT + qno; sr->instr.irh.s.ctxc = req->ctrl.s.ctxc; sr->instr.irh.s.arg = req->ctrl.s.arg; sr->instr.irh.s.opcode = req->opcode; sr->instr.irh.bev[0] = cpu_to_be64(sr->instr.irh.value[0]); /* word 3 */ sr->instr.irh.s.ctxp = cpu_to_be64(ctx_handle); /* word 4 */ sr->instr.slc.value[0] = 0; sr->instr.slc.s.ssz = sr->out.sgmap_cnt; sr->instr.slc.bev[0] = cpu_to_be64(sr->instr.slc.value[0]); /* word 5 */ sr->instr.slc.s.rptr = cpu_to_be64(sr->out.sgcomp_dma); /* * No conversion for front data, * It goes into payload * put GP Header in front data */ sr->instr.fdata[0] = *((u64 *)&req->gph); sr->instr.fdata[1] = 0; ret = nitrox_enqueue_request(sr); if (ret == -ENOSPC) goto send_fail; return ret; send_fail: softreq_destroy(sr); return ret; } static inline int cmd_timeout(unsigned long tstamp, unsigned long timeout) { return time_after_eq(jiffies, (tstamp + timeout)); } void backlog_qflush_work(struct work_struct *work) { struct nitrox_cmdq *cmdq; cmdq = container_of(work, struct nitrox_cmdq, backlog_qflush); post_backlog_cmds(cmdq); } static bool sr_completed(struct nitrox_softreq *sr) { u64 orh = READ_ONCE(*sr->resp.orh); unsigned long timeout = jiffies + msecs_to_jiffies(1); if ((orh != PENDING_SIG) && (orh & 0xff)) return true; while (READ_ONCE(*sr->resp.completion) == PENDING_SIG) { if (time_after(jiffies, timeout)) { pr_err("comp not done\n"); return false; } } return true; } /** * process_response_list - process completed requests * @cmdq: Command queue structure * * Returns the number of responses processed. */ static void process_response_list(struct nitrox_cmdq *cmdq) { struct nitrox_device *ndev = cmdq->ndev; struct nitrox_softreq *sr; int req_completed = 0, err = 0, budget; completion_t callback; void *cb_arg; /* check all pending requests */ budget = atomic_read(&cmdq->pending_count); while (req_completed < budget) { sr = get_first_response_entry(cmdq); if (!sr) break; if (atomic_read(&sr->status) != REQ_POSTED) break; /* check orh and completion bytes updates */ if (!sr_completed(sr)) { /* request not completed, check for timeout */ if (!cmd_timeout(sr->tstamp, ndev->timeout)) break; dev_err_ratelimited(DEV(ndev), "Request timeout, orh 0x%016llx\n", READ_ONCE(*sr->resp.orh)); } atomic_dec(&cmdq->pending_count); atomic64_inc(&ndev->stats.completed); /* sync with other cpus */ smp_mb__after_atomic(); /* remove from response list */ response_list_del(sr, cmdq); /* ORH error code */ err = READ_ONCE(*sr->resp.orh) & 0xff; callback = sr->callback; cb_arg = sr->cb_arg; softreq_destroy(sr); if (callback) callback(cb_arg, err); req_completed++; } } /* * pkt_slc_resp_tasklet - post processing of SE responses */ void pkt_slc_resp_tasklet(unsigned long data) { struct nitrox_q_vector *qvec = (void *)(uintptr_t)(data); struct nitrox_cmdq *cmdq = qvec->cmdq; union nps_pkt_slc_cnts slc_cnts; /* read completion count */ slc_cnts.value = readq(cmdq->compl_cnt_csr_addr); /* resend the interrupt if more work to do */ slc_cnts.s.resend = 1; process_response_list(cmdq); /* * clear the interrupt with resend bit enabled, * MSI-X interrupt generates if Completion count > Threshold */ writeq(slc_cnts.value, cmdq->compl_cnt_csr_addr); if (atomic_read(&cmdq->backlog_count)) schedule_work(&cmdq->backlog_qflush); }