drivers/dma/ioat/dma.c

   1 /*
   2  * Intel I/OAT DMA Linux driver
   3  * Copyright(c) 2004 - 2015 Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * The full GNU General Public License is included in this distribution in
  15  * the file called "COPYING".
  16  *
  17  */
  18
  19 /*
  20  * This driver supports an Intel I/OAT DMA engine, which does asynchronous
  21  * copy operations.
  22  */
  23
  24 #include <linux/init.h>
  25 #include <linux/module.h>
  26 #include <linux/slab.h>
  27 #include <linux/pci.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/dmaengine.h>
  30 #include <linux/delay.h>
  31 #include <linux/dma-mapping.h>
  32 #include <linux/workqueue.h>
  33 #include <linux/prefetch.h>
  34 #include <linux/sizes.h>
  35 #include "dma.h"
  36 #include "registers.h"
  37 #include "hw.h"
  38
  39 #include "../dmaengine.h"
  40
  41 int completion_timeout = 200;
  42 module_param(completion_timeout, int, 0644);
  43 MODULE_PARM_DESC(completion_timeout,
  44                 "set ioat completion timeout [msec] (default 200 [msec])");
  45 int idle_timeout = 2000;
  46 module_param(idle_timeout, int, 0644);
  47 MODULE_PARM_DESC(idle_timeout,
  48                 "set ioat idel timeout [msec] (default 2000 [msec])");
  49
  50 #define IDLE_TIMEOUT msecs_to_jiffies(idle_timeout)
  51 #define COMPLETION_TIMEOUT msecs_to_jiffies(completion_timeout)
  52
  53 static char *chanerr_str[] = {
  54         "DMA Transfer Source Address Error",
  55         "DMA Transfer Destination Address Error",
  56         "Next Descriptor Address Error",
  57         "Descriptor Error",
  58         "Chan Address Value Error",
  59         "CHANCMD Error",
  60         "Chipset Uncorrectable Data Integrity Error",
  61         "DMA Uncorrectable Data Integrity Error",
  62         "Read Data Error",
  63         "Write Data Error",
  64         "Descriptor Control Error",
  65         "Descriptor Transfer Size Error",
  66         "Completion Address Error",
  67         "Interrupt Configuration Error",
  68         "Super extended descriptor Address Error",
  69         "Unaffiliated Error",
  70         "CRC or XOR P Error",
  71         "XOR Q Error",
  72         "Descriptor Count Error",
  73         "DIF All F detect Error",
  74         "Guard Tag verification Error",
  75         "Application Tag verification Error",
  76         "Reference Tag verification Error",
  77         "Bundle Bit Error",
  78         "Result DIF All F detect Error",
  79         "Result Guard Tag verification Error",
  80         "Result Application Tag verification Error",
  81         "Result Reference Tag verification Error",
  82 };
  83
  84 static void ioat_eh(struct ioatdma_chan *ioat_chan);
  85
  86 static void ioat_print_chanerrs(struct ioatdma_chan *ioat_chan, u32 chanerr)
  87 {
  88         int i;
  89
  90         for (i = 0; i < ARRAY_SIZE(chanerr_str); i++) {
  91                 if ((chanerr >> i) & 1) {
  92                         dev_err(to_dev(ioat_chan), "Err(%d): %s\n",
  93                                 i, chanerr_str[i]);
  94                 }
  95         }
  96 }
  97
  98 /**
  99  * ioat_dma_do_interrupt - handler used for single vector interrupt mode
 100  * @irq: interrupt id
 101  * @data: interrupt data
 102  */
 103 irqreturn_t ioat_dma_do_interrupt(int irq, void *data)
 104 {
 105         struct ioatdma_device *instance = data;
 106         struct ioatdma_chan *ioat_chan;
 107         unsigned long attnstatus;
 108         int bit;
 109         u8 intrctrl;
 110
 111         intrctrl = readb(instance->reg_base + IOAT_INTRCTRL_OFFSET);
 112
 113         if (!(intrctrl & IOAT_INTRCTRL_MASTER_INT_EN))
 114                 return IRQ_NONE;
 115
 116         if (!(intrctrl & IOAT_INTRCTRL_INT_STATUS)) {
 117                 writeb(intrctrl, instance->reg_base + IOAT_INTRCTRL_OFFSET);
 118                 return IRQ_NONE;
 119         }
 120
 121         attnstatus = readl(instance->reg_base + IOAT_ATTNSTATUS_OFFSET);
 122         for_each_set_bit(bit, &attnstatus, BITS_PER_LONG) {
 123                 ioat_chan = ioat_chan_by_index(instance, bit);
 124                 if (test_bit(IOAT_RUN, &ioat_chan->state))
 125                         tasklet_schedule(&ioat_chan->cleanup_task);
 126         }
 127
 128         writeb(intrctrl, instance->reg_base + IOAT_INTRCTRL_OFFSET);
 129         return IRQ_HANDLED;
 130 }
 131
 132 /**
 133  * ioat_dma_do_interrupt_msix - handler used for vector-per-channel interrupt mode
 134  * @irq: interrupt id
 135  * @data: interrupt data
 136  */
 137 irqreturn_t ioat_dma_do_interrupt_msix(int irq, void *data)
 138 {
 139         struct ioatdma_chan *ioat_chan = data;
 140
 141         if (test_bit(IOAT_RUN, &ioat_chan->state))
 142                 tasklet_schedule(&ioat_chan->cleanup_task);
 143
 144         return IRQ_HANDLED;
 145 }
 146
 147 void ioat_stop(struct ioatdma_chan *ioat_chan)
 148 {
 149         struct ioatdma_device *ioat_dma = ioat_chan->ioat_dma;
 150         struct pci_dev *pdev = ioat_dma->pdev;
 151         int chan_id = chan_num(ioat_chan);
 152         struct msix_entry *msix;
 153
 154         /* 1/ stop irq from firing tasklets
 155          * 2/ stop the tasklet from re-arming irqs
 156          */
 157         clear_bit(IOAT_RUN, &ioat_chan->state);
 158
 159         /* flush inflight interrupts */
 160         switch (ioat_dma->irq_mode) {
 161         case IOAT_MSIX:
 162                 msix = &ioat_dma->msix_entries[chan_id];
 163                 synchronize_irq(msix->vector);
 164                 break;
 165         case IOAT_MSI:
 166         case IOAT_INTX:
 167                 synchronize_irq(pdev->irq);
 168                 break;
 169         default:
 170                 break;
 171         }
 172
 173         /* flush inflight timers */
 174         del_timer_sync(&ioat_chan->timer);
 175
 176         /* flush inflight tasklet runs */
 177         tasklet_kill(&ioat_chan->cleanup_task);
 178
 179         /* final cleanup now that everything is quiesced and can't re-arm */
 180         ioat_cleanup_event((unsigned long)&ioat_chan->dma_chan);
 181 }
 182
 183 static void __ioat_issue_pending(struct ioatdma_chan *ioat_chan)
 184 {
 185         ioat_chan->dmacount += ioat_ring_pending(ioat_chan);
 186         ioat_chan->issued = ioat_chan->head;
 187         writew(ioat_chan->dmacount,
 188                ioat_chan->reg_base + IOAT_CHAN_DMACOUNT_OFFSET);
 189         dev_dbg(to_dev(ioat_chan),
 190                 "%s: head: %#x tail: %#x issued: %#x count: %#x\n",
 191                 __func__, ioat_chan->head, ioat_chan->tail,
 192                 ioat_chan->issued, ioat_chan->dmacount);
 193 }
 194
 195 void ioat_issue_pending(struct dma_chan *c)
 196 {
 197         struct ioatdma_chan *ioat_chan = to_ioat_chan(c);
 198
 199         if (ioat_ring_pending(ioat_chan)) {
 200                 spin_lock_bh(&ioat_chan->prep_lock);
 201                 __ioat_issue_pending(ioat_chan);
 202                 spin_unlock_bh(&ioat_chan->prep_lock);
 203         }
 204 }
 205
 206 /**
 207  * ioat_update_pending - log pending descriptors
 208  * @ioat: ioat+ channel
 209  *
 210  * Check if the number of unsubmitted descriptors has exceeded the
 211  * watermark.  Called with prep_lock held
 212  */
 213 static void ioat_update_pending(struct ioatdma_chan *ioat_chan)
 214 {
 215         if (ioat_ring_pending(ioat_chan) > ioat_pending_level)
 216                 __ioat_issue_pending(ioat_chan);
 217 }
 218
 219 static void __ioat_start_null_desc(struct ioatdma_chan *ioat_chan)
 220 {
 221         struct ioat_ring_ent *desc;
 222         struct ioat_dma_descriptor *hw;
 223
 224         if (ioat_ring_space(ioat_chan) < 1) {
 225                 dev_err(to_dev(ioat_chan),
 226                         "Unable to start null desc - ring full\n");
 227                 return;
 228         }
 229
 230         dev_dbg(to_dev(ioat_chan),
 231                 "%s: head: %#x tail: %#x issued: %#x\n",
 232                 __func__, ioat_chan->head, ioat_chan->tail, ioat_chan->issued);
 233         desc = ioat_get_ring_ent(ioat_chan, ioat_chan->head);
 234
 235         hw = desc->hw;
 236         hw->ctl = 0;
 237         hw->ctl_f.null = 1;
 238         hw->ctl_f.int_en = 1;
 239         hw->ctl_f.compl_write = 1;
 240         /* set size to non-zero value (channel returns error when size is 0) */
 241         hw->size = NULL_DESC_BUFFER_SIZE;
 242         hw->src_addr = 0;
 243         hw->dst_addr = 0;
 244         async_tx_ack(&desc->txd);
 245         ioat_set_chainaddr(ioat_chan, desc->txd.phys);
 246         dump_desc_dbg(ioat_chan, desc);
 247         /* make sure descriptors are written before we submit */
 248         wmb();
 249         ioat_chan->head += 1;
 250         __ioat_issue_pending(ioat_chan);
 251 }
 252
 253 void ioat_start_null_desc(struct ioatdma_chan *ioat_chan)
 254 {
 255         spin_lock_bh(&ioat_chan->prep_lock);
 256         if (!test_bit(IOAT_CHAN_DOWN, &ioat_chan->state))
 257                 __ioat_start_null_desc(ioat_chan);
 258         spin_unlock_bh(&ioat_chan->prep_lock);
 259 }
 260
 261 static void __ioat_restart_chan(struct ioatdma_chan *ioat_chan)
 262 {
 263         /* set the tail to be re-issued */
 264         ioat_chan->issued = ioat_chan->tail;
 265         ioat_chan->dmacount = 0;
 266         mod_timer(&ioat_chan->timer, jiffies + COMPLETION_TIMEOUT);
 267
 268         dev_dbg(to_dev(ioat_chan),
 269                 "%s: head: %#x tail: %#x issued: %#x count: %#x\n",
 270                 __func__, ioat_chan->head, ioat_chan->tail,
 271                 ioat_chan->issued, ioat_chan->dmacount);
 272
 273         if (ioat_ring_pending(ioat_chan)) {
 274                 struct ioat_ring_ent *desc;
 275
 276                 desc = ioat_get_ring_ent(ioat_chan, ioat_chan->tail);
 277                 ioat_set_chainaddr(ioat_chan, desc->txd.phys);
 278                 __ioat_issue_pending(ioat_chan);
 279         } else
 280                 __ioat_start_null_desc(ioat_chan);
 281 }
 282
 283 static int ioat_quiesce(struct ioatdma_chan *ioat_chan, unsigned long tmo)
 284 {
 285         unsigned long end = jiffies + tmo;
 286         int err = 0;
 287         u32 status;
 288
 289         status = ioat_chansts(ioat_chan);
 290         if (is_ioat_active(status) || is_ioat_idle(status))
 291                 ioat_suspend(ioat_chan);
 292         while (is_ioat_active(status) || is_ioat_idle(status)) {
 293                 if (tmo && time_after(jiffies, end)) {
 294                         err = -ETIMEDOUT;
 295                         break;
 296                 }
 297                 status = ioat_chansts(ioat_chan);
 298                 cpu_relax();
 299         }
 300
 301         return err;
 302 }
 303
 304 static int ioat_reset_sync(struct ioatdma_chan *ioat_chan, unsigned long tmo)
 305 {
 306         unsigned long end = jiffies + tmo;
 307         int err = 0;
 308
 309         ioat_reset(ioat_chan);
 310         while (ioat_reset_pending(ioat_chan)) {
 311                 if (end && time_after(jiffies, end)) {
 312                         err = -ETIMEDOUT;
 313                         break;
 314                 }
 315                 cpu_relax();
 316         }
 317
 318         return err;
 319 }
 320
 321 static dma_cookie_t ioat_tx_submit_unlock(struct dma_async_tx_descriptor *tx)
 322         __releases(&ioat_chan->prep_lock)
 323 {
 324         struct dma_chan *c = tx->chan;
 325         struct ioatdma_chan *ioat_chan = to_ioat_chan(c);
 326         dma_cookie_t cookie;
 327
 328         cookie = dma_cookie_assign(tx);
 329         dev_dbg(to_dev(ioat_chan), "%s: cookie: %d\n", __func__, cookie);
 330
 331         if (!test_and_set_bit(IOAT_CHAN_ACTIVE, &ioat_chan->state))
 332                 mod_timer(&ioat_chan->timer, jiffies + COMPLETION_TIMEOUT);
 333
 334         /* make descriptor updates visible before advancing ioat->head,
 335          * this is purposefully not smp_wmb() since we are also
 336          * publishing the descriptor updates to a dma device
 337          */
 338         wmb();
 339
 340         ioat_chan->head += ioat_chan->produce;
 341
 342         ioat_update_pending(ioat_chan);
 343         spin_unlock_bh(&ioat_chan->prep_lock);
 344
 345         return cookie;
 346 }
 347
 348 static struct ioat_ring_ent *
 349 ioat_alloc_ring_ent(struct dma_chan *chan, int idx, gfp_t flags)
 350 {
 351         struct ioat_dma_descriptor *hw;
 352         struct ioat_ring_ent *desc;
 353         struct ioatdma_chan *ioat_chan = to_ioat_chan(chan);
 354         int chunk;
 355         dma_addr_t phys;
 356         u8 *pos;
 357         off_t offs;
 358
 359         chunk = idx / IOAT_DESCS_PER_2M;
 360         idx &= (IOAT_DESCS_PER_2M - 1);
 361         offs = idx * IOAT_DESC_SZ;
 362         pos = (u8 *)ioat_chan->descs[chunk].virt + offs;
 363         phys = ioat_chan->descs[chunk].hw + offs;
 364         hw = (struct ioat_dma_descriptor *)pos;
 365         memset(hw, 0, sizeof(*hw));
 366
 367         desc = kmem_cache_zalloc(ioat_cache, flags);
 368         if (!desc)
 369                 return NULL;
 370
 371         dma_async_tx_descriptor_init(&desc->txd, chan);
 372         desc->txd.tx_submit = ioat_tx_submit_unlock;
 373         desc->hw = hw;
 374         desc->txd.phys = phys;
 375         return desc;
 376 }
 377
 378 void ioat_free_ring_ent(struct ioat_ring_ent *desc, struct dma_chan *chan)
 379 {
 380         kmem_cache_free(ioat_cache, desc);
 381 }
 382
 383 struct ioat_ring_ent **
 384 ioat_alloc_ring(struct dma_chan *c, int order, gfp_t flags)
 385 {
 386         struct ioatdma_chan *ioat_chan = to_ioat_chan(c);
 387         struct ioat_ring_ent **ring;
 388         int total_descs = 1 << order;
 389         int i, chunks;
 390
 391         /* allocate the array to hold the software ring */
 392         ring = kcalloc(total_descs, sizeof(*ring), flags);
 393         if (!ring)
 394                 return NULL;
 395
 396         ioat_chan->desc_chunks = chunks = (total_descs * IOAT_DESC_SZ) / SZ_2M;
 397
 398         for (i = 0; i < chunks; i++) {
 399                 struct ioat_descs *descs = &ioat_chan->descs[i];
 400
 401                 descs->virt = dma_alloc_coherent(to_dev(ioat_chan),
 402                                                  SZ_2M, &descs->hw, flags);
 403                 if (!descs->virt) {
 404                         int idx;
 405
 406                         for (idx = 0; idx < i; idx++) {
 407                                 descs = &ioat_chan->descs[idx];
 408                                 dma_free_coherent(to_dev(ioat_chan), SZ_2M,
 409                                                   descs->virt, descs->hw);
 410                                 descs->virt = NULL;
 411                                 descs->hw = 0;
 412                         }
 413
 414                         ioat_chan->desc_chunks = 0;
 415                         kfree(ring);
 416                         return NULL;
 417                 }
 418         }
 419
 420         for (i = 0; i < total_descs; i++) {
 421                 ring[i] = ioat_alloc_ring_ent(c, i, flags);
 422                 if (!ring[i]) {
 423                         int idx;
 424
 425                         while (i--)
 426                                 ioat_free_ring_ent(ring[i], c);
 427
 428                         for (idx = 0; idx < ioat_chan->desc_chunks; idx++) {
 429                                 dma_free_coherent(to_dev(ioat_chan),
 430                                                   SZ_2M,
 431                                                   ioat_chan->descs[idx].virt,
 432                                                   ioat_chan->descs[idx].hw);
 433                                 ioat_chan->descs[idx].virt = NULL;
 434                                 ioat_chan->descs[idx].hw = 0;
 435                         }
 436
 437                         ioat_chan->desc_chunks = 0;
 438                         kfree(ring);
 439                         return NULL;
 440                 }
 441                 set_desc_id(ring[i], i);
 442         }
 443
 444         /* link descs */
 445         for (i = 0; i < total_descs-1; i++) {
 446                 struct ioat_ring_ent *next = ring[i+1];
 447                 struct ioat_dma_descriptor *hw = ring[i]->hw;
 448
 449                 hw->next = next->txd.phys;
 450         }
 451         ring[i]->hw->next = ring[0]->txd.phys;
 452
 453         return ring;
 454 }
 455
 456 /**
 457  * ioat_check_space_lock - verify space and grab ring producer lock
 458  * @ioat: ioat,3 channel (ring) to operate on
 459  * @num_descs: allocation length
 460  */
 461 int ioat_check_space_lock(struct ioatdma_chan *ioat_chan, int num_descs)
 462         __acquires(&ioat_chan->prep_lock)
 463 {
 464         spin_lock_bh(&ioat_chan->prep_lock);
 465         /* never allow the last descriptor to be consumed, we need at
 466          * least one free at all times to allow for on-the-fly ring
 467          * resizing.
 468          */
 469         if (likely(ioat_ring_space(ioat_chan) > num_descs)) {
 470                 dev_dbg(to_dev(ioat_chan), "%s: num_descs: %d (%x:%x:%x)\n",
 471                         __func__, num_descs, ioat_chan->head,
 472                         ioat_chan->tail, ioat_chan->issued);
 473                 ioat_chan->produce = num_descs;
 474                 return 0;  /* with ioat->prep_lock held */
 475         }
 476         spin_unlock_bh(&ioat_chan->prep_lock);
 477
 478         dev_dbg_ratelimited(to_dev(ioat_chan),
 479                             "%s: ring full! num_descs: %d (%x:%x:%x)\n",
 480                             __func__, num_descs, ioat_chan->head,
 481                             ioat_chan->tail, ioat_chan->issued);
 482
 483         /* progress reclaim in the allocation failure case we may be
 484          * called under bh_disabled so we need to trigger the timer
 485          * event directly
 486          */
 487         if (time_is_before_jiffies(ioat_chan->timer.expires)
 488             && timer_pending(&ioat_chan->timer)) {
 489                 mod_timer(&ioat_chan->timer, jiffies + COMPLETION_TIMEOUT);
 490                 ioat_timer_event(&ioat_chan->timer);
 491         }
 492
 493         return -ENOMEM;
 494 }
 495
 496 static bool desc_has_ext(struct ioat_ring_ent *desc)
 497 {
 498         struct ioat_dma_descriptor *hw = desc->hw;
 499
 500         if (hw->ctl_f.op == IOAT_OP_XOR ||
 501             hw->ctl_f.op == IOAT_OP_XOR_VAL) {
 502                 struct ioat_xor_descriptor *xor = desc->xor;
 503
 504                 if (src_cnt_to_sw(xor->ctl_f.src_cnt) > 5)
 505                         return true;
 506         } else if (hw->ctl_f.op == IOAT_OP_PQ ||
 507                    hw->ctl_f.op == IOAT_OP_PQ_VAL) {
 508                 struct ioat_pq_descriptor *pq = desc->pq;
 509
 510                 if (src_cnt_to_sw(pq->ctl_f.src_cnt) > 3)
 511                         return true;
 512         }
 513
 514         return false;
 515 }
 516
 517 static void
 518 ioat_free_sed(struct ioatdma_device *ioat_dma, struct ioat_sed_ent *sed)
 519 {
 520         if (!sed)
 521                 return;
 522
 523         dma_pool_free(ioat_dma->sed_hw_pool[sed->hw_pool], sed->hw, sed->dma);
 524         kmem_cache_free(ioat_sed_cache, sed);
 525 }
 526
 527 static u64 ioat_get_current_completion(struct ioatdma_chan *ioat_chan)
 528 {
 529         u64 phys_complete;
 530         u64 completion;
 531
 532         completion = *ioat_chan->completion;
 533         phys_complete = ioat_chansts_to_addr(completion);
 534
 535         dev_dbg(to_dev(ioat_chan), "%s: phys_complete: %#llx\n", __func__,
 536                 (unsigned long long) phys_complete);
 537
 538         return phys_complete;
 539 }
 540
 541 static bool ioat_cleanup_preamble(struct ioatdma_chan *ioat_chan,
 542                                    u64 *phys_complete)
 543 {
 544         *phys_complete = ioat_get_current_completion(ioat_chan);
 545         if (*phys_complete == ioat_chan->last_completion)
 546                 return false;
 547
 548         clear_bit(IOAT_COMPLETION_ACK, &ioat_chan->state);
 549         mod_timer(&ioat_chan->timer, jiffies + COMPLETION_TIMEOUT);
 550
 551         return true;
 552 }
 553
 554 static void
 555 desc_get_errstat(struct ioatdma_chan *ioat_chan, struct ioat_ring_ent *desc)
 556 {
 557         struct ioat_dma_descriptor *hw = desc->hw;
 558
 559         switch (hw->ctl_f.op) {
 560         case IOAT_OP_PQ_VAL:
 561         case IOAT_OP_PQ_VAL_16S:
 562         {
 563                 struct ioat_pq_descriptor *pq = desc->pq;
 564
 565                 /* check if there's error written */
 566                 if (!pq->dwbes_f.wbes)
 567                         return;
 568
 569                 /* need to set a chanerr var for checking to clear later */
 570
 571                 if (pq->dwbes_f.p_val_err)
 572                         *desc->result |= SUM_CHECK_P_RESULT;
 573
 574                 if (pq->dwbes_f.q_val_err)
 575                         *desc->result |= SUM_CHECK_Q_RESULT;
 576
 577                 return;
 578         }
 579         default:
 580                 return;
 581         }
 582 }
 583
 584 /**
 585  * __cleanup - reclaim used descriptors
 586  * @ioat: channel (ring) to clean
 587  */
 588 static void __cleanup(struct ioatdma_chan *ioat_chan, dma_addr_t phys_complete)
 589 {
 590         struct ioatdma_device *ioat_dma = ioat_chan->ioat_dma;
 591         struct ioat_ring_ent *desc;
 592         bool seen_current = false;
 593         int idx = ioat_chan->tail, i;
 594         u16 active;
 595
 596         dev_dbg(to_dev(ioat_chan), "%s: head: %#x tail: %#x issued: %#x\n",
 597                 __func__, ioat_chan->head, ioat_chan->tail, ioat_chan->issued);
 598
 599         /*
 600          * At restart of the channel, the completion address and the
 601          * channel status will be 0 due to starting a new chain. Since
 602          * it's new chain and the first descriptor "fails", there is
 603          * nothing to clean up. We do not want to reap the entire submitted
 604          * chain due to this 0 address value and then BUG.
 605          */
 606         if (!phys_complete)
 607                 return;
 608
 609         active = ioat_ring_active(ioat_chan);
 610         for (i = 0; i < active && !seen_current; i++) {
 611                 struct dma_async_tx_descriptor *tx;
 612
 613                 prefetch(ioat_get_ring_ent(ioat_chan, idx + i + 1));
 614                 desc = ioat_get_ring_ent(ioat_chan, idx + i);
 615                 dump_desc_dbg(ioat_chan, desc);
 616
 617                 /* set err stat if we are using dwbes */
 618                 if (ioat_dma->cap & IOAT_CAP_DWBES)
 619                         desc_get_errstat(ioat_chan, desc);
 620
 621                 tx = &desc->txd;
 622                 if (tx->cookie) {
 623                         dma_cookie_complete(tx);
 624                         dma_descriptor_unmap(tx);
 625                         dmaengine_desc_get_callback_invoke(tx, NULL);
 626                         tx->callback = NULL;
 627                         tx->callback_result = NULL;
 628                 }
 629
 630                 if (tx->phys == phys_complete)
 631                         seen_current = true;
 632
 633                 /* skip extended descriptors */
 634                 if (desc_has_ext(desc)) {
 635                         BUG_ON(i + 1 >= active);
 636                         i++;
 637                 }
 638
 639                 /* cleanup super extended descriptors */
 640                 if (desc->sed) {
 641                         ioat_free_sed(ioat_dma, desc->sed);
 642                         desc->sed = NULL;
 643                 }
 644         }
 645
 646         /* finish all descriptor reads before incrementing tail */
 647         smp_mb();
 648         ioat_chan->tail = idx + i;
 649         /* no active descs have written a completion? */
 650         BUG_ON(active && !seen_current);
 651         ioat_chan->last_completion = phys_complete;
 652
 653         if (active - i == 0) {
 654                 dev_dbg(to_dev(ioat_chan), "%s: cancel completion timeout\n",
 655                         __func__);
 656                 mod_timer_pending(&ioat_chan->timer, jiffies + IDLE_TIMEOUT);
 657         }
 658
 659         /* microsecond delay by sysfs variable  per pending descriptor */
 660         if (ioat_chan->intr_coalesce != ioat_chan->prev_intr_coalesce) {
 661                 writew(min((ioat_chan->intr_coalesce * (active - i)),
 662                        IOAT_INTRDELAY_MASK),
 663                        ioat_chan->ioat_dma->reg_base + IOAT_INTRDELAY_OFFSET);
 664                 ioat_chan->prev_intr_coalesce = ioat_chan->intr_coalesce;
 665         }
 666 }
 667
 668 static void ioat_cleanup(struct ioatdma_chan *ioat_chan)
 669 {
 670         u64 phys_complete;
 671
 672         spin_lock_bh(&ioat_chan->cleanup_lock);
 673
 674         if (ioat_cleanup_preamble(ioat_chan, &phys_complete))
 675                 __cleanup(ioat_chan, phys_complete);
 676
 677         if (is_ioat_halted(*ioat_chan->completion)) {
 678                 u32 chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
 679
 680                 if (chanerr &
 681                     (IOAT_CHANERR_HANDLE_MASK | IOAT_CHANERR_RECOVER_MASK)) {
 682                         mod_timer_pending(&ioat_chan->timer, jiffies + IDLE_TIMEOUT);
 683                         ioat_eh(ioat_chan);
 684                 }
 685         }
 686
 687         spin_unlock_bh(&ioat_chan->cleanup_lock);
 688 }
 689
 690 void ioat_cleanup_event(unsigned long data)
 691 {
 692         struct ioatdma_chan *ioat_chan = to_ioat_chan((void *)data);
 693
 694         ioat_cleanup(ioat_chan);
 695         if (!test_bit(IOAT_RUN, &ioat_chan->state))
 696                 return;
 697         writew(IOAT_CHANCTRL_RUN, ioat_chan->reg_base + IOAT_CHANCTRL_OFFSET);
 698 }
 699
 700 static void ioat_restart_channel(struct ioatdma_chan *ioat_chan)
 701 {
 702         u64 phys_complete;
 703
 704         /* set the completion address register again */
 705         writel(lower_32_bits(ioat_chan->completion_dma),
 706                ioat_chan->reg_base + IOAT_CHANCMP_OFFSET_LOW);
 707         writel(upper_32_bits(ioat_chan->completion_dma),
 708                ioat_chan->reg_base + IOAT_CHANCMP_OFFSET_HIGH);
 709
 710         ioat_quiesce(ioat_chan, 0);
 711         if (ioat_cleanup_preamble(ioat_chan, &phys_complete))
 712                 __cleanup(ioat_chan, phys_complete);
 713
 714         __ioat_restart_chan(ioat_chan);
 715 }
 716
 717
 718 static void ioat_abort_descs(struct ioatdma_chan *ioat_chan)
 719 {
 720         struct ioatdma_device *ioat_dma = ioat_chan->ioat_dma;
 721         struct ioat_ring_ent *desc;
 722         u16 active;
 723         int idx = ioat_chan->tail, i;
 724
 725         /*
 726          * We assume that the failed descriptor has been processed.
 727          * Now we are just returning all the remaining submitted
 728          * descriptors to abort.
 729          */
 730         active = ioat_ring_active(ioat_chan);
 731
 732         /* we skip the failed descriptor that tail points to */
 733         for (i = 1; i < active; i++) {
 734                 struct dma_async_tx_descriptor *tx;
 735
 736                 prefetch(ioat_get_ring_ent(ioat_chan, idx + i + 1));
 737                 desc = ioat_get_ring_ent(ioat_chan, idx + i);
 738
 739                 tx = &desc->txd;
 740                 if (tx->cookie) {
 741                         struct dmaengine_result res;
 742
 743                         dma_cookie_complete(tx);
 744                         dma_descriptor_unmap(tx);
 745                         res.result = DMA_TRANS_ABORTED;
 746                         dmaengine_desc_get_callback_invoke(tx, &res);
 747                         tx->callback = NULL;
 748                         tx->callback_result = NULL;
 749                 }
 750
 751                 /* skip extended descriptors */
 752                 if (desc_has_ext(desc)) {
 753                         WARN_ON(i + 1 >= active);
 754                         i++;
 755                 }
 756
 757                 /* cleanup super extended descriptors */
 758                 if (desc->sed) {
 759                         ioat_free_sed(ioat_dma, desc->sed);
 760                         desc->sed = NULL;
 761                 }
 762         }
 763
 764         smp_mb(); /* finish all descriptor reads before incrementing tail */
 765         ioat_chan->tail = idx + active;
 766
 767         desc = ioat_get_ring_ent(ioat_chan, ioat_chan->tail);
 768         ioat_chan->last_completion = *ioat_chan->completion = desc->txd.phys;
 769 }
 770
 771 static void ioat_eh(struct ioatdma_chan *ioat_chan)
 772 {
 773         struct pci_dev *pdev = to_pdev(ioat_chan);
 774         struct ioat_dma_descriptor *hw;
 775         struct dma_async_tx_descriptor *tx;
 776         u64 phys_complete;
 777         struct ioat_ring_ent *desc;
 778         u32 err_handled = 0;
 779         u32 chanerr_int;
 780         u32 chanerr;
 781         bool abort = false;
 782         struct dmaengine_result res;
 783
 784         /* cleanup so tail points to descriptor that caused the error */
 785         if (ioat_cleanup_preamble(ioat_chan, &phys_complete))
 786                 __cleanup(ioat_chan, phys_complete);
 787
 788         chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
 789         pci_read_config_dword(pdev, IOAT_PCI_CHANERR_INT_OFFSET, &chanerr_int);
 790
 791         dev_dbg(to_dev(ioat_chan), "%s: error = %x:%x\n",
 792                 __func__, chanerr, chanerr_int);
 793
 794         desc = ioat_get_ring_ent(ioat_chan, ioat_chan->tail);
 795         hw = desc->hw;
 796         dump_desc_dbg(ioat_chan, desc);
 797
 798         switch (hw->ctl_f.op) {
 799         case IOAT_OP_XOR_VAL:
 800                 if (chanerr & IOAT_CHANERR_XOR_P_OR_CRC_ERR) {
 801                         *desc->result |= SUM_CHECK_P_RESULT;
 802                         err_handled |= IOAT_CHANERR_XOR_P_OR_CRC_ERR;
 803                 }
 804                 break;
 805         case IOAT_OP_PQ_VAL:
 806         case IOAT_OP_PQ_VAL_16S:
 807                 if (chanerr & IOAT_CHANERR_XOR_P_OR_CRC_ERR) {
 808                         *desc->result |= SUM_CHECK_P_RESULT;
 809                         err_handled |= IOAT_CHANERR_XOR_P_OR_CRC_ERR;
 810                 }
 811                 if (chanerr & IOAT_CHANERR_XOR_Q_ERR) {
 812                         *desc->result |= SUM_CHECK_Q_RESULT;
 813                         err_handled |= IOAT_CHANERR_XOR_Q_ERR;
 814                 }
 815                 break;
 816         }
 817
 818         if (chanerr & IOAT_CHANERR_RECOVER_MASK) {
 819                 if (chanerr & IOAT_CHANERR_READ_DATA_ERR) {
 820                         res.result = DMA_TRANS_READ_FAILED;
 821                         err_handled |= IOAT_CHANERR_READ_DATA_ERR;
 822                 } else if (chanerr & IOAT_CHANERR_WRITE_DATA_ERR) {
 823                         res.result = DMA_TRANS_WRITE_FAILED;
 824                         err_handled |= IOAT_CHANERR_WRITE_DATA_ERR;
 825                 }
 826
 827                 abort = true;
 828         } else
 829                 res.result = DMA_TRANS_NOERROR;
 830
 831         /* fault on unhandled error or spurious halt */
 832         if (chanerr ^ err_handled || chanerr == 0) {
 833                 dev_err(to_dev(ioat_chan), "%s: fatal error (%x:%x)\n",
 834                         __func__, chanerr, err_handled);
 835                 dev_err(to_dev(ioat_chan), "Errors handled:\n");
 836                 ioat_print_chanerrs(ioat_chan, err_handled);
 837                 dev_err(to_dev(ioat_chan), "Errors not handled:\n");
 838                 ioat_print_chanerrs(ioat_chan, (chanerr & ~err_handled));
 839
 840                 BUG();
 841         }
 842
 843         /* cleanup the faulty descriptor since we are continuing */
 844         tx = &desc->txd;
 845         if (tx->cookie) {
 846                 dma_cookie_complete(tx);
 847                 dma_descriptor_unmap(tx);
 848                 dmaengine_desc_get_callback_invoke(tx, &res);
 849                 tx->callback = NULL;
 850                 tx->callback_result = NULL;
 851         }
 852
 853         /* mark faulting descriptor as complete */
 854         *ioat_chan->completion = desc->txd.phys;
 855
 856         spin_lock_bh(&ioat_chan->prep_lock);
 857         /* we need abort all descriptors */
 858         if (abort) {
 859                 ioat_abort_descs(ioat_chan);
 860                 /* clean up the channel, we could be in weird state */
 861                 ioat_reset_hw(ioat_chan);
 862         }
 863
 864         writel(chanerr, ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
 865         pci_write_config_dword(pdev, IOAT_PCI_CHANERR_INT_OFFSET, chanerr_int);
 866
 867         ioat_restart_channel(ioat_chan);
 868         spin_unlock_bh(&ioat_chan->prep_lock);
 869 }
 870
 871 static void check_active(struct ioatdma_chan *ioat_chan)
 872 {
 873         if (ioat_ring_active(ioat_chan)) {
 874                 mod_timer(&ioat_chan->timer, jiffies + COMPLETION_TIMEOUT);
 875                 return;
 876         }
 877
 878         if (test_and_clear_bit(IOAT_CHAN_ACTIVE, &ioat_chan->state))
 879                 mod_timer_pending(&ioat_chan->timer, jiffies + IDLE_TIMEOUT);
 880 }
 881
 882 void ioat_timer_event(struct timer_list *t)
 883 {
 884         struct ioatdma_chan *ioat_chan = from_timer(ioat_chan, t, timer);
 885         dma_addr_t phys_complete;
 886         u64 status;
 887
 888         status = ioat_chansts(ioat_chan);
 889
 890         /* when halted due to errors check for channel
 891          * programming errors before advancing the completion state
 892          */
 893         if (is_ioat_halted(status)) {
 894                 u32 chanerr;
 895
 896                 chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
 897                 dev_err(to_dev(ioat_chan), "%s: Channel halted (%x)\n",
 898                         __func__, chanerr);
 899                 dev_err(to_dev(ioat_chan), "Errors:\n");
 900                 ioat_print_chanerrs(ioat_chan, chanerr);
 901
 902                 if (test_bit(IOAT_RUN, &ioat_chan->state)) {
 903                         spin_lock_bh(&ioat_chan->cleanup_lock);
 904                         spin_lock_bh(&ioat_chan->prep_lock);
 905                         set_bit(IOAT_CHAN_DOWN, &ioat_chan->state);
 906                         spin_unlock_bh(&ioat_chan->prep_lock);
 907
 908                         ioat_abort_descs(ioat_chan);
 909                         dev_warn(to_dev(ioat_chan), "Reset channel...\n");
 910                         ioat_reset_hw(ioat_chan);
 911                         dev_warn(to_dev(ioat_chan), "Restart channel...\n");
 912                         ioat_restart_channel(ioat_chan);
 913
 914                         spin_lock_bh(&ioat_chan->prep_lock);
 915                         clear_bit(IOAT_CHAN_DOWN, &ioat_chan->state);
 916                         spin_unlock_bh(&ioat_chan->prep_lock);
 917                         spin_unlock_bh(&ioat_chan->cleanup_lock);
 918                 }
 919
 920                 return;
 921         }
 922
 923         spin_lock_bh(&ioat_chan->cleanup_lock);
 924
 925         /* handle the no-actives case */
 926         if (!ioat_ring_active(ioat_chan)) {
 927                 spin_lock_bh(&ioat_chan->prep_lock);
 928                 check_active(ioat_chan);
 929                 spin_unlock_bh(&ioat_chan->prep_lock);
 930                 spin_unlock_bh(&ioat_chan->cleanup_lock);
 931                 return;
 932         }
 933
 934         /* if we haven't made progress and we have already
 935          * acknowledged a pending completion once, then be more
 936          * forceful with a restart
 937          */
 938         if (ioat_cleanup_preamble(ioat_chan, &phys_complete))
 939                 __cleanup(ioat_chan, phys_complete);
 940         else if (test_bit(IOAT_COMPLETION_ACK, &ioat_chan->state)) {
 941                 u32 chanerr;
 942
 943                 chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
 944                 dev_err(to_dev(ioat_chan), "CHANSTS: %#Lx CHANERR: %#x\n",
 945                         status, chanerr);
 946                 dev_err(to_dev(ioat_chan), "Errors:\n");
 947                 ioat_print_chanerrs(ioat_chan, chanerr);
 948
 949                 dev_dbg(to_dev(ioat_chan), "Active descriptors: %d\n",
 950                         ioat_ring_active(ioat_chan));
 951
 952                 spin_lock_bh(&ioat_chan->prep_lock);
 953                 set_bit(IOAT_CHAN_DOWN, &ioat_chan->state);
 954                 spin_unlock_bh(&ioat_chan->prep_lock);
 955
 956                 ioat_abort_descs(ioat_chan);
 957                 dev_warn(to_dev(ioat_chan), "Resetting channel...\n");
 958                 ioat_reset_hw(ioat_chan);
 959                 dev_warn(to_dev(ioat_chan), "Restarting channel...\n");
 960                 ioat_restart_channel(ioat_chan);
 961
 962                 spin_lock_bh(&ioat_chan->prep_lock);
 963                 clear_bit(IOAT_CHAN_DOWN, &ioat_chan->state);
 964                 spin_unlock_bh(&ioat_chan->prep_lock);
 965                 spin_unlock_bh(&ioat_chan->cleanup_lock);
 966                 return;
 967         } else
 968                 set_bit(IOAT_COMPLETION_ACK, &ioat_chan->state);
 969
 970         mod_timer(&ioat_chan->timer, jiffies + COMPLETION_TIMEOUT);
 971         spin_unlock_bh(&ioat_chan->cleanup_lock);
 972 }
 973
 974 enum dma_status
 975 ioat_tx_status(struct dma_chan *c, dma_cookie_t cookie,
 976                 struct dma_tx_state *txstate)
 977 {
 978         struct ioatdma_chan *ioat_chan = to_ioat_chan(c);
 979         enum dma_status ret;
 980
 981         ret = dma_cookie_status(c, cookie, txstate);
 982         if (ret == DMA_COMPLETE)
 983                 return ret;
 984
 985         ioat_cleanup(ioat_chan);
 986
 987         return dma_cookie_status(c, cookie, txstate);
 988 }
 989
 990 int ioat_reset_hw(struct ioatdma_chan *ioat_chan)
 991 {
 992         /* throw away whatever the channel was doing and get it
 993          * initialized, with ioat3 specific workarounds
 994          */
 995         struct ioatdma_device *ioat_dma = ioat_chan->ioat_dma;
 996         struct pci_dev *pdev = ioat_dma->pdev;
 997         u32 chanerr;
 998         u16 dev_id;
 999         int err;
1000
1001         ioat_quiesce(ioat_chan, msecs_to_jiffies(100));
1002
1003         chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
1004         writel(chanerr, ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
1005
1006         if (ioat_dma->version < IOAT_VER_3_3) {
1007                 /* clear any pending errors */
1008                 err = pci_read_config_dword(pdev,
1009                                 IOAT_PCI_CHANERR_INT_OFFSET, &chanerr);
1010                 if (err) {
1011                         dev_err(&pdev->dev,
1012                                 "channel error register unreachable\n");
1013                         return err;
1014                 }
1015                 pci_write_config_dword(pdev,
1016                                 IOAT_PCI_CHANERR_INT_OFFSET, chanerr);
1017
1018                 /* Clear DMAUNCERRSTS Cfg-Reg Parity Error status bit
1019                  * (workaround for spurious config parity error after restart)
1020                  */
1021                 pci_read_config_word(pdev, IOAT_PCI_DEVICE_ID_OFFSET, &dev_id);
1022                 if (dev_id == PCI_DEVICE_ID_INTEL_IOAT_TBG0) {
1023                         pci_write_config_dword(pdev,
1024                                                IOAT_PCI_DMAUNCERRSTS_OFFSET,
1025                                                0x10);
1026                 }
1027         }
1028
1029         if (is_bwd_ioat(pdev) && (ioat_dma->irq_mode == IOAT_MSIX)) {
1030                 ioat_dma->msixtba0 = readq(ioat_dma->reg_base + 0x1000);
1031                 ioat_dma->msixdata0 = readq(ioat_dma->reg_base + 0x1008);
1032                 ioat_dma->msixpba = readq(ioat_dma->reg_base + 0x1800);
1033         }
1034
1035
1036         err = ioat_reset_sync(ioat_chan, msecs_to_jiffies(200));
1037         if (!err) {
1038                 if (is_bwd_ioat(pdev) && (ioat_dma->irq_mode == IOAT_MSIX)) {
1039                         writeq(ioat_dma->msixtba0, ioat_dma->reg_base + 0x1000);
1040                         writeq(ioat_dma->msixdata0, ioat_dma->reg_base + 0x1008);
1041                         writeq(ioat_dma->msixpba, ioat_dma->reg_base + 0x1800);
1042                 }
1043         }
1044
1045         if (err)
1046                 dev_err(&pdev->dev, "Failed to reset: %d\n", err);
1047
1048         return err;
1049 }