2009-08-26 20:01:44 +00:00
|
|
|
/*
|
|
|
|
* Intel I/OAT DMA Linux driver
|
|
|
|
* Copyright(c) 2004 - 2009 Intel Corporation.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms and conditions of the GNU General Public License,
|
|
|
|
* version 2, as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
* this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*
|
|
|
|
* The full GNU General Public License is included in this distribution in
|
|
|
|
* the file called "COPYING".
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This driver supports an Intel I/OAT DMA engine (versions >= 2), which
|
|
|
|
* does asynchronous data movement and checksumming operations.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2009-08-26 20:01:44 +00:00
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/dmaengine.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/workqueue.h>
|
2011-05-22 20:47:17 +00:00
|
|
|
#include <linux/prefetch.h>
|
2009-08-26 20:01:44 +00:00
|
|
|
#include <linux/i7300_idle.h>
|
|
|
|
#include "dma.h"
|
|
|
|
#include "dma_v2.h"
|
|
|
|
#include "registers.h"
|
|
|
|
#include "hw.h"
|
|
|
|
|
2012-03-06 22:34:26 +00:00
|
|
|
#include "../dmaengine.h"
|
|
|
|
|
2009-09-09 00:42:55 +00:00
|
|
|
int ioat_ring_alloc_order = 8;
|
2009-08-26 20:01:44 +00:00
|
|
|
module_param(ioat_ring_alloc_order, int, 0644);
|
|
|
|
MODULE_PARM_DESC(ioat_ring_alloc_order,
|
2009-09-16 22:16:50 +00:00
|
|
|
"ioat2+: allocate 2^n descriptors per channel"
|
|
|
|
" (default: 8 max: 16)");
|
2009-09-08 19:02:01 +00:00
|
|
|
static int ioat_ring_max_alloc_order = IOAT_MAX_ORDER;
|
|
|
|
module_param(ioat_ring_max_alloc_order, int, 0644);
|
|
|
|
MODULE_PARM_DESC(ioat_ring_max_alloc_order,
|
2009-09-16 22:16:50 +00:00
|
|
|
"ioat2+: upper limit for ring size (default: 16)");
|
2009-08-26 20:01:44 +00:00
|
|
|
|
2009-09-09 00:42:57 +00:00
|
|
|
void __ioat2_issue_pending(struct ioat2_dma_chan *ioat)
|
2009-08-26 20:01:44 +00:00
|
|
|
{
|
2010-03-03 18:47:43 +00:00
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
2009-08-26 20:01:44 +00:00
|
|
|
|
2009-09-16 22:16:50 +00:00
|
|
|
ioat->dmacount += ioat2_ring_pending(ioat);
|
2009-08-26 20:01:44 +00:00
|
|
|
ioat->issued = ioat->head;
|
2010-03-03 18:47:43 +00:00
|
|
|
writew(ioat->dmacount, chan->reg_base + IOAT_CHAN_DMACOUNT_OFFSET);
|
|
|
|
dev_dbg(to_dev(chan),
|
2009-09-08 19:00:55 +00:00
|
|
|
"%s: head: %#x tail: %#x issued: %#x count: %#x\n",
|
|
|
|
__func__, ioat->head, ioat->tail, ioat->issued, ioat->dmacount);
|
2009-08-26 20:01:44 +00:00
|
|
|
}
|
|
|
|
|
2010-03-03 18:47:43 +00:00
|
|
|
void ioat2_issue_pending(struct dma_chan *c)
|
2009-08-26 20:01:44 +00:00
|
|
|
{
|
2010-03-03 18:47:43 +00:00
|
|
|
struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
|
2009-08-26 20:01:44 +00:00
|
|
|
|
2010-03-03 18:47:43 +00:00
|
|
|
if (ioat2_ring_pending(ioat)) {
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_lock_bh(&ioat->prep_lock);
|
2009-08-26 20:01:44 +00:00
|
|
|
__ioat2_issue_pending(ioat);
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_unlock_bh(&ioat->prep_lock);
|
2010-03-03 18:47:43 +00:00
|
|
|
}
|
2009-08-26 20:01:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ioat2_update_pending - log pending descriptors
|
|
|
|
* @ioat: ioat2+ channel
|
|
|
|
*
|
2010-03-03 18:47:43 +00:00
|
|
|
* Check if the number of unsubmitted descriptors has exceeded the
|
2010-05-01 22:22:55 +00:00
|
|
|
* watermark. Called with prep_lock held
|
2009-08-26 20:01:44 +00:00
|
|
|
*/
|
|
|
|
static void ioat2_update_pending(struct ioat2_dma_chan *ioat)
|
|
|
|
{
|
2010-03-03 18:47:43 +00:00
|
|
|
if (ioat2_ring_pending(ioat) > ioat_pending_level)
|
2009-08-26 20:01:44 +00:00
|
|
|
__ioat2_issue_pending(ioat);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __ioat2_start_null_desc(struct ioat2_dma_chan *ioat)
|
|
|
|
{
|
|
|
|
struct ioat_ring_ent *desc;
|
|
|
|
struct ioat_dma_descriptor *hw;
|
|
|
|
|
|
|
|
if (ioat2_ring_space(ioat) < 1) {
|
|
|
|
dev_err(to_dev(&ioat->base),
|
|
|
|
"Unable to start null desc - ring full\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-09-08 19:00:55 +00:00
|
|
|
dev_dbg(to_dev(&ioat->base), "%s: head: %#x tail: %#x issued: %#x\n",
|
|
|
|
__func__, ioat->head, ioat->tail, ioat->issued);
|
2010-05-01 22:22:55 +00:00
|
|
|
desc = ioat2_get_ring_ent(ioat, ioat->head);
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
hw = desc->hw;
|
|
|
|
hw->ctl = 0;
|
|
|
|
hw->ctl_f.null = 1;
|
|
|
|
hw->ctl_f.int_en = 1;
|
|
|
|
hw->ctl_f.compl_write = 1;
|
|
|
|
/* set size to non-zero value (channel returns error when size is 0) */
|
|
|
|
hw->size = NULL_DESC_BUFFER_SIZE;
|
|
|
|
hw->src_addr = 0;
|
|
|
|
hw->dst_addr = 0;
|
|
|
|
async_tx_ack(&desc->txd);
|
2009-09-08 19:01:49 +00:00
|
|
|
ioat2_set_chainaddr(ioat, desc->txd.phys);
|
2009-09-08 19:00:55 +00:00
|
|
|
dump_desc_dbg(ioat, desc);
|
2010-05-01 22:22:55 +00:00
|
|
|
wmb();
|
|
|
|
ioat->head += 1;
|
2009-08-26 20:01:44 +00:00
|
|
|
__ioat2_issue_pending(ioat);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ioat2_start_null_desc(struct ioat2_dma_chan *ioat)
|
|
|
|
{
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_lock_bh(&ioat->prep_lock);
|
2009-08-26 20:01:44 +00:00
|
|
|
__ioat2_start_null_desc(ioat);
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_unlock_bh(&ioat->prep_lock);
|
2009-08-26 20:01:44 +00:00
|
|
|
}
|
|
|
|
|
2012-03-23 20:36:42 +00:00
|
|
|
static void __cleanup(struct ioat2_dma_chan *ioat, dma_addr_t phys_complete)
|
2009-08-26 20:01:44 +00:00
|
|
|
{
|
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
2009-09-08 19:01:49 +00:00
|
|
|
struct dma_async_tx_descriptor *tx;
|
2009-08-26 20:01:44 +00:00
|
|
|
struct ioat_ring_ent *desc;
|
|
|
|
bool seen_current = false;
|
|
|
|
u16 active;
|
2010-05-01 22:22:55 +00:00
|
|
|
int idx = ioat->tail, i;
|
2009-08-26 20:01:44 +00:00
|
|
|
|
2009-09-08 19:00:55 +00:00
|
|
|
dev_dbg(to_dev(chan), "%s: head: %#x tail: %#x issued: %#x\n",
|
|
|
|
__func__, ioat->head, ioat->tail, ioat->issued);
|
|
|
|
|
2009-08-26 20:01:44 +00:00
|
|
|
active = ioat2_ring_active(ioat);
|
|
|
|
for (i = 0; i < active && !seen_current; i++) {
|
2010-05-01 22:22:55 +00:00
|
|
|
smp_read_barrier_depends();
|
|
|
|
prefetch(ioat2_get_ring_ent(ioat, idx + i + 1));
|
|
|
|
desc = ioat2_get_ring_ent(ioat, idx + i);
|
2009-08-26 20:01:44 +00:00
|
|
|
tx = &desc->txd;
|
2009-09-08 19:00:55 +00:00
|
|
|
dump_desc_dbg(ioat, desc);
|
2009-08-26 20:01:44 +00:00
|
|
|
if (tx->cookie) {
|
|
|
|
ioat_dma_unmap(chan, tx->flags, desc->len, desc->hw);
|
2012-03-06 22:35:07 +00:00
|
|
|
dma_cookie_complete(tx);
|
2009-08-26 20:01:44 +00:00
|
|
|
if (tx->callback) {
|
|
|
|
tx->callback(tx->callback_param);
|
|
|
|
tx->callback = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tx->phys == phys_complete)
|
|
|
|
seen_current = true;
|
|
|
|
}
|
2010-05-01 22:22:55 +00:00
|
|
|
smp_mb(); /* finish all descriptor reads before incrementing tail */
|
|
|
|
ioat->tail = idx + i;
|
2010-03-04 04:21:10 +00:00
|
|
|
BUG_ON(active && !seen_current); /* no active descs have written a completion? */
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
chan->last_completion = phys_complete;
|
2010-05-01 22:22:55 +00:00
|
|
|
if (active - i == 0) {
|
2009-09-08 19:01:49 +00:00
|
|
|
dev_dbg(to_dev(chan), "%s: cancel completion timeout\n",
|
|
|
|
__func__);
|
|
|
|
clear_bit(IOAT_COMPLETION_PENDING, &chan->state);
|
2009-09-08 19:02:01 +00:00
|
|
|
mod_timer(&chan->timer, jiffies + IDLE_TIMEOUT);
|
2009-09-08 19:01:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ioat2_cleanup - clean finished descriptors (advance tail pointer)
|
|
|
|
* @chan: ioat channel to be cleaned up
|
|
|
|
*/
|
|
|
|
static void ioat2_cleanup(struct ioat2_dma_chan *ioat)
|
|
|
|
{
|
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
2012-03-23 20:36:42 +00:00
|
|
|
dma_addr_t phys_complete;
|
2009-08-26 20:01:44 +00:00
|
|
|
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_lock_bh(&chan->cleanup_lock);
|
|
|
|
if (ioat_cleanup_preamble(chan, &phys_complete))
|
|
|
|
__cleanup(ioat, phys_complete);
|
2009-08-26 20:01:44 +00:00
|
|
|
spin_unlock_bh(&chan->cleanup_lock);
|
|
|
|
}
|
|
|
|
|
2010-03-04 04:21:13 +00:00
|
|
|
void ioat2_cleanup_event(unsigned long data)
|
2009-08-26 20:01:44 +00:00
|
|
|
{
|
2010-03-04 04:21:13 +00:00
|
|
|
struct ioat2_dma_chan *ioat = to_ioat2_chan((void *) data);
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
ioat2_cleanup(ioat);
|
2009-09-08 19:01:21 +00:00
|
|
|
writew(IOAT_CHANCTRL_RUN, ioat->base.reg_base + IOAT_CHANCTRL_OFFSET);
|
2009-08-26 20:01:44 +00:00
|
|
|
}
|
|
|
|
|
2009-09-09 00:42:55 +00:00
|
|
|
void __ioat2_restart_chan(struct ioat2_dma_chan *ioat)
|
2009-09-08 19:01:49 +00:00
|
|
|
{
|
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
|
|
|
|
|
|
|
/* set the tail to be re-issued */
|
|
|
|
ioat->issued = ioat->tail;
|
|
|
|
ioat->dmacount = 0;
|
|
|
|
set_bit(IOAT_COMPLETION_PENDING, &chan->state);
|
|
|
|
mod_timer(&chan->timer, jiffies + COMPLETION_TIMEOUT);
|
|
|
|
|
|
|
|
dev_dbg(to_dev(chan),
|
|
|
|
"%s: head: %#x tail: %#x issued: %#x count: %#x\n",
|
|
|
|
__func__, ioat->head, ioat->tail, ioat->issued, ioat->dmacount);
|
|
|
|
|
|
|
|
if (ioat2_ring_pending(ioat)) {
|
|
|
|
struct ioat_ring_ent *desc;
|
|
|
|
|
|
|
|
desc = ioat2_get_ring_ent(ioat, ioat->tail);
|
|
|
|
ioat2_set_chainaddr(ioat, desc->txd.phys);
|
|
|
|
__ioat2_issue_pending(ioat);
|
|
|
|
} else
|
|
|
|
__ioat2_start_null_desc(ioat);
|
|
|
|
}
|
|
|
|
|
2009-12-19 22:36:02 +00:00
|
|
|
int ioat2_quiesce(struct ioat_chan_common *chan, unsigned long tmo)
|
2009-09-08 19:01:49 +00:00
|
|
|
{
|
2009-12-19 22:36:02 +00:00
|
|
|
unsigned long end = jiffies + tmo;
|
|
|
|
int err = 0;
|
2009-09-08 19:01:49 +00:00
|
|
|
u32 status;
|
|
|
|
|
|
|
|
status = ioat_chansts(chan);
|
|
|
|
if (is_ioat_active(status) || is_ioat_idle(status))
|
|
|
|
ioat_suspend(chan);
|
|
|
|
while (is_ioat_active(status) || is_ioat_idle(status)) {
|
2010-01-13 20:33:12 +00:00
|
|
|
if (tmo && time_after(jiffies, end)) {
|
2009-12-19 22:36:02 +00:00
|
|
|
err = -ETIMEDOUT;
|
|
|
|
break;
|
|
|
|
}
|
2009-09-08 19:01:49 +00:00
|
|
|
status = ioat_chansts(chan);
|
|
|
|
cpu_relax();
|
|
|
|
}
|
|
|
|
|
2009-12-19 22:36:02 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ioat2_reset_sync(struct ioat_chan_common *chan, unsigned long tmo)
|
|
|
|
{
|
|
|
|
unsigned long end = jiffies + tmo;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
ioat_reset(chan);
|
|
|
|
while (ioat_reset_pending(chan)) {
|
|
|
|
if (end && time_after(jiffies, end)) {
|
|
|
|
err = -ETIMEDOUT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
cpu_relax();
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ioat2_restart_channel(struct ioat2_dma_chan *ioat)
|
|
|
|
{
|
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
2012-03-23 20:36:42 +00:00
|
|
|
dma_addr_t phys_complete;
|
2009-12-19 22:36:02 +00:00
|
|
|
|
|
|
|
ioat2_quiesce(chan, 0);
|
2009-09-08 19:01:49 +00:00
|
|
|
if (ioat_cleanup_preamble(chan, &phys_complete))
|
|
|
|
__cleanup(ioat, phys_complete);
|
|
|
|
|
2009-09-09 00:42:55 +00:00
|
|
|
__ioat2_restart_chan(ioat);
|
2009-09-08 19:01:49 +00:00
|
|
|
}
|
|
|
|
|
2013-02-07 21:38:32 +00:00
|
|
|
static void check_active(struct ioat2_dma_chan *ioat)
|
2009-09-08 19:01:49 +00:00
|
|
|
{
|
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
|
|
|
|
2013-02-07 21:38:32 +00:00
|
|
|
if (ioat2_ring_active(ioat)) {
|
|
|
|
mod_timer(&chan->timer, jiffies + COMPLETION_TIMEOUT);
|
|
|
|
return;
|
|
|
|
}
|
2009-09-08 19:02:01 +00:00
|
|
|
|
2013-02-07 21:38:32 +00:00
|
|
|
if (test_and_clear_bit(IOAT_CHAN_ACTIVE, &chan->state))
|
|
|
|
mod_timer(&chan->timer, jiffies + IDLE_TIMEOUT);
|
|
|
|
else if (ioat->alloc_order > ioat_get_alloc_order()) {
|
2009-09-08 19:02:01 +00:00
|
|
|
/* if the ring is idle, empty, and oversized try to step
|
|
|
|
* down the size
|
|
|
|
*/
|
2013-02-07 21:38:32 +00:00
|
|
|
reshape_ring(ioat, ioat->alloc_order - 1);
|
2009-09-08 19:02:01 +00:00
|
|
|
|
|
|
|
/* keep shrinking until we get back to our minimum
|
|
|
|
* default size
|
|
|
|
*/
|
|
|
|
if (ioat->alloc_order > ioat_get_alloc_order())
|
|
|
|
mod_timer(&chan->timer, jiffies + IDLE_TIMEOUT);
|
2009-09-08 19:01:49 +00:00
|
|
|
}
|
2013-02-07 21:38:32 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void ioat2_timer_event(unsigned long data)
|
|
|
|
{
|
|
|
|
struct ioat2_dma_chan *ioat = to_ioat2_chan((void *) data);
|
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
|
|
|
dma_addr_t phys_complete;
|
|
|
|
u64 status;
|
|
|
|
|
|
|
|
status = ioat_chansts(chan);
|
|
|
|
|
|
|
|
/* when halted due to errors check for channel
|
|
|
|
* programming errors before advancing the completion state
|
|
|
|
*/
|
|
|
|
if (is_ioat_halted(status)) {
|
|
|
|
u32 chanerr;
|
|
|
|
|
|
|
|
chanerr = readl(chan->reg_base + IOAT_CHANERR_OFFSET);
|
|
|
|
dev_err(to_dev(chan), "%s: Channel halted (%x)\n",
|
|
|
|
__func__, chanerr);
|
|
|
|
if (test_bit(IOAT_RUN, &chan->state))
|
|
|
|
BUG_ON(is_ioat_bug(chanerr));
|
|
|
|
else /* we never got off the ground */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if we haven't made progress and we have already
|
|
|
|
* acknowledged a pending completion once, then be more
|
|
|
|
* forceful with a restart
|
|
|
|
*/
|
|
|
|
spin_lock_bh(&chan->cleanup_lock);
|
|
|
|
if (ioat_cleanup_preamble(chan, &phys_complete))
|
|
|
|
__cleanup(ioat, phys_complete);
|
|
|
|
else if (test_bit(IOAT_COMPLETION_ACK, &chan->state)) {
|
|
|
|
spin_lock_bh(&ioat->prep_lock);
|
|
|
|
ioat2_restart_channel(ioat);
|
|
|
|
spin_unlock_bh(&ioat->prep_lock);
|
|
|
|
spin_unlock_bh(&chan->cleanup_lock);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
set_bit(IOAT_COMPLETION_ACK, &chan->state);
|
|
|
|
mod_timer(&chan->timer, jiffies + COMPLETION_TIMEOUT);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (ioat2_ring_active(ioat))
|
|
|
|
mod_timer(&chan->timer, jiffies + COMPLETION_TIMEOUT);
|
|
|
|
else {
|
|
|
|
spin_lock_bh(&ioat->prep_lock);
|
|
|
|
check_active(ioat);
|
|
|
|
spin_unlock_bh(&ioat->prep_lock);
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&chan->cleanup_lock);
|
2009-09-08 19:01:49 +00:00
|
|
|
}
|
|
|
|
|
2009-12-19 22:36:02 +00:00
|
|
|
static int ioat2_reset_hw(struct ioat_chan_common *chan)
|
|
|
|
{
|
|
|
|
/* throw away whatever the channel was doing and get it initialized */
|
|
|
|
u32 chanerr;
|
|
|
|
|
|
|
|
ioat2_quiesce(chan, msecs_to_jiffies(100));
|
|
|
|
|
|
|
|
chanerr = readl(chan->reg_base + IOAT_CHANERR_OFFSET);
|
|
|
|
writel(chanerr, chan->reg_base + IOAT_CHANERR_OFFSET);
|
|
|
|
|
|
|
|
return ioat2_reset_sync(chan, msecs_to_jiffies(200));
|
|
|
|
}
|
|
|
|
|
2009-08-26 20:01:44 +00:00
|
|
|
/**
|
|
|
|
* ioat2_enumerate_channels - find and initialize the device's channels
|
|
|
|
* @device: the device to be enumerated
|
|
|
|
*/
|
2009-09-09 00:42:55 +00:00
|
|
|
int ioat2_enumerate_channels(struct ioatdma_device *device)
|
2009-08-26 20:01:44 +00:00
|
|
|
{
|
|
|
|
struct ioat2_dma_chan *ioat;
|
|
|
|
struct device *dev = &device->pdev->dev;
|
|
|
|
struct dma_device *dma = &device->common;
|
|
|
|
u8 xfercap_log;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&dma->channels);
|
|
|
|
dma->chancnt = readb(device->reg_base + IOAT_CHANCNT_OFFSET);
|
2009-09-08 19:01:14 +00:00
|
|
|
dma->chancnt &= 0x1f; /* bits [4:0] valid */
|
|
|
|
if (dma->chancnt > ARRAY_SIZE(device->idx)) {
|
|
|
|
dev_warn(dev, "(%d) exceeds max supported channels (%zu)\n",
|
|
|
|
dma->chancnt, ARRAY_SIZE(device->idx));
|
|
|
|
dma->chancnt = ARRAY_SIZE(device->idx);
|
|
|
|
}
|
2009-08-26 20:01:44 +00:00
|
|
|
xfercap_log = readb(device->reg_base + IOAT_XFERCAP_OFFSET);
|
2009-09-08 19:01:14 +00:00
|
|
|
xfercap_log &= 0x1f; /* bits [4:0] valid */
|
2009-08-26 20:01:44 +00:00
|
|
|
if (xfercap_log == 0)
|
|
|
|
return 0;
|
2009-09-08 19:00:55 +00:00
|
|
|
dev_dbg(dev, "%s: xfercap = %d\n", __func__, 1 << xfercap_log);
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
/* FIXME which i/oat version is i7300? */
|
|
|
|
#ifdef CONFIG_I7300_IDLE_IOAT_CHANNEL
|
|
|
|
if (i7300_idle_platform_probe(NULL, NULL, 1) == 0)
|
|
|
|
dma->chancnt--;
|
|
|
|
#endif
|
|
|
|
for (i = 0; i < dma->chancnt; i++) {
|
|
|
|
ioat = devm_kzalloc(dev, sizeof(*ioat), GFP_KERNEL);
|
|
|
|
if (!ioat)
|
|
|
|
break;
|
|
|
|
|
2010-03-04 04:21:13 +00:00
|
|
|
ioat_init_channel(device, &ioat->base, i);
|
2009-08-26 20:01:44 +00:00
|
|
|
ioat->xfercap_log = xfercap_log;
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_lock_init(&ioat->prep_lock);
|
2009-12-19 22:36:02 +00:00
|
|
|
if (device->reset_hw(&ioat->base)) {
|
|
|
|
i = 0;
|
|
|
|
break;
|
|
|
|
}
|
2009-08-26 20:01:44 +00:00
|
|
|
}
|
|
|
|
dma->chancnt = i;
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
static dma_cookie_t ioat2_tx_submit_unlock(struct dma_async_tx_descriptor *tx)
|
|
|
|
{
|
|
|
|
struct dma_chan *c = tx->chan;
|
|
|
|
struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
|
2009-09-08 19:01:49 +00:00
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
2012-03-06 22:34:46 +00:00
|
|
|
dma_cookie_t cookie;
|
2009-08-26 20:01:44 +00:00
|
|
|
|
2012-03-06 22:34:46 +00:00
|
|
|
cookie = dma_cookie_assign(tx);
|
2009-09-08 19:00:55 +00:00
|
|
|
dev_dbg(to_dev(&ioat->base), "%s: cookie: %d\n", __func__, cookie);
|
|
|
|
|
2013-02-07 21:38:32 +00:00
|
|
|
if (!test_and_set_bit(IOAT_CHAN_ACTIVE, &chan->state))
|
2009-09-08 19:01:49 +00:00
|
|
|
mod_timer(&chan->timer, jiffies + COMPLETION_TIMEOUT);
|
2010-05-01 22:22:55 +00:00
|
|
|
|
|
|
|
/* make descriptor updates visible before advancing ioat->head,
|
|
|
|
* this is purposefully not smp_wmb() since we are also
|
|
|
|
* publishing the descriptor updates to a dma device
|
|
|
|
*/
|
|
|
|
wmb();
|
|
|
|
|
|
|
|
ioat->head += ioat->produce;
|
|
|
|
|
2009-08-26 20:01:44 +00:00
|
|
|
ioat2_update_pending(ioat);
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_unlock_bh(&ioat->prep_lock);
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
return cookie;
|
|
|
|
}
|
|
|
|
|
2009-09-08 19:02:01 +00:00
|
|
|
static struct ioat_ring_ent *ioat2_alloc_ring_ent(struct dma_chan *chan, gfp_t flags)
|
2009-08-26 20:01:44 +00:00
|
|
|
{
|
|
|
|
struct ioat_dma_descriptor *hw;
|
|
|
|
struct ioat_ring_ent *desc;
|
|
|
|
struct ioatdma_device *dma;
|
|
|
|
dma_addr_t phys;
|
|
|
|
|
|
|
|
dma = to_ioatdma_device(chan->device);
|
2009-09-08 19:02:01 +00:00
|
|
|
hw = pci_pool_alloc(dma->dma_pool, flags, &phys);
|
2009-08-26 20:01:44 +00:00
|
|
|
if (!hw)
|
|
|
|
return NULL;
|
|
|
|
memset(hw, 0, sizeof(*hw));
|
|
|
|
|
2012-08-27 04:40:42 +00:00
|
|
|
desc = kmem_cache_zalloc(ioat2_cache, flags);
|
2009-08-26 20:01:44 +00:00
|
|
|
if (!desc) {
|
|
|
|
pci_pool_free(dma->dma_pool, hw, phys);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dma_async_tx_descriptor_init(&desc->txd, chan);
|
|
|
|
desc->txd.tx_submit = ioat2_tx_submit_unlock;
|
|
|
|
desc->hw = hw;
|
|
|
|
desc->txd.phys = phys;
|
|
|
|
return desc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ioat2_free_ring_ent(struct ioat_ring_ent *desc, struct dma_chan *chan)
|
|
|
|
{
|
|
|
|
struct ioatdma_device *dma;
|
|
|
|
|
|
|
|
dma = to_ioatdma_device(chan->device);
|
|
|
|
pci_pool_free(dma->dma_pool, desc->hw, desc->txd.phys);
|
2009-09-09 00:53:04 +00:00
|
|
|
kmem_cache_free(ioat2_cache, desc);
|
2009-08-26 20:01:44 +00:00
|
|
|
}
|
|
|
|
|
2009-09-08 19:02:01 +00:00
|
|
|
static struct ioat_ring_ent **ioat2_alloc_ring(struct dma_chan *c, int order, gfp_t flags)
|
|
|
|
{
|
|
|
|
struct ioat_ring_ent **ring;
|
|
|
|
int descs = 1 << order;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (order > ioat_get_max_alloc_order())
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* allocate the array to hold the software ring */
|
|
|
|
ring = kcalloc(descs, sizeof(*ring), flags);
|
|
|
|
if (!ring)
|
|
|
|
return NULL;
|
|
|
|
for (i = 0; i < descs; i++) {
|
|
|
|
ring[i] = ioat2_alloc_ring_ent(c, flags);
|
|
|
|
if (!ring[i]) {
|
|
|
|
while (i--)
|
|
|
|
ioat2_free_ring_ent(ring[i], c);
|
|
|
|
kfree(ring);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
set_desc_id(ring[i], i);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* link descs */
|
|
|
|
for (i = 0; i < descs-1; i++) {
|
|
|
|
struct ioat_ring_ent *next = ring[i+1];
|
|
|
|
struct ioat_dma_descriptor *hw = ring[i]->hw;
|
|
|
|
|
|
|
|
hw->next = next->txd.phys;
|
|
|
|
}
|
|
|
|
ring[i]->hw->next = ring[0]->txd.phys;
|
|
|
|
|
|
|
|
return ring;
|
|
|
|
}
|
|
|
|
|
2010-07-23 22:47:56 +00:00
|
|
|
void ioat2_free_chan_resources(struct dma_chan *c);
|
|
|
|
|
2009-08-26 20:01:44 +00:00
|
|
|
/* ioat2_alloc_chan_resources - allocate/initialize ioat2 descriptor ring
|
|
|
|
* @chan: channel to be initialized
|
|
|
|
*/
|
2009-09-09 00:42:55 +00:00
|
|
|
int ioat2_alloc_chan_resources(struct dma_chan *c)
|
2009-08-26 20:01:44 +00:00
|
|
|
{
|
|
|
|
struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
|
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
|
|
|
struct ioat_ring_ent **ring;
|
2010-07-23 22:47:56 +00:00
|
|
|
u64 status;
|
2009-09-08 19:02:01 +00:00
|
|
|
int order;
|
2011-05-06 15:33:44 +00:00
|
|
|
int i = 0;
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
/* have we already been set up? */
|
|
|
|
if (ioat->ring)
|
|
|
|
return 1 << ioat->alloc_order;
|
|
|
|
|
|
|
|
/* Setup register to interrupt and write completion status on error */
|
2009-09-08 19:01:21 +00:00
|
|
|
writew(IOAT_CHANCTRL_RUN, chan->reg_base + IOAT_CHANCTRL_OFFSET);
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
/* allocate a completion writeback area */
|
|
|
|
/* doing 2 32bit writes to mmio since 1 64b write doesn't work */
|
2009-09-08 19:01:04 +00:00
|
|
|
chan->completion = pci_pool_alloc(chan->device->completion_pool,
|
|
|
|
GFP_KERNEL, &chan->completion_dma);
|
|
|
|
if (!chan->completion)
|
2009-08-26 20:01:44 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2009-09-08 19:01:04 +00:00
|
|
|
memset(chan->completion, 0, sizeof(*chan->completion));
|
|
|
|
writel(((u64) chan->completion_dma) & 0x00000000FFFFFFFF,
|
2009-08-26 20:01:44 +00:00
|
|
|
chan->reg_base + IOAT_CHANCMP_OFFSET_LOW);
|
2009-09-08 19:01:04 +00:00
|
|
|
writel(((u64) chan->completion_dma) >> 32,
|
2009-08-26 20:01:44 +00:00
|
|
|
chan->reg_base + IOAT_CHANCMP_OFFSET_HIGH);
|
|
|
|
|
2009-09-08 19:02:01 +00:00
|
|
|
order = ioat_get_alloc_order();
|
|
|
|
ring = ioat2_alloc_ring(c, order, GFP_KERNEL);
|
2009-08-26 20:01:44 +00:00
|
|
|
if (!ring)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_lock_bh(&chan->cleanup_lock);
|
|
|
|
spin_lock_bh(&ioat->prep_lock);
|
2009-08-26 20:01:44 +00:00
|
|
|
ioat->ring = ring;
|
|
|
|
ioat->head = 0;
|
|
|
|
ioat->issued = 0;
|
|
|
|
ioat->tail = 0;
|
2009-09-08 19:02:01 +00:00
|
|
|
ioat->alloc_order = order;
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_unlock_bh(&ioat->prep_lock);
|
|
|
|
spin_unlock_bh(&chan->cleanup_lock);
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
tasklet_enable(&chan->cleanup_task);
|
|
|
|
ioat2_start_null_desc(ioat);
|
|
|
|
|
2010-07-23 22:47:56 +00:00
|
|
|
/* check that we got off the ground */
|
2011-05-06 15:33:44 +00:00
|
|
|
do {
|
|
|
|
udelay(1);
|
|
|
|
status = ioat_chansts(chan);
|
|
|
|
} while (i++ < 20 && !is_ioat_active(status) && !is_ioat_idle(status));
|
|
|
|
|
2010-07-23 22:47:56 +00:00
|
|
|
if (is_ioat_active(status) || is_ioat_idle(status)) {
|
|
|
|
set_bit(IOAT_RUN, &chan->state);
|
|
|
|
return 1 << ioat->alloc_order;
|
|
|
|
} else {
|
|
|
|
u32 chanerr = readl(chan->reg_base + IOAT_CHANERR_OFFSET);
|
|
|
|
|
|
|
|
dev_WARN(to_dev(chan),
|
|
|
|
"failed to start channel chanerr: %#x\n", chanerr);
|
|
|
|
ioat2_free_chan_resources(c);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
2009-09-08 19:02:01 +00:00
|
|
|
}
|
|
|
|
|
2009-09-09 00:42:55 +00:00
|
|
|
bool reshape_ring(struct ioat2_dma_chan *ioat, int order)
|
2009-09-08 19:02:01 +00:00
|
|
|
{
|
|
|
|
/* reshape differs from normal ring allocation in that we want
|
|
|
|
* to allocate a new software ring while only
|
|
|
|
* extending/truncating the hardware ring
|
|
|
|
*/
|
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
|
|
|
struct dma_chan *c = &chan->common;
|
2012-04-04 23:10:35 +00:00
|
|
|
const u32 curr_size = ioat2_ring_size(ioat);
|
2009-09-08 19:02:01 +00:00
|
|
|
const u16 active = ioat2_ring_active(ioat);
|
2012-04-04 23:10:35 +00:00
|
|
|
const u32 new_size = 1 << order;
|
2009-09-08 19:02:01 +00:00
|
|
|
struct ioat_ring_ent **ring;
|
|
|
|
u16 i;
|
|
|
|
|
|
|
|
if (order > ioat_get_max_alloc_order())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* double check that we have at least 1 free descriptor */
|
|
|
|
if (active == curr_size)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* when shrinking, verify that we can hold the current active
|
|
|
|
* set in the new ring
|
|
|
|
*/
|
|
|
|
if (active >= new_size)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* allocate the array to hold the software ring */
|
|
|
|
ring = kcalloc(new_size, sizeof(*ring), GFP_NOWAIT);
|
|
|
|
if (!ring)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* allocate/trim descriptors as needed */
|
|
|
|
if (new_size > curr_size) {
|
|
|
|
/* copy current descriptors to the new ring */
|
|
|
|
for (i = 0; i < curr_size; i++) {
|
|
|
|
u16 curr_idx = (ioat->tail+i) & (curr_size-1);
|
|
|
|
u16 new_idx = (ioat->tail+i) & (new_size-1);
|
|
|
|
|
|
|
|
ring[new_idx] = ioat->ring[curr_idx];
|
|
|
|
set_desc_id(ring[new_idx], new_idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add new descriptors to the ring */
|
|
|
|
for (i = curr_size; i < new_size; i++) {
|
|
|
|
u16 new_idx = (ioat->tail+i) & (new_size-1);
|
|
|
|
|
|
|
|
ring[new_idx] = ioat2_alloc_ring_ent(c, GFP_NOWAIT);
|
|
|
|
if (!ring[new_idx]) {
|
|
|
|
while (i--) {
|
|
|
|
u16 new_idx = (ioat->tail+i) & (new_size-1);
|
|
|
|
|
|
|
|
ioat2_free_ring_ent(ring[new_idx], c);
|
|
|
|
}
|
|
|
|
kfree(ring);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
set_desc_id(ring[new_idx], new_idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* hw link new descriptors */
|
|
|
|
for (i = curr_size-1; i < new_size; i++) {
|
|
|
|
u16 new_idx = (ioat->tail+i) & (new_size-1);
|
|
|
|
struct ioat_ring_ent *next = ring[(new_idx+1) & (new_size-1)];
|
|
|
|
struct ioat_dma_descriptor *hw = ring[new_idx]->hw;
|
|
|
|
|
|
|
|
hw->next = next->txd.phys;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct ioat_dma_descriptor *hw;
|
|
|
|
struct ioat_ring_ent *next;
|
|
|
|
|
|
|
|
/* copy current descriptors to the new ring, dropping the
|
|
|
|
* removed descriptors
|
|
|
|
*/
|
|
|
|
for (i = 0; i < new_size; i++) {
|
|
|
|
u16 curr_idx = (ioat->tail+i) & (curr_size-1);
|
|
|
|
u16 new_idx = (ioat->tail+i) & (new_size-1);
|
|
|
|
|
|
|
|
ring[new_idx] = ioat->ring[curr_idx];
|
|
|
|
set_desc_id(ring[new_idx], new_idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* free deleted descriptors */
|
|
|
|
for (i = new_size; i < curr_size; i++) {
|
|
|
|
struct ioat_ring_ent *ent;
|
|
|
|
|
|
|
|
ent = ioat2_get_ring_ent(ioat, ioat->tail+i);
|
|
|
|
ioat2_free_ring_ent(ent, c);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fix up hardware ring */
|
|
|
|
hw = ring[(ioat->tail+new_size-1) & (new_size-1)]->hw;
|
|
|
|
next = ring[(ioat->tail+new_size) & (new_size-1)];
|
|
|
|
hw->next = next->txd.phys;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(to_dev(chan), "%s: allocated %d descriptors\n",
|
|
|
|
__func__, new_size);
|
|
|
|
|
|
|
|
kfree(ioat->ring);
|
|
|
|
ioat->ring = ring;
|
|
|
|
ioat->alloc_order = order;
|
|
|
|
|
|
|
|
return true;
|
2009-08-26 20:01:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-05-01 22:22:55 +00:00
|
|
|
* ioat2_check_space_lock - verify space and grab ring producer lock
|
2009-08-26 20:01:44 +00:00
|
|
|
* @ioat: ioat2,3 channel (ring) to operate on
|
|
|
|
* @num_descs: allocation length
|
|
|
|
*/
|
2010-05-01 22:22:55 +00:00
|
|
|
int ioat2_check_space_lock(struct ioat2_dma_chan *ioat, int num_descs)
|
2009-08-26 20:01:44 +00:00
|
|
|
{
|
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
2010-05-01 22:22:55 +00:00
|
|
|
bool retry;
|
2009-08-26 20:01:44 +00:00
|
|
|
|
2010-05-01 22:22:55 +00:00
|
|
|
retry:
|
|
|
|
spin_lock_bh(&ioat->prep_lock);
|
2009-09-08 19:02:01 +00:00
|
|
|
/* never allow the last descriptor to be consumed, we need at
|
|
|
|
* least one free at all times to allow for on-the-fly ring
|
|
|
|
* resizing.
|
|
|
|
*/
|
2010-05-01 22:22:55 +00:00
|
|
|
if (likely(ioat2_ring_space(ioat) > num_descs)) {
|
|
|
|
dev_dbg(to_dev(chan), "%s: num_descs: %d (%x:%x:%x)\n",
|
|
|
|
__func__, num_descs, ioat->head, ioat->tail, ioat->issued);
|
|
|
|
ioat->produce = num_descs;
|
|
|
|
return 0; /* with ioat->prep_lock held */
|
2009-08-26 20:01:44 +00:00
|
|
|
}
|
2010-05-01 22:22:55 +00:00
|
|
|
retry = test_and_set_bit(IOAT_RESHAPE_PENDING, &chan->state);
|
|
|
|
spin_unlock_bh(&ioat->prep_lock);
|
2009-08-26 20:01:44 +00:00
|
|
|
|
2010-05-01 22:22:55 +00:00
|
|
|
/* is another cpu already trying to expand the ring? */
|
|
|
|
if (retry)
|
|
|
|
goto retry;
|
2009-08-26 20:01:44 +00:00
|
|
|
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_lock_bh(&chan->cleanup_lock);
|
|
|
|
spin_lock_bh(&ioat->prep_lock);
|
|
|
|
retry = reshape_ring(ioat, ioat->alloc_order + 1);
|
|
|
|
clear_bit(IOAT_RESHAPE_PENDING, &chan->state);
|
|
|
|
spin_unlock_bh(&ioat->prep_lock);
|
|
|
|
spin_unlock_bh(&chan->cleanup_lock);
|
|
|
|
|
|
|
|
/* if we were able to expand the ring retry the allocation */
|
|
|
|
if (retry)
|
|
|
|
goto retry;
|
|
|
|
|
|
|
|
if (printk_ratelimit())
|
|
|
|
dev_dbg(to_dev(chan), "%s: ring full! num_descs: %d (%x:%x:%x)\n",
|
|
|
|
__func__, num_descs, ioat->head, ioat->tail, ioat->issued);
|
|
|
|
|
|
|
|
/* progress reclaim in the allocation failure case we may be
|
|
|
|
* called under bh_disabled so we need to trigger the timer
|
|
|
|
* event directly
|
|
|
|
*/
|
|
|
|
if (jiffies > chan->timer.expires && timer_pending(&chan->timer)) {
|
|
|
|
struct ioatdma_device *device = chan->device;
|
|
|
|
|
|
|
|
mod_timer(&chan->timer, jiffies + COMPLETION_TIMEOUT);
|
|
|
|
device->timer_fn((unsigned long) &chan->common);
|
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOMEM;
|
2009-08-26 20:01:44 +00:00
|
|
|
}
|
|
|
|
|
2009-09-09 00:42:55 +00:00
|
|
|
struct dma_async_tx_descriptor *
|
2009-08-26 20:01:44 +00:00
|
|
|
ioat2_dma_prep_memcpy_lock(struct dma_chan *c, dma_addr_t dma_dest,
|
|
|
|
dma_addr_t dma_src, size_t len, unsigned long flags)
|
|
|
|
{
|
|
|
|
struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
|
|
|
|
struct ioat_dma_descriptor *hw;
|
|
|
|
struct ioat_ring_ent *desc;
|
|
|
|
dma_addr_t dst = dma_dest;
|
|
|
|
dma_addr_t src = dma_src;
|
|
|
|
size_t total_len = len;
|
2010-05-01 22:22:55 +00:00
|
|
|
int num_descs, idx, i;
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
num_descs = ioat2_xferlen_to_descs(ioat, len);
|
2010-05-01 22:22:55 +00:00
|
|
|
if (likely(num_descs) && ioat2_check_space_lock(ioat, num_descs) == 0)
|
|
|
|
idx = ioat->head;
|
2009-08-26 20:01:44 +00:00
|
|
|
else
|
|
|
|
return NULL;
|
2009-09-21 16:17:58 +00:00
|
|
|
i = 0;
|
|
|
|
do {
|
2009-08-26 20:01:44 +00:00
|
|
|
size_t copy = min_t(size_t, len, 1 << ioat->xfercap_log);
|
|
|
|
|
|
|
|
desc = ioat2_get_ring_ent(ioat, idx + i);
|
|
|
|
hw = desc->hw;
|
|
|
|
|
|
|
|
hw->size = copy;
|
|
|
|
hw->ctl = 0;
|
|
|
|
hw->src_addr = src;
|
|
|
|
hw->dst_addr = dst;
|
|
|
|
|
|
|
|
len -= copy;
|
|
|
|
dst += copy;
|
|
|
|
src += copy;
|
2009-09-08 19:00:55 +00:00
|
|
|
dump_desc_dbg(ioat, desc);
|
2009-09-21 16:17:58 +00:00
|
|
|
} while (++i < num_descs);
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
desc->txd.flags = flags;
|
|
|
|
desc->len = total_len;
|
|
|
|
hw->ctl_f.int_en = !!(flags & DMA_PREP_INTERRUPT);
|
2009-09-09 00:42:53 +00:00
|
|
|
hw->ctl_f.fence = !!(flags & DMA_PREP_FENCE);
|
2009-08-26 20:01:44 +00:00
|
|
|
hw->ctl_f.compl_write = 1;
|
2009-09-08 19:00:55 +00:00
|
|
|
dump_desc_dbg(ioat, desc);
|
2009-08-26 20:01:44 +00:00
|
|
|
/* we leave the channel locked to ensure in order submission */
|
|
|
|
|
|
|
|
return &desc->txd;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ioat2_free_chan_resources - release all the descriptors
|
|
|
|
* @chan: the channel to be cleaned
|
|
|
|
*/
|
2009-09-09 00:42:55 +00:00
|
|
|
void ioat2_free_chan_resources(struct dma_chan *c)
|
2009-08-26 20:01:44 +00:00
|
|
|
{
|
|
|
|
struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
|
|
|
|
struct ioat_chan_common *chan = &ioat->base;
|
2009-09-09 00:42:55 +00:00
|
|
|
struct ioatdma_device *device = chan->device;
|
2009-08-26 20:01:44 +00:00
|
|
|
struct ioat_ring_ent *desc;
|
|
|
|
const u16 total_descs = 1 << ioat->alloc_order;
|
|
|
|
int descs;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Before freeing channel resources first check
|
|
|
|
* if they have been previously allocated for this channel.
|
|
|
|
*/
|
|
|
|
if (!ioat->ring)
|
|
|
|
return;
|
|
|
|
|
|
|
|
tasklet_disable(&chan->cleanup_task);
|
2009-09-08 19:01:49 +00:00
|
|
|
del_timer_sync(&chan->timer);
|
2010-03-04 04:21:13 +00:00
|
|
|
device->cleanup_fn((unsigned long) c);
|
2009-12-19 22:36:02 +00:00
|
|
|
device->reset_hw(chan);
|
2010-07-23 22:47:56 +00:00
|
|
|
clear_bit(IOAT_RUN, &chan->state);
|
2009-08-26 20:01:44 +00:00
|
|
|
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_lock_bh(&chan->cleanup_lock);
|
|
|
|
spin_lock_bh(&ioat->prep_lock);
|
2009-08-26 20:01:44 +00:00
|
|
|
descs = ioat2_ring_space(ioat);
|
2009-09-08 19:00:55 +00:00
|
|
|
dev_dbg(to_dev(chan), "freeing %d idle descriptors\n", descs);
|
2009-08-26 20:01:44 +00:00
|
|
|
for (i = 0; i < descs; i++) {
|
|
|
|
desc = ioat2_get_ring_ent(ioat, ioat->head + i);
|
|
|
|
ioat2_free_ring_ent(desc, c);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (descs < total_descs)
|
|
|
|
dev_err(to_dev(chan), "Freeing %d in use descriptors!\n",
|
|
|
|
total_descs - descs);
|
|
|
|
|
|
|
|
for (i = 0; i < total_descs - descs; i++) {
|
|
|
|
desc = ioat2_get_ring_ent(ioat, ioat->tail + i);
|
2009-09-08 19:00:55 +00:00
|
|
|
dump_desc_dbg(ioat, desc);
|
2009-08-26 20:01:44 +00:00
|
|
|
ioat2_free_ring_ent(desc, c);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(ioat->ring);
|
|
|
|
ioat->ring = NULL;
|
|
|
|
ioat->alloc_order = 0;
|
2009-09-09 00:42:55 +00:00
|
|
|
pci_pool_free(device->completion_pool, chan->completion,
|
2009-09-08 19:01:04 +00:00
|
|
|
chan->completion_dma);
|
2010-05-01 22:22:55 +00:00
|
|
|
spin_unlock_bh(&ioat->prep_lock);
|
|
|
|
spin_unlock_bh(&chan->cleanup_lock);
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
chan->last_completion = 0;
|
2009-09-08 19:01:04 +00:00
|
|
|
chan->completion_dma = 0;
|
2009-08-26 20:01:44 +00:00
|
|
|
ioat->dmacount = 0;
|
|
|
|
}
|
|
|
|
|
2009-09-09 00:42:56 +00:00
|
|
|
static ssize_t ring_size_show(struct dma_chan *c, char *page)
|
|
|
|
{
|
|
|
|
struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
|
|
|
|
|
|
|
|
return sprintf(page, "%d\n", (1 << ioat->alloc_order) & ~1);
|
|
|
|
}
|
|
|
|
static struct ioat_sysfs_entry ring_size_attr = __ATTR_RO(ring_size);
|
|
|
|
|
|
|
|
static ssize_t ring_active_show(struct dma_chan *c, char *page)
|
|
|
|
{
|
|
|
|
struct ioat2_dma_chan *ioat = to_ioat2_chan(c);
|
|
|
|
|
|
|
|
/* ...taken outside the lock, no need to be precise */
|
|
|
|
return sprintf(page, "%d\n", ioat2_ring_active(ioat));
|
|
|
|
}
|
|
|
|
static struct ioat_sysfs_entry ring_active_attr = __ATTR_RO(ring_active);
|
|
|
|
|
|
|
|
static struct attribute *ioat2_attrs[] = {
|
|
|
|
&ring_size_attr.attr,
|
|
|
|
&ring_active_attr.attr,
|
|
|
|
&ioat_cap_attr.attr,
|
|
|
|
&ioat_version_attr.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct kobj_type ioat2_ktype = {
|
|
|
|
.sysfs_ops = &ioat_sysfs_ops,
|
|
|
|
.default_attrs = ioat2_attrs,
|
|
|
|
};
|
|
|
|
|
2012-12-21 23:09:59 +00:00
|
|
|
int ioat2_dma_probe(struct ioatdma_device *device, int dca)
|
2009-08-26 20:01:44 +00:00
|
|
|
{
|
|
|
|
struct pci_dev *pdev = device->pdev;
|
|
|
|
struct dma_device *dma;
|
|
|
|
struct dma_chan *c;
|
|
|
|
struct ioat_chan_common *chan;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
device->enumerate_channels = ioat2_enumerate_channels;
|
2009-12-19 22:36:02 +00:00
|
|
|
device->reset_hw = ioat2_reset_hw;
|
2010-03-04 04:21:13 +00:00
|
|
|
device->cleanup_fn = ioat2_cleanup_event;
|
2009-09-09 00:42:55 +00:00
|
|
|
device->timer_fn = ioat2_timer_event;
|
2009-09-09 00:42:58 +00:00
|
|
|
device->self_test = ioat_dma_self_test;
|
2009-08-26 20:01:44 +00:00
|
|
|
dma = &device->common;
|
|
|
|
dma->device_prep_dma_memcpy = ioat2_dma_prep_memcpy_lock;
|
|
|
|
dma->device_issue_pending = ioat2_issue_pending;
|
|
|
|
dma->device_alloc_chan_resources = ioat2_alloc_chan_resources;
|
|
|
|
dma->device_free_chan_resources = ioat2_free_chan_resources;
|
2010-10-13 22:43:10 +00:00
|
|
|
dma->device_tx_status = ioat_dma_tx_status;
|
2009-08-26 20:01:44 +00:00
|
|
|
|
|
|
|
err = ioat_probe(device);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
ioat_set_tcp_copy_break(2048);
|
|
|
|
|
|
|
|
list_for_each_entry(c, &dma->channels, device_node) {
|
|
|
|
chan = to_chan_common(c);
|
|
|
|
writel(IOAT_DCACTRL_CMPL_WRITE_ENABLE | IOAT_DMA_DCA_ANY_CPU,
|
|
|
|
chan->reg_base + IOAT_DCACTRL_OFFSET);
|
|
|
|
}
|
|
|
|
|
|
|
|
err = ioat_register(device);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2009-09-09 00:42:56 +00:00
|
|
|
|
|
|
|
ioat_kobject_add(device, &ioat2_ktype);
|
|
|
|
|
2009-08-26 20:01:44 +00:00
|
|
|
if (dca)
|
|
|
|
device->dca = ioat2_dca_init(pdev, device->reg_base);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|