![Kim Phillips](/assets/img/avatar_default.png)
commit "crypto: caam - use non-irq versions of spinlocks for job rings" made two bad assumptions: (a) The caam_jr_enqueue lock isn't used in softirq context. Not true: jr_enqueue can be interrupted by an incoming net interrupt and the received packet may be sent for encryption, via caam_jr_enqueue in softirq context, thereby inducing a deadlock. This is evidenced when running netperf over an IPSec tunnel between two P4080's, with spinlock debugging turned on: [ 892.092569] BUG: spinlock lockup on CPU#7, netperf/10634, e8bf5f70 [ 892.098747] Call Trace: [ 892.101197] [eff9fc10] [c00084c0] show_stack+0x48/0x15c (unreliable) [ 892.107563] [eff9fc50] [c0239c2c] do_raw_spin_lock+0x16c/0x174 [ 892.113399] [eff9fc80] [c0596494] _raw_spin_lock+0x3c/0x50 [ 892.118889] [eff9fc90] [c0445e74] caam_jr_enqueue+0xf8/0x250 [ 892.124550] [eff9fcd0] [c044a644] aead_decrypt+0x6c/0xc8 [ 892.129625] BUG: spinlock lockup on CPU#5, swapper/5/0, e8bf5f70 [ 892.129629] Call Trace: [ 892.129637] [effa7c10] [c00084c0] show_stack+0x48/0x15c (unreliable) [ 892.129645] [effa7c50] [c0239c2c] do_raw_spin_lock+0x16c/0x174 [ 892.129652] [effa7c80] [c0596494] _raw_spin_lock+0x3c/0x50 [ 892.129660] [effa7c90] [c0445e74] caam_jr_enqueue+0xf8/0x250 [ 892.129666] [effa7cd0] [c044a644] aead_decrypt+0x6c/0xc8 [ 892.129674] [effa7d00] [c0509724] esp_input+0x178/0x334 [ 892.129681] [effa7d50] [c0519778] xfrm_input+0x77c/0x818 [ 892.129688] [effa7da0] [c050e344] xfrm4_rcv_encap+0x20/0x30 [ 892.129697] [effa7db0] [c04b90c8] ip_local_deliver+0x190/0x408 [ 892.129703] [effa7de0] [c04b966c] ip_rcv+0x32c/0x898 [ 892.129709] [effa7e10] [c048b998] __netif_receive_skb+0x27c/0x4e8 [ 892.129715] [effa7e80] [c048d744] netif_receive_skb+0x4c/0x13c [ 892.129726] [effa7eb0] [c03c28ac] _dpa_rx+0x1a8/0x354 [ 892.129732] [effa7ef0] [c03c2ac4] ingress_rx_default_dqrr+0x6c/0x108 [ 892.129742] [effa7f10] [c0467ae0] qman_poll_dqrr+0x170/0x1d4 [ 892.129748] [effa7f40] [c03c153c] dpaa_eth_poll+0x20/0x94 [ 892.129754] [effa7f60] [c048dbd0] net_rx_action+0x13c/0x1f4 [ 892.129763] [effa7fa0] [c003d1b8] __do_softirq+0x108/0x1b0 [ 892.129769] [effa7ff0] [c000df58] call_do_softirq+0x14/0x24 [ 892.129775] [ebacfe70] [c0004868] do_softirq+0xd8/0x104 [ 892.129780] [ebacfe90] [c003d5a4] irq_exit+0xb8/0xd8 [ 892.129786] [ebacfea0] [c0004498] do_IRQ+0xa4/0x1b0 [ 892.129792] [ebacfed0] [c000fad8] ret_from_except+0x0/0x18 [ 892.129798] [ebacff90] [c0009010] cpu_idle+0x94/0xf0 [ 892.129804] [ebacffb0] [c059ff88] start_secondary+0x42c/0x430 [ 892.129809] [ebacfff0] [c0001e28] __secondary_start+0x30/0x84 [ 892.281474] [ 892.282959] [eff9fd00] [c0509724] esp_input+0x178/0x334 [ 892.288186] [eff9fd50] [c0519778] xfrm_input+0x77c/0x818 [ 892.293499] [eff9fda0] [c050e344] xfrm4_rcv_encap+0x20/0x30 [ 892.299074] [eff9fdb0] [c04b90c8] ip_local_deliver+0x190/0x408 [ 892.304907] [eff9fde0] [c04b966c] ip_rcv+0x32c/0x898 [ 892.309872] [eff9fe10] [c048b998] __netif_receive_skb+0x27c/0x4e8 [ 892.315966] [eff9fe80] [c048d744] netif_receive_skb+0x4c/0x13c [ 892.321803] [eff9feb0] [c03c28ac] _dpa_rx+0x1a8/0x354 [ 892.326855] [eff9fef0] [c03c2ac4] ingress_rx_default_dqrr+0x6c/0x108 [ 892.333212] [eff9ff10] [c0467ae0] qman_poll_dqrr+0x170/0x1d4 [ 892.338872] [eff9ff40] [c03c153c] dpaa_eth_poll+0x20/0x94 [ 892.344271] [eff9ff60] [c048dbd0] net_rx_action+0x13c/0x1f4 [ 892.349846] [eff9ffa0] [c003d1b8] __do_softirq+0x108/0x1b0 [ 892.355338] [eff9fff0] [c000df58] call_do_softirq+0x14/0x24 [ 892.360910] [e7169950] [c0004868] do_softirq+0xd8/0x104 [ 892.366135] [e7169970] [c003d5a4] irq_exit+0xb8/0xd8 [ 892.371101] [e7169980] [c0004498] do_IRQ+0xa4/0x1b0 [ 892.375979] [e71699b0] [c000fad8] ret_from_except+0x0/0x18 [ 892.381466] [e7169a70] [c0445e74] caam_jr_enqueue+0xf8/0x250 [ 892.387127] [e7169ab0] [c044ad4c] aead_givencrypt+0x6ac/0xa70 [ 892.392873] [e7169b20] [c050a0b8] esp_output+0x2b4/0x570 [ 892.398186] [e7169b80] [c0519b9c] xfrm_output_resume+0x248/0x7c0 [ 892.404194] [e7169bb0] [c050e89c] xfrm4_output_finish+0x18/0x28 [ 892.410113] [e7169bc0] [c050e8f4] xfrm4_output+0x48/0x98 [ 892.415427] [e7169bd0] [c04beac0] ip_local_out+0x48/0x98 [ 892.420740] [e7169be0] [c04bec7c] ip_queue_xmit+0x16c/0x490 [ 892.426314] [e7169c10] [c04d6128] tcp_transmit_skb+0x35c/0x9a4 [ 892.432147] [e7169c70] [c04d6f98] tcp_write_xmit+0x200/0xa04 [ 892.437808] [e7169cc0] [c04c8ccc] tcp_sendmsg+0x994/0xcec [ 892.443213] [e7169d40] [c04eebfc] inet_sendmsg+0xd0/0x164 [ 892.448617] [e7169d70] [c04792f8] sock_sendmsg+0x8c/0xbc [ 892.453931] [e7169e40] [c047aecc] sys_sendto+0xc0/0xfc [ 892.459069] [e7169f10] [c047b934] sys_socketcall+0x110/0x25c [ 892.464729] [e7169f40] [c000f480] ret_from_syscall+0x0/0x3c (b) since the caam_jr_dequeue lock is only used in bh context, then semantically it should use _bh spin_lock types. spin_lock_bh semantics are to disable back-halves, and used when a lock is shared between softirq (bh) context and process and/or h/w IRQ context. Since the lock is only used within softirq context, and this tasklet is atomic, there is no need to do the additional work to disable back halves. This patch adds back-half disabling protection to caam_jr_enqueue spin_locks to fix (a), and drops it from caam_jr_dequeue to fix (b). Signed-off-by: Kim Phillips <kim.phillips@freescale.com> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
481 lines
13 KiB
C
481 lines
13 KiB
C
/*
|
|
* CAAM/SEC 4.x transport/backend driver
|
|
* JobR backend functionality
|
|
*
|
|
* Copyright 2008-2012 Freescale Semiconductor, Inc.
|
|
*/
|
|
|
|
#include "compat.h"
|
|
#include "regs.h"
|
|
#include "jr.h"
|
|
#include "desc.h"
|
|
#include "intern.h"
|
|
|
|
/* Main per-ring interrupt handler */
|
|
static irqreturn_t caam_jr_interrupt(int irq, void *st_dev)
|
|
{
|
|
struct device *dev = st_dev;
|
|
struct caam_drv_private_jr *jrp = dev_get_drvdata(dev);
|
|
u32 irqstate;
|
|
|
|
/*
|
|
* Check the output ring for ready responses, kick
|
|
* tasklet if jobs done.
|
|
*/
|
|
irqstate = rd_reg32(&jrp->rregs->jrintstatus);
|
|
if (!irqstate)
|
|
return IRQ_NONE;
|
|
|
|
/*
|
|
* If JobR error, we got more development work to do
|
|
* Flag a bug now, but we really need to shut down and
|
|
* restart the queue (and fix code).
|
|
*/
|
|
if (irqstate & JRINT_JR_ERROR) {
|
|
dev_err(dev, "job ring error: irqstate: %08x\n", irqstate);
|
|
BUG();
|
|
}
|
|
|
|
/* mask valid interrupts */
|
|
setbits32(&jrp->rregs->rconfig_lo, JRCFG_IMSK);
|
|
|
|
/* Have valid interrupt at this point, just ACK and trigger */
|
|
wr_reg32(&jrp->rregs->jrintstatus, irqstate);
|
|
|
|
preempt_disable();
|
|
tasklet_schedule(&jrp->irqtask);
|
|
preempt_enable();
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/* Deferred service handler, run as interrupt-fired tasklet */
|
|
static void caam_jr_dequeue(unsigned long devarg)
|
|
{
|
|
int hw_idx, sw_idx, i, head, tail;
|
|
struct device *dev = (struct device *)devarg;
|
|
struct caam_drv_private_jr *jrp = dev_get_drvdata(dev);
|
|
void (*usercall)(struct device *dev, u32 *desc, u32 status, void *arg);
|
|
u32 *userdesc, userstatus;
|
|
void *userarg;
|
|
|
|
while (rd_reg32(&jrp->rregs->outring_used)) {
|
|
|
|
head = ACCESS_ONCE(jrp->head);
|
|
|
|
spin_lock(&jrp->outlock);
|
|
|
|
sw_idx = tail = jrp->tail;
|
|
hw_idx = jrp->out_ring_read_index;
|
|
|
|
for (i = 0; CIRC_CNT(head, tail + i, JOBR_DEPTH) >= 1; i++) {
|
|
sw_idx = (tail + i) & (JOBR_DEPTH - 1);
|
|
|
|
smp_read_barrier_depends();
|
|
|
|
if (jrp->outring[hw_idx].desc ==
|
|
jrp->entinfo[sw_idx].desc_addr_dma)
|
|
break; /* found */
|
|
}
|
|
/* we should never fail to find a matching descriptor */
|
|
BUG_ON(CIRC_CNT(head, tail + i, JOBR_DEPTH) <= 0);
|
|
|
|
/* Unmap just-run descriptor so we can post-process */
|
|
dma_unmap_single(dev, jrp->outring[hw_idx].desc,
|
|
jrp->entinfo[sw_idx].desc_size,
|
|
DMA_TO_DEVICE);
|
|
|
|
/* mark completed, avoid matching on a recycled desc addr */
|
|
jrp->entinfo[sw_idx].desc_addr_dma = 0;
|
|
|
|
/* Stash callback params for use outside of lock */
|
|
usercall = jrp->entinfo[sw_idx].callbk;
|
|
userarg = jrp->entinfo[sw_idx].cbkarg;
|
|
userdesc = jrp->entinfo[sw_idx].desc_addr_virt;
|
|
userstatus = jrp->outring[hw_idx].jrstatus;
|
|
|
|
/* set done */
|
|
wr_reg32(&jrp->rregs->outring_rmvd, 1);
|
|
|
|
jrp->out_ring_read_index = (jrp->out_ring_read_index + 1) &
|
|
(JOBR_DEPTH - 1);
|
|
|
|
/*
|
|
* if this job completed out-of-order, do not increment
|
|
* the tail. Otherwise, increment tail by 1 plus the
|
|
* number of subsequent jobs already completed out-of-order
|
|
*/
|
|
if (sw_idx == tail) {
|
|
do {
|
|
tail = (tail + 1) & (JOBR_DEPTH - 1);
|
|
smp_read_barrier_depends();
|
|
} while (CIRC_CNT(head, tail, JOBR_DEPTH) >= 1 &&
|
|
jrp->entinfo[tail].desc_addr_dma == 0);
|
|
|
|
jrp->tail = tail;
|
|
}
|
|
|
|
spin_unlock(&jrp->outlock);
|
|
|
|
/* Finally, execute user's callback */
|
|
usercall(dev, userdesc, userstatus, userarg);
|
|
}
|
|
|
|
/* reenable / unmask IRQs */
|
|
clrbits32(&jrp->rregs->rconfig_lo, JRCFG_IMSK);
|
|
}
|
|
|
|
/**
|
|
* caam_jr_register() - Alloc a ring for someone to use as needed. Returns
|
|
* an ordinal of the rings allocated, else returns -ENODEV if no rings
|
|
* are available.
|
|
* @ctrldev: points to the controller level dev (parent) that
|
|
* owns rings available for use.
|
|
* @dev: points to where a pointer to the newly allocated queue's
|
|
* dev can be written to if successful.
|
|
**/
|
|
int caam_jr_register(struct device *ctrldev, struct device **rdev)
|
|
{
|
|
struct caam_drv_private *ctrlpriv = dev_get_drvdata(ctrldev);
|
|
struct caam_drv_private_jr *jrpriv = NULL;
|
|
int ring;
|
|
|
|
/* Lock, if free ring - assign, unlock */
|
|
spin_lock(&ctrlpriv->jr_alloc_lock);
|
|
for (ring = 0; ring < ctrlpriv->total_jobrs; ring++) {
|
|
jrpriv = dev_get_drvdata(ctrlpriv->jrdev[ring]);
|
|
if (jrpriv->assign == JOBR_UNASSIGNED) {
|
|
jrpriv->assign = JOBR_ASSIGNED;
|
|
*rdev = ctrlpriv->jrdev[ring];
|
|
spin_unlock(&ctrlpriv->jr_alloc_lock);
|
|
return ring;
|
|
}
|
|
}
|
|
|
|
/* If assigned, write dev where caller needs it */
|
|
spin_unlock(&ctrlpriv->jr_alloc_lock);
|
|
*rdev = NULL;
|
|
|
|
return -ENODEV;
|
|
}
|
|
EXPORT_SYMBOL(caam_jr_register);
|
|
|
|
/**
|
|
* caam_jr_deregister() - Deregister an API and release the queue.
|
|
* Returns 0 if OK, -EBUSY if queue still contains pending entries
|
|
* or unprocessed results at the time of the call
|
|
* @dev - points to the dev that identifies the queue to
|
|
* be released.
|
|
**/
|
|
int caam_jr_deregister(struct device *rdev)
|
|
{
|
|
struct caam_drv_private_jr *jrpriv = dev_get_drvdata(rdev);
|
|
struct caam_drv_private *ctrlpriv;
|
|
|
|
/* Get the owning controller's private space */
|
|
ctrlpriv = dev_get_drvdata(jrpriv->parentdev);
|
|
|
|
/*
|
|
* Make sure ring empty before release
|
|
*/
|
|
if (rd_reg32(&jrpriv->rregs->outring_used) ||
|
|
(rd_reg32(&jrpriv->rregs->inpring_avail) != JOBR_DEPTH))
|
|
return -EBUSY;
|
|
|
|
/* Release ring */
|
|
spin_lock(&ctrlpriv->jr_alloc_lock);
|
|
jrpriv->assign = JOBR_UNASSIGNED;
|
|
spin_unlock(&ctrlpriv->jr_alloc_lock);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(caam_jr_deregister);
|
|
|
|
/**
|
|
* caam_jr_enqueue() - Enqueue a job descriptor head. Returns 0 if OK,
|
|
* -EBUSY if the queue is full, -EIO if it cannot map the caller's
|
|
* descriptor.
|
|
* @dev: device of the job ring to be used. This device should have
|
|
* been assigned prior by caam_jr_register().
|
|
* @desc: points to a job descriptor that execute our request. All
|
|
* descriptors (and all referenced data) must be in a DMAable
|
|
* region, and all data references must be physical addresses
|
|
* accessible to CAAM (i.e. within a PAMU window granted
|
|
* to it).
|
|
* @cbk: pointer to a callback function to be invoked upon completion
|
|
* of this request. This has the form:
|
|
* callback(struct device *dev, u32 *desc, u32 stat, void *arg)
|
|
* where:
|
|
* @dev: contains the job ring device that processed this
|
|
* response.
|
|
* @desc: descriptor that initiated the request, same as
|
|
* "desc" being argued to caam_jr_enqueue().
|
|
* @status: untranslated status received from CAAM. See the
|
|
* reference manual for a detailed description of
|
|
* error meaning, or see the JRSTA definitions in the
|
|
* register header file
|
|
* @areq: optional pointer to an argument passed with the
|
|
* original request
|
|
* @areq: optional pointer to a user argument for use at callback
|
|
* time.
|
|
**/
|
|
int caam_jr_enqueue(struct device *dev, u32 *desc,
|
|
void (*cbk)(struct device *dev, u32 *desc,
|
|
u32 status, void *areq),
|
|
void *areq)
|
|
{
|
|
struct caam_drv_private_jr *jrp = dev_get_drvdata(dev);
|
|
struct caam_jrentry_info *head_entry;
|
|
int head, tail, desc_size;
|
|
dma_addr_t desc_dma;
|
|
|
|
desc_size = (*desc & HDR_JD_LENGTH_MASK) * sizeof(u32);
|
|
desc_dma = dma_map_single(dev, desc, desc_size, DMA_TO_DEVICE);
|
|
if (dma_mapping_error(dev, desc_dma)) {
|
|
dev_err(dev, "caam_jr_enqueue(): can't map jobdesc\n");
|
|
return -EIO;
|
|
}
|
|
|
|
spin_lock_bh(&jrp->inplock);
|
|
|
|
head = jrp->head;
|
|
tail = ACCESS_ONCE(jrp->tail);
|
|
|
|
if (!rd_reg32(&jrp->rregs->inpring_avail) ||
|
|
CIRC_SPACE(head, tail, JOBR_DEPTH) <= 0) {
|
|
spin_unlock_bh(&jrp->inplock);
|
|
dma_unmap_single(dev, desc_dma, desc_size, DMA_TO_DEVICE);
|
|
return -EBUSY;
|
|
}
|
|
|
|
head_entry = &jrp->entinfo[head];
|
|
head_entry->desc_addr_virt = desc;
|
|
head_entry->desc_size = desc_size;
|
|
head_entry->callbk = (void *)cbk;
|
|
head_entry->cbkarg = areq;
|
|
head_entry->desc_addr_dma = desc_dma;
|
|
|
|
jrp->inpring[jrp->inp_ring_write_index] = desc_dma;
|
|
|
|
smp_wmb();
|
|
|
|
jrp->inp_ring_write_index = (jrp->inp_ring_write_index + 1) &
|
|
(JOBR_DEPTH - 1);
|
|
jrp->head = (head + 1) & (JOBR_DEPTH - 1);
|
|
|
|
wr_reg32(&jrp->rregs->inpring_jobadd, 1);
|
|
|
|
spin_unlock_bh(&jrp->inplock);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(caam_jr_enqueue);
|
|
|
|
static int caam_reset_hw_jr(struct device *dev)
|
|
{
|
|
struct caam_drv_private_jr *jrp = dev_get_drvdata(dev);
|
|
unsigned int timeout = 100000;
|
|
|
|
/*
|
|
* mask interrupts since we are going to poll
|
|
* for reset completion status
|
|
*/
|
|
setbits32(&jrp->rregs->rconfig_lo, JRCFG_IMSK);
|
|
|
|
/* initiate flush (required prior to reset) */
|
|
wr_reg32(&jrp->rregs->jrcommand, JRCR_RESET);
|
|
while (((rd_reg32(&jrp->rregs->jrintstatus) & JRINT_ERR_HALT_MASK) ==
|
|
JRINT_ERR_HALT_INPROGRESS) && --timeout)
|
|
cpu_relax();
|
|
|
|
if ((rd_reg32(&jrp->rregs->jrintstatus) & JRINT_ERR_HALT_MASK) !=
|
|
JRINT_ERR_HALT_COMPLETE || timeout == 0) {
|
|
dev_err(dev, "failed to flush job ring %d\n", jrp->ridx);
|
|
return -EIO;
|
|
}
|
|
|
|
/* initiate reset */
|
|
timeout = 100000;
|
|
wr_reg32(&jrp->rregs->jrcommand, JRCR_RESET);
|
|
while ((rd_reg32(&jrp->rregs->jrcommand) & JRCR_RESET) && --timeout)
|
|
cpu_relax();
|
|
|
|
if (timeout == 0) {
|
|
dev_err(dev, "failed to reset job ring %d\n", jrp->ridx);
|
|
return -EIO;
|
|
}
|
|
|
|
/* unmask interrupts */
|
|
clrbits32(&jrp->rregs->rconfig_lo, JRCFG_IMSK);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Init JobR independent of platform property detection
|
|
*/
|
|
static int caam_jr_init(struct device *dev)
|
|
{
|
|
struct caam_drv_private_jr *jrp;
|
|
dma_addr_t inpbusaddr, outbusaddr;
|
|
int i, error;
|
|
|
|
jrp = dev_get_drvdata(dev);
|
|
|
|
tasklet_init(&jrp->irqtask, caam_jr_dequeue, (unsigned long)dev);
|
|
|
|
/* Connect job ring interrupt handler. */
|
|
error = request_irq(jrp->irq, caam_jr_interrupt, IRQF_SHARED,
|
|
"caam-jobr", dev);
|
|
if (error) {
|
|
dev_err(dev, "can't connect JobR %d interrupt (%d)\n",
|
|
jrp->ridx, jrp->irq);
|
|
irq_dispose_mapping(jrp->irq);
|
|
jrp->irq = 0;
|
|
return -EINVAL;
|
|
}
|
|
|
|
error = caam_reset_hw_jr(dev);
|
|
if (error)
|
|
return error;
|
|
|
|
jrp->inpring = dma_alloc_coherent(dev, sizeof(dma_addr_t) * JOBR_DEPTH,
|
|
&inpbusaddr, GFP_KERNEL);
|
|
|
|
jrp->outring = dma_alloc_coherent(dev, sizeof(struct jr_outentry) *
|
|
JOBR_DEPTH, &outbusaddr, GFP_KERNEL);
|
|
|
|
jrp->entinfo = kzalloc(sizeof(struct caam_jrentry_info) * JOBR_DEPTH,
|
|
GFP_KERNEL);
|
|
|
|
if ((jrp->inpring == NULL) || (jrp->outring == NULL) ||
|
|
(jrp->entinfo == NULL)) {
|
|
dev_err(dev, "can't allocate job rings for %d\n",
|
|
jrp->ridx);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
for (i = 0; i < JOBR_DEPTH; i++)
|
|
jrp->entinfo[i].desc_addr_dma = !0;
|
|
|
|
/* Setup rings */
|
|
jrp->inp_ring_write_index = 0;
|
|
jrp->out_ring_read_index = 0;
|
|
jrp->head = 0;
|
|
jrp->tail = 0;
|
|
|
|
wr_reg64(&jrp->rregs->inpring_base, inpbusaddr);
|
|
wr_reg64(&jrp->rregs->outring_base, outbusaddr);
|
|
wr_reg32(&jrp->rregs->inpring_size, JOBR_DEPTH);
|
|
wr_reg32(&jrp->rregs->outring_size, JOBR_DEPTH);
|
|
|
|
jrp->ringsize = JOBR_DEPTH;
|
|
|
|
spin_lock_init(&jrp->inplock);
|
|
spin_lock_init(&jrp->outlock);
|
|
|
|
/* Select interrupt coalescing parameters */
|
|
setbits32(&jrp->rregs->rconfig_lo, JOBR_INTC |
|
|
(JOBR_INTC_COUNT_THLD << JRCFG_ICDCT_SHIFT) |
|
|
(JOBR_INTC_TIME_THLD << JRCFG_ICTT_SHIFT));
|
|
|
|
jrp->assign = JOBR_UNASSIGNED;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Shutdown JobR independent of platform property code
|
|
*/
|
|
int caam_jr_shutdown(struct device *dev)
|
|
{
|
|
struct caam_drv_private_jr *jrp = dev_get_drvdata(dev);
|
|
dma_addr_t inpbusaddr, outbusaddr;
|
|
int ret;
|
|
|
|
ret = caam_reset_hw_jr(dev);
|
|
|
|
tasklet_kill(&jrp->irqtask);
|
|
|
|
/* Release interrupt */
|
|
free_irq(jrp->irq, dev);
|
|
|
|
/* Free rings */
|
|
inpbusaddr = rd_reg64(&jrp->rregs->inpring_base);
|
|
outbusaddr = rd_reg64(&jrp->rregs->outring_base);
|
|
dma_free_coherent(dev, sizeof(dma_addr_t) * JOBR_DEPTH,
|
|
jrp->inpring, inpbusaddr);
|
|
dma_free_coherent(dev, sizeof(struct jr_outentry) * JOBR_DEPTH,
|
|
jrp->outring, outbusaddr);
|
|
kfree(jrp->entinfo);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Probe routine for each detected JobR subsystem. It assumes that
|
|
* property detection was picked up externally.
|
|
*/
|
|
int caam_jr_probe(struct platform_device *pdev, struct device_node *np,
|
|
int ring)
|
|
{
|
|
struct device *ctrldev, *jrdev;
|
|
struct platform_device *jr_pdev;
|
|
struct caam_drv_private *ctrlpriv;
|
|
struct caam_drv_private_jr *jrpriv;
|
|
u32 *jroffset;
|
|
int error;
|
|
|
|
ctrldev = &pdev->dev;
|
|
ctrlpriv = dev_get_drvdata(ctrldev);
|
|
|
|
jrpriv = kmalloc(sizeof(struct caam_drv_private_jr),
|
|
GFP_KERNEL);
|
|
if (jrpriv == NULL) {
|
|
dev_err(ctrldev, "can't alloc private mem for job ring %d\n",
|
|
ring);
|
|
return -ENOMEM;
|
|
}
|
|
jrpriv->parentdev = ctrldev; /* point back to parent */
|
|
jrpriv->ridx = ring; /* save ring identity relative to detection */
|
|
|
|
/*
|
|
* Derive a pointer to the detected JobRs regs
|
|
* Driver has already iomapped the entire space, we just
|
|
* need to add in the offset to this JobR. Don't know if I
|
|
* like this long-term, but it'll run
|
|
*/
|
|
jroffset = (u32 *)of_get_property(np, "reg", NULL);
|
|
jrpriv->rregs = (struct caam_job_ring __iomem *)((void *)ctrlpriv->ctrl
|
|
+ *jroffset);
|
|
|
|
/* Build a local dev for each detected queue */
|
|
jr_pdev = of_platform_device_create(np, NULL, ctrldev);
|
|
if (jr_pdev == NULL) {
|
|
kfree(jrpriv);
|
|
return -EINVAL;
|
|
}
|
|
jrdev = &jr_pdev->dev;
|
|
dev_set_drvdata(jrdev, jrpriv);
|
|
ctrlpriv->jrdev[ring] = jrdev;
|
|
|
|
if (sizeof(dma_addr_t) == sizeof(u64))
|
|
if (of_device_is_compatible(np, "fsl,sec-v5.0-job-ring"))
|
|
dma_set_mask(jrdev, DMA_BIT_MASK(40));
|
|
else
|
|
dma_set_mask(jrdev, DMA_BIT_MASK(36));
|
|
else
|
|
dma_set_mask(jrdev, DMA_BIT_MASK(32));
|
|
|
|
/* Identify the interrupt */
|
|
jrpriv->irq = of_irq_to_resource(np, 0, NULL);
|
|
|
|
/* Now do the platform independent part */
|
|
error = caam_jr_init(jrdev); /* now turn on hardware */
|
|
if (error) {
|
|
kfree(jrpriv);
|
|
return error;
|
|
}
|
|
|
|
return error;
|
|
}
|