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((unsigned long)ioat_chan);
 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                 smp_read_barrier_depends();
 614                 prefetch(ioat_get_ring_ent(ioat_chan, idx + i + 1));
 615                 desc = ioat_get_ring_ent(ioat_chan, idx + i);
 616                 dump_desc_dbg(ioat_chan, desc);
 617
 618                 /* set err stat if we are using dwbes */
 619                 if (ioat_dma->cap & IOAT_CAP_DWBES)
 620                         desc_get_errstat(ioat_chan, desc);
 621
 622                 tx = &desc->txd;
 623                 if (tx->cookie) {
 624                         dma_cookie_complete(tx);
 625                         dma_descriptor_unmap(tx);
 626                         dmaengine_desc_get_callback_invoke(tx, NULL);
 627                         tx->callback = NULL;
 628                         tx->callback_result = NULL;
 629                 }
 630
 631                 if (tx->phys == phys_complete)
 632                         seen_current = true;
 633
 634                 /* skip extended descriptors */
 635                 if (desc_has_ext(desc)) {
 636                         BUG_ON(i + 1 >= active);
 637                         i++;
 638                 }
 639
 640                 /* cleanup super extended descriptors */
 641                 if (desc->sed) {
 642                         ioat_free_sed(ioat_dma, desc->sed);
 643                         desc->sed = NULL;
 644                 }
 645         }
 646
 647         /* finish all descriptor reads before incrementing tail */
 648         smp_mb();
 649         ioat_chan->tail = idx + i;
 650         /* no active descs have written a completion? */
 651         BUG_ON(active && !seen_current);
 652         ioat_chan->last_completion = phys_complete;
 653
 654         if (active - i == 0) {
 655                 dev_dbg(to_dev(ioat_chan), "%s: cancel completion timeout\n",
 656                         __func__);
 657                 mod_timer(&ioat_chan->timer, jiffies + IDLE_TIMEOUT);
 658         }
 659
 660         /* microsecond delay by sysfs variable  per pending descriptor */
 661         if (ioat_chan->intr_coalesce != ioat_chan->prev_intr_coalesce) {
 662                 writew(min((ioat_chan->intr_coalesce * (active - i)),
 663                        IOAT_INTRDELAY_MASK),
 664                        ioat_chan->ioat_dma->reg_base + IOAT_INTRDELAY_OFFSET);
 665                 ioat_chan->prev_intr_coalesce = ioat_chan->intr_coalesce;
 666         }
 667 }
 668
 669 static void ioat_cleanup(struct ioatdma_chan *ioat_chan)
 670 {
 671         u64 phys_complete;
 672
 673         spin_lock_bh(&ioat_chan->cleanup_lock);
 674
 675         if (ioat_cleanup_preamble(ioat_chan, &phys_complete))
 676                 __cleanup(ioat_chan, phys_complete);
 677
 678         if (is_ioat_halted(*ioat_chan->completion)) {
 679                 u32 chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
 680
 681                 if (chanerr &
 682                     (IOAT_CHANERR_HANDLE_MASK | IOAT_CHANERR_RECOVER_MASK)) {
 683                         mod_timer(&ioat_chan->timer, jiffies + IDLE_TIMEOUT);
 684                         ioat_eh(ioat_chan);
 685                 }
 686         }
 687
 688         spin_unlock_bh(&ioat_chan->cleanup_lock);
 689 }
 690
 691 void ioat_cleanup_event(unsigned long data)
 692 {
 693         struct ioatdma_chan *ioat_chan = to_ioat_chan((void *)data);
 694
 695         ioat_cleanup(ioat_chan);
 696         if (!test_bit(IOAT_RUN, &ioat_chan->state))
 697                 return;
 698         writew(IOAT_CHANCTRL_RUN, ioat_chan->reg_base + IOAT_CHANCTRL_OFFSET);
 699 }
 700
 701 static void ioat_restart_channel(struct ioatdma_chan *ioat_chan)
 702 {
 703         u64 phys_complete;
 704
 705         ioat_quiesce(ioat_chan, 0);
 706         if (ioat_cleanup_preamble(ioat_chan, &phys_complete))
 707                 __cleanup(ioat_chan, phys_complete);
 708
 709         __ioat_restart_chan(ioat_chan);
 710 }
 711
 712
 713 static void ioat_abort_descs(struct ioatdma_chan *ioat_chan)
 714 {
 715         struct ioatdma_device *ioat_dma = ioat_chan->ioat_dma;
 716         struct ioat_ring_ent *desc;
 717         u16 active;
 718         int idx = ioat_chan->tail, i;
 719
 720         /*
 721          * We assume that the failed descriptor has been processed.
 722          * Now we are just returning all the remaining submitted
 723          * descriptors to abort.
 724          */
 725         active = ioat_ring_active(ioat_chan);
 726
 727         /* we skip the failed descriptor that tail points to */
 728         for (i = 1; i < active; i++) {
 729                 struct dma_async_tx_descriptor *tx;
 730
 731                 smp_read_barrier_depends();
 732                 prefetch(ioat_get_ring_ent(ioat_chan, idx + i + 1));
 733                 desc = ioat_get_ring_ent(ioat_chan, idx + i);
 734
 735                 tx = &desc->txd;
 736                 if (tx->cookie) {
 737                         struct dmaengine_result res;
 738
 739                         dma_cookie_complete(tx);
 740                         dma_descriptor_unmap(tx);
 741                         res.result = DMA_TRANS_ABORTED;
 742                         dmaengine_desc_get_callback_invoke(tx, &res);
 743                         tx->callback = NULL;
 744                         tx->callback_result = NULL;
 745                 }
 746
 747                 /* skip extended descriptors */
 748                 if (desc_has_ext(desc)) {
 749                         WARN_ON(i + 1 >= active);
 750                         i++;
 751                 }
 752
 753                 /* cleanup super extended descriptors */
 754                 if (desc->sed) {
 755                         ioat_free_sed(ioat_dma, desc->sed);
 756                         desc->sed = NULL;
 757                 }
 758         }
 759
 760         smp_mb(); /* finish all descriptor reads before incrementing tail */
 761         ioat_chan->tail = idx + active;
 762
 763         desc = ioat_get_ring_ent(ioat_chan, ioat_chan->tail);
 764         ioat_chan->last_completion = *ioat_chan->completion = desc->txd.phys;
 765 }
 766
 767 static void ioat_eh(struct ioatdma_chan *ioat_chan)
 768 {
 769         struct pci_dev *pdev = to_pdev(ioat_chan);
 770         struct ioat_dma_descriptor *hw;
 771         struct dma_async_tx_descriptor *tx;
 772         u64 phys_complete;
 773         struct ioat_ring_ent *desc;
 774         u32 err_handled = 0;
 775         u32 chanerr_int;
 776         u32 chanerr;
 777         bool abort = false;
 778         struct dmaengine_result res;
 779
 780         /* cleanup so tail points to descriptor that caused the error */
 781         if (ioat_cleanup_preamble(ioat_chan, &phys_complete))
 782                 __cleanup(ioat_chan, phys_complete);
 783
 784         chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
 785         pci_read_config_dword(pdev, IOAT_PCI_CHANERR_INT_OFFSET, &chanerr_int);
 786
 787         dev_dbg(to_dev(ioat_chan), "%s: error = %x:%x\n",
 788                 __func__, chanerr, chanerr_int);
 789
 790         desc = ioat_get_ring_ent(ioat_chan, ioat_chan->tail);
 791         hw = desc->hw;
 792         dump_desc_dbg(ioat_chan, desc);
 793
 794         switch (hw->ctl_f.op) {
 795         case IOAT_OP_XOR_VAL:
 796                 if (chanerr & IOAT_CHANERR_XOR_P_OR_CRC_ERR) {
 797                         *desc->result |= SUM_CHECK_P_RESULT;
 798                         err_handled |= IOAT_CHANERR_XOR_P_OR_CRC_ERR;
 799                 }
 800                 break;
 801         case IOAT_OP_PQ_VAL:
 802         case IOAT_OP_PQ_VAL_16S:
 803                 if (chanerr & IOAT_CHANERR_XOR_P_OR_CRC_ERR) {
 804                         *desc->result |= SUM_CHECK_P_RESULT;
 805                         err_handled |= IOAT_CHANERR_XOR_P_OR_CRC_ERR;
 806                 }
 807                 if (chanerr & IOAT_CHANERR_XOR_Q_ERR) {
 808                         *desc->result |= SUM_CHECK_Q_RESULT;
 809                         err_handled |= IOAT_CHANERR_XOR_Q_ERR;
 810                 }
 811                 break;
 812         }
 813
 814         if (chanerr & IOAT_CHANERR_RECOVER_MASK) {
 815                 if (chanerr & IOAT_CHANERR_READ_DATA_ERR) {
 816                         res.result = DMA_TRANS_READ_FAILED;
 817                         err_handled |= IOAT_CHANERR_READ_DATA_ERR;
 818                 } else if (chanerr & IOAT_CHANERR_WRITE_DATA_ERR) {
 819                         res.result = DMA_TRANS_WRITE_FAILED;
 820                         err_handled |= IOAT_CHANERR_WRITE_DATA_ERR;
 821                 }
 822
 823                 abort = true;
 824         } else
 825                 res.result = DMA_TRANS_NOERROR;
 826
 827         /* fault on unhandled error or spurious halt */
 828         if (chanerr ^ err_handled || chanerr == 0) {
 829                 dev_err(to_dev(ioat_chan), "%s: fatal error (%x:%x)\n",
 830                         __func__, chanerr, err_handled);
 831                 dev_err(to_dev(ioat_chan), "Errors handled:\n");
 832                 ioat_print_chanerrs(ioat_chan, err_handled);
 833                 dev_err(to_dev(ioat_chan), "Errors not handled:\n");
 834                 ioat_print_chanerrs(ioat_chan, (chanerr & ~err_handled));
 835
 836                 BUG();
 837         }
 838
 839         /* cleanup the faulty descriptor since we are continuing */
 840         tx = &desc->txd;
 841         if (tx->cookie) {
 842                 dma_cookie_complete(tx);
 843                 dma_descriptor_unmap(tx);
 844                 dmaengine_desc_get_callback_invoke(tx, &res);
 845                 tx->callback = NULL;
 846                 tx->callback_result = NULL;
 847         }
 848
 849         /* mark faulting descriptor as complete */
 850         *ioat_chan->completion = desc->txd.phys;
 851
 852         spin_lock_bh(&ioat_chan->prep_lock);
 853         /* we need abort all descriptors */
 854         if (abort) {
 855                 ioat_abort_descs(ioat_chan);
 856                 /* clean up the channel, we could be in weird state */
 857                 ioat_reset_hw(ioat_chan);
 858         }
 859
 860         writel(chanerr, ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
 861         pci_write_config_dword(pdev, IOAT_PCI_CHANERR_INT_OFFSET, chanerr_int);
 862
 863         ioat_restart_channel(ioat_chan);
 864         spin_unlock_bh(&ioat_chan->prep_lock);
 865 }
 866
 867 static void check_active(struct ioatdma_chan *ioat_chan)
 868 {
 869         if (ioat_ring_active(ioat_chan)) {
 870                 mod_timer(&ioat_chan->timer, jiffies + COMPLETION_TIMEOUT);
 871                 return;
 872         }
 873
 874         if (test_and_clear_bit(IOAT_CHAN_ACTIVE, &ioat_chan->state))
 875                 mod_timer(&ioat_chan->timer, jiffies + IDLE_TIMEOUT);
 876 }
 877
 878 void ioat_timer_event(unsigned long data)
 879 {
 880         struct ioatdma_chan *ioat_chan = to_ioat_chan((void *)data);
 881         dma_addr_t phys_complete;
 882         u64 status;
 883
 884         status = ioat_chansts(ioat_chan);
 885
 886         /* when halted due to errors check for channel
 887          * programming errors before advancing the completion state
 888          */
 889         if (is_ioat_halted(status)) {
 890                 u32 chanerr;
 891
 892                 chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
 893                 dev_err(to_dev(ioat_chan), "%s: Channel halted (%x)\n",
 894                         __func__, chanerr);
 895                 dev_err(to_dev(ioat_chan), "Errors:\n");
 896                 ioat_print_chanerrs(ioat_chan, chanerr);
 897
 898                 if (test_bit(IOAT_RUN, &ioat_chan->state)) {
 899                         spin_lock_bh(&ioat_chan->cleanup_lock);
 900                         spin_lock_bh(&ioat_chan->prep_lock);
 901                         set_bit(IOAT_CHAN_DOWN, &ioat_chan->state);
 902                         spin_unlock_bh(&ioat_chan->prep_lock);
 903
 904                         ioat_abort_descs(ioat_chan);
 905                         dev_warn(to_dev(ioat_chan), "Reset channel...\n");
 906                         ioat_reset_hw(ioat_chan);
 907                         dev_warn(to_dev(ioat_chan), "Restart channel...\n");
 908                         ioat_restart_channel(ioat_chan);
 909
 910                         spin_lock_bh(&ioat_chan->prep_lock);
 911                         clear_bit(IOAT_CHAN_DOWN, &ioat_chan->state);
 912                         spin_unlock_bh(&ioat_chan->prep_lock);
 913                         spin_unlock_bh(&ioat_chan->cleanup_lock);
 914                 }
 915
 916                 return;
 917         }
 918
 919         spin_lock_bh(&ioat_chan->cleanup_lock);
 920
 921         /* handle the no-actives case */
 922         if (!ioat_ring_active(ioat_chan)) {
 923                 spin_lock_bh(&ioat_chan->prep_lock);
 924                 check_active(ioat_chan);
 925                 spin_unlock_bh(&ioat_chan->prep_lock);
 926                 spin_unlock_bh(&ioat_chan->cleanup_lock);
 927                 return;
 928         }
 929
 930         /* if we haven't made progress and we have already
 931          * acknowledged a pending completion once, then be more
 932          * forceful with a restart
 933          */
 934         if (ioat_cleanup_preamble(ioat_chan, &phys_complete))
 935                 __cleanup(ioat_chan, phys_complete);
 936         else if (test_bit(IOAT_COMPLETION_ACK, &ioat_chan->state)) {
 937                 u32 chanerr;
 938
 939                 chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
 940                 dev_err(to_dev(ioat_chan), "CHANSTS: %#Lx CHANERR: %#x\n",
 941                         status, chanerr);
 942                 dev_err(to_dev(ioat_chan), "Errors:\n");
 943                 ioat_print_chanerrs(ioat_chan, chanerr);
 944
 945                 dev_dbg(to_dev(ioat_chan), "Active descriptors: %d\n",
 946                         ioat_ring_active(ioat_chan));
 947
 948                 spin_lock_bh(&ioat_chan->prep_lock);
 949                 set_bit(IOAT_CHAN_DOWN, &ioat_chan->state);
 950                 spin_unlock_bh(&ioat_chan->prep_lock);
 951
 952                 ioat_abort_descs(ioat_chan);
 953                 dev_warn(to_dev(ioat_chan), "Resetting channel...\n");
 954                 ioat_reset_hw(ioat_chan);
 955                 dev_warn(to_dev(ioat_chan), "Restarting channel...\n");
 956                 ioat_restart_channel(ioat_chan);
 957
 958                 spin_lock_bh(&ioat_chan->prep_lock);
 959                 clear_bit(IOAT_CHAN_DOWN, &ioat_chan->state);
 960                 spin_unlock_bh(&ioat_chan->prep_lock);
 961                 spin_unlock_bh(&ioat_chan->cleanup_lock);
 962                 return;
 963         } else
 964                 set_bit(IOAT_COMPLETION_ACK, &ioat_chan->state);
 965
 966         mod_timer(&ioat_chan->timer, jiffies + COMPLETION_TIMEOUT);
 967         spin_unlock_bh(&ioat_chan->cleanup_lock);
 968 }
 969
 970 enum dma_status
 971 ioat_tx_status(struct dma_chan *c, dma_cookie_t cookie,
 972                 struct dma_tx_state *txstate)
 973 {
 974         struct ioatdma_chan *ioat_chan = to_ioat_chan(c);
 975         enum dma_status ret;
 976
 977         ret = dma_cookie_status(c, cookie, txstate);
 978         if (ret == DMA_COMPLETE)
 979                 return ret;
 980
 981         ioat_cleanup(ioat_chan);
 982
 983         return dma_cookie_status(c, cookie, txstate);
 984 }
 985
 986 int ioat_reset_hw(struct ioatdma_chan *ioat_chan)
 987 {
 988         /* throw away whatever the channel was doing and get it
 989          * initialized, with ioat3 specific workarounds
 990          */
 991         struct ioatdma_device *ioat_dma = ioat_chan->ioat_dma;
 992         struct pci_dev *pdev = ioat_dma->pdev;
 993         u32 chanerr;
 994         u16 dev_id;
 995         int err;
 996
 997         ioat_quiesce(ioat_chan, msecs_to_jiffies(100));
 998
 999         chanerr = readl(ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
1000         writel(chanerr, ioat_chan->reg_base + IOAT_CHANERR_OFFSET);
1001
1002         if (ioat_dma->version < IOAT_VER_3_3) {
1003                 /* clear any pending errors */
1004                 err = pci_read_config_dword(pdev,
1005                                 IOAT_PCI_CHANERR_INT_OFFSET, &chanerr);
1006                 if (err) {
1007                         dev_err(&pdev->dev,
1008                                 "channel error register unreachable\n");
1009                         return err;
1010                 }
1011                 pci_write_config_dword(pdev,
1012                                 IOAT_PCI_CHANERR_INT_OFFSET, chanerr);
1013
1014                 /* Clear DMAUNCERRSTS Cfg-Reg Parity Error status bit
1015                  * (workaround for spurious config parity error after restart)
1016                  */
1017                 pci_read_config_word(pdev, IOAT_PCI_DEVICE_ID_OFFSET, &dev_id);
1018                 if (dev_id == PCI_DEVICE_ID_INTEL_IOAT_TBG0) {
1019                         pci_write_config_dword(pdev,
1020                                                IOAT_PCI_DMAUNCERRSTS_OFFSET,
1021                                                0x10);
1022                 }
1023         }
1024
1025         if (is_bwd_ioat(pdev) && (ioat_dma->irq_mode == IOAT_MSIX)) {
1026                 ioat_dma->msixtba0 = readq(ioat_dma->reg_base + 0x1000);
1027                 ioat_dma->msixdata0 = readq(ioat_dma->reg_base + 0x1008);
1028                 ioat_dma->msixpba = readq(ioat_dma->reg_base + 0x1800);
1029         }
1030
1031
1032         err = ioat_reset_sync(ioat_chan, msecs_to_jiffies(200));
1033         if (!err) {
1034                 if (is_bwd_ioat(pdev) && (ioat_dma->irq_mode == IOAT_MSIX)) {
1035                         writeq(ioat_dma->msixtba0, ioat_dma->reg_base + 0x1000);
1036                         writeq(ioat_dma->msixdata0, ioat_dma->reg_base + 0x1008);
1037                         writeq(ioat_dma->msixpba, ioat_dma->reg_base + 0x1800);
1038                 }
1039         }
1040
1041         if (err)
1042                 dev_err(&pdev->dev, "Failed to reset: %d\n", err);
1043
1044         return err;
1045 }