kernel/drivers/infiniband/hw/qib/qib_tx.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010 QLogic Corporation. All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33 #include <linux/spinlock.h>
  34 #include <linux/pci.h>
  35 #include <linux/io.h>
  36 #include <linux/delay.h>
  37 #include <linux/netdevice.h>
  38 #include <linux/vmalloc.h>
  39 #include <linux/moduleparam.h>
  40
  41 #include "qib.h"
  42
  43 static unsigned qib_hol_timeout_ms = 3000;
  44 module_param_named(hol_timeout_ms, qib_hol_timeout_ms, uint, S_IRUGO);
  45 MODULE_PARM_DESC(hol_timeout_ms,
  46                  "duration of user app suspension after link failure");
  47
  48 unsigned qib_sdma_fetch_arb = 1;
  49 module_param_named(fetch_arb, qib_sdma_fetch_arb, uint, S_IRUGO);
  50 MODULE_PARM_DESC(fetch_arb, "IBA7220: change SDMA descriptor arbitration");
  51
  52 /**
  53  * qib_disarm_piobufs - cancel a range of PIO buffers
  54  * @dd: the qlogic_ib device
  55  * @first: the first PIO buffer to cancel
  56  * @cnt: the number of PIO buffers to cancel
  57  *
  58  * Cancel a range of PIO buffers. Used at user process close,
  59  * in case it died while writing to a PIO buffer.
  60  */
  61 void qib_disarm_piobufs(struct qib_devdata *dd, unsigned first, unsigned cnt)
  62 {
  63         unsigned long flags;
  64         unsigned i;
  65         unsigned last;
  66
  67         last = first + cnt;
  68         spin_lock_irqsave(&dd->pioavail_lock, flags);
  69         for (i = first; i < last; i++) {
  70                 __clear_bit(i, dd->pio_need_disarm);
  71                 dd->f_sendctrl(dd->pport, QIB_SENDCTRL_DISARM_BUF(i));
  72         }
  73         spin_unlock_irqrestore(&dd->pioavail_lock, flags);
  74 }
  75
  76 /*
  77  * This is called by a user process when it sees the DISARM_BUFS event
  78  * bit is set.
  79  */
  80 int qib_disarm_piobufs_ifneeded(struct qib_ctxtdata *rcd)
  81 {
  82         struct qib_devdata *dd = rcd->dd;
  83         unsigned i;
  84         unsigned last;
  85         unsigned n = 0;
  86
  87         last = rcd->pio_base + rcd->piocnt;
  88         /*
  89          * Don't need uctxt_lock here, since user has called in to us.
  90          * Clear at start in case more interrupts set bits while we
  91          * are disarming
  92          */
  93         if (rcd->user_event_mask) {
  94                 /*
  95                  * subctxt_cnt is 0 if not shared, so do base
  96                  * separately, first, then remaining subctxt, if any
  97                  */
  98                 clear_bit(_QIB_EVENT_DISARM_BUFS_BIT, &rcd->user_event_mask[0]);
  99                 for (i = 1; i < rcd->subctxt_cnt; i++)
 100                         clear_bit(_QIB_EVENT_DISARM_BUFS_BIT,
 101                                   &rcd->user_event_mask[i]);
 102         }
 103         spin_lock_irq(&dd->pioavail_lock);
 104         for (i = rcd->pio_base; i < last; i++) {
 105                 if (__test_and_clear_bit(i, dd->pio_need_disarm)) {
 106                         n++;
 107                         dd->f_sendctrl(rcd->ppd, QIB_SENDCTRL_DISARM_BUF(i));
 108                 }
 109         }
 110         spin_unlock_irq(&dd->pioavail_lock);
 111         return 0;
 112 }
 113
 114 static struct qib_pportdata *is_sdma_buf(struct qib_devdata *dd, unsigned i)
 115 {
 116         struct qib_pportdata *ppd;
 117         unsigned pidx;
 118
 119         for (pidx = 0; pidx < dd->num_pports; pidx++) {
 120                 ppd = dd->pport + pidx;
 121                 if (i >= ppd->sdma_state.first_sendbuf &&
 122                     i < ppd->sdma_state.last_sendbuf)
 123                         return ppd;
 124         }
 125         return NULL;
 126 }
 127
 128 /*
 129  * Return true if send buffer is being used by a user context.
 130  * Sets  _QIB_EVENT_DISARM_BUFS_BIT in user_event_mask as a side effect
 131  */
 132 static int find_ctxt(struct qib_devdata *dd, unsigned bufn)
 133 {
 134         struct qib_ctxtdata *rcd;
 135         unsigned ctxt;
 136         int ret = 0;
 137
 138         spin_lock(&dd->uctxt_lock);
 139         for (ctxt = dd->first_user_ctxt; ctxt < dd->cfgctxts; ctxt++) {
 140                 rcd = dd->rcd[ctxt];
 141                 if (!rcd || bufn < rcd->pio_base ||
 142                     bufn >= rcd->pio_base + rcd->piocnt)
 143                         continue;
 144                 if (rcd->user_event_mask) {
 145                         int i;
 146                         /*
 147                          * subctxt_cnt is 0 if not shared, so do base
 148                          * separately, first, then remaining subctxt, if any
 149                          */
 150                         set_bit(_QIB_EVENT_DISARM_BUFS_BIT,
 151                                 &rcd->user_event_mask[0]);
 152                         for (i = 1; i < rcd->subctxt_cnt; i++)
 153                                 set_bit(_QIB_EVENT_DISARM_BUFS_BIT,
 154                                         &rcd->user_event_mask[i]);
 155                 }
 156                 ret = 1;
 157                 break;
 158         }
 159         spin_unlock(&dd->uctxt_lock);
 160
 161         return ret;
 162 }
 163
 164 /*
 165  * Disarm a set of send buffers.  If the buffer might be actively being
 166  * written to, mark the buffer to be disarmed later when it is not being
 167  * written to.
 168  *
 169  * This should only be called from the IRQ error handler.
 170  */
 171 void qib_disarm_piobufs_set(struct qib_devdata *dd, unsigned long *mask,
 172                             unsigned cnt)
 173 {
 174         struct qib_pportdata *ppd, *pppd[QIB_MAX_IB_PORTS];
 175         unsigned i;
 176         unsigned long flags;
 177
 178         for (i = 0; i < dd->num_pports; i++)
 179                 pppd[i] = NULL;
 180
 181         for (i = 0; i < cnt; i++) {
 182                 int which;
 183
 184                 if (!test_bit(i, mask))
 185                         continue;
 186                 /*
 187                  * If the buffer is owned by the DMA hardware,
 188                  * reset the DMA engine.
 189                  */
 190                 ppd = is_sdma_buf(dd, i);
 191                 if (ppd) {
 192                         pppd[ppd->port] = ppd;
 193                         continue;
 194                 }
 195                 /*
 196                  * If the kernel is writing the buffer or the buffer is
 197                  * owned by a user process, we can't clear it yet.
 198                  */
 199                 spin_lock_irqsave(&dd->pioavail_lock, flags);
 200                 if (test_bit(i, dd->pio_writing) ||
 201                     (!test_bit(i << 1, dd->pioavailkernel) &&
 202                      find_ctxt(dd, i))) {
 203                         __set_bit(i, dd->pio_need_disarm);
 204                         which = 0;
 205                 } else {
 206                         which = 1;
 207                         dd->f_sendctrl(dd->pport, QIB_SENDCTRL_DISARM_BUF(i));
 208                 }
 209                 spin_unlock_irqrestore(&dd->pioavail_lock, flags);
 210         }
 211
 212         /* do cancel_sends once per port that had sdma piobufs in error */
 213         for (i = 0; i < dd->num_pports; i++)
 214                 if (pppd[i])
 215                         qib_cancel_sends(pppd[i]);
 216 }
 217
 218 /**
 219  * update_send_bufs - update shadow copy of the PIO availability map
 220  * @dd: the qlogic_ib device
 221  *
 222  * called whenever our local copy indicates we have run out of send buffers
 223  */
 224 static void update_send_bufs(struct qib_devdata *dd)
 225 {
 226         unsigned long flags;
 227         unsigned i;
 228         const unsigned piobregs = dd->pioavregs;
 229
 230         /*
 231          * If the generation (check) bits have changed, then we update the
 232          * busy bit for the corresponding PIO buffer.  This algorithm will
 233          * modify positions to the value they already have in some cases
 234          * (i.e., no change), but it's faster than changing only the bits
 235          * that have changed.
 236          *
 237          * We would like to do this atomicly, to avoid spinlocks in the
 238          * critical send path, but that's not really possible, given the
 239          * type of changes, and that this routine could be called on
 240          * multiple cpu's simultaneously, so we lock in this routine only,
 241          * to avoid conflicting updates; all we change is the shadow, and
 242          * it's a single 64 bit memory location, so by definition the update
 243          * is atomic in terms of what other cpu's can see in testing the
 244          * bits.  The spin_lock overhead isn't too bad, since it only
 245          * happens when all buffers are in use, so only cpu overhead, not
 246          * latency or bandwidth is affected.
 247          */
 248         if (!dd->pioavailregs_dma)
 249                 return;
 250         spin_lock_irqsave(&dd->pioavail_lock, flags);
 251         for (i = 0; i < piobregs; i++) {
 252                 u64 pchbusy, pchg, piov, pnew;
 253
 254                 piov = le64_to_cpu(dd->pioavailregs_dma[i]);
 255                 pchg = dd->pioavailkernel[i] &
 256                         ~(dd->pioavailshadow[i] ^ piov);
 257                 pchbusy = pchg << QLOGIC_IB_SENDPIOAVAIL_BUSY_SHIFT;
 258                 if (pchg && (pchbusy & dd->pioavailshadow[i])) {
 259                         pnew = dd->pioavailshadow[i] & ~pchbusy;
 260                         pnew |= piov & pchbusy;
 261                         dd->pioavailshadow[i] = pnew;
 262                 }
 263         }
 264         spin_unlock_irqrestore(&dd->pioavail_lock, flags);
 265 }
 266
 267 /*
 268  * Debugging code and stats updates if no pio buffers available.
 269  */
 270 static noinline void no_send_bufs(struct qib_devdata *dd)
 271 {
 272         dd->upd_pio_shadow = 1;
 273
 274         /* not atomic, but if we lose a stat count in a while, that's OK */
 275         qib_stats.sps_nopiobufs++;
 276 }
 277
 278 /*
 279  * Common code for normal driver send buffer allocation, and reserved
 280  * allocation.
 281  *
 282  * Do appropriate marking as busy, etc.
 283  * Returns buffer pointer if one is found, otherwise NULL.
 284  */
 285 u32 __iomem *qib_getsendbuf_range(struct qib_devdata *dd, u32 *pbufnum,
 286                                   u32 first, u32 last)
 287 {
 288         unsigned i, j, updated = 0;
 289         unsigned nbufs;
 290         unsigned long flags;
 291         unsigned long *shadow = dd->pioavailshadow;
 292         u32 __iomem *buf;
 293
 294         if (!(dd->flags & QIB_PRESENT))
 295                 return NULL;
 296
 297         nbufs = last - first + 1; /* number in range to check */
 298         if (dd->upd_pio_shadow) {
 299 update_shadow:
 300                 /*
 301                  * Minor optimization.  If we had no buffers on last call,
 302                  * start out by doing the update; continue and do scan even
 303                  * if no buffers were updated, to be paranoid.
 304                  */
 305                 update_send_bufs(dd);
 306                 updated++;
 307         }
 308         i = first;
 309         /*
 310          * While test_and_set_bit() is atomic, we do that and then the
 311          * change_bit(), and the pair is not.  See if this is the cause
 312          * of the remaining armlaunch errors.
 313          */
 314         spin_lock_irqsave(&dd->pioavail_lock, flags);
 315         if (dd->last_pio >= first && dd->last_pio <= last)
 316                 i = dd->last_pio + 1;
 317         if (!first)
 318                 /* adjust to min possible  */
 319                 nbufs = last - dd->min_kernel_pio + 1;
 320         for (j = 0; j < nbufs; j++, i++) {
 321                 if (i > last)
 322                         i = !first ? dd->min_kernel_pio : first;
 323                 if (__test_and_set_bit((2 * i) + 1, shadow))
 324                         continue;
 325                 /* flip generation bit */
 326                 __change_bit(2 * i, shadow);
 327                 /* remember that the buffer can be written to now */
 328                 __set_bit(i, dd->pio_writing);
 329                 if (!first && first != last) /* first == last on VL15, avoid */
 330                         dd->last_pio = i;
 331                 break;
 332         }
 333         spin_unlock_irqrestore(&dd->pioavail_lock, flags);
 334
 335         if (j == nbufs) {
 336                 if (!updated)
 337                         /*
 338                          * First time through; shadow exhausted, but may be
 339                          * buffers available, try an update and then rescan.
 340                          */
 341                         goto update_shadow;
 342                 no_send_bufs(dd);
 343                 buf = NULL;
 344         } else {
 345                 if (i < dd->piobcnt2k)
 346                         buf = (u32 __iomem *)(dd->pio2kbase +
 347                                 i * dd->palign);
 348                 else if (i < dd->piobcnt2k + dd->piobcnt4k || !dd->piovl15base)
 349                         buf = (u32 __iomem *)(dd->pio4kbase +
 350                                 (i - dd->piobcnt2k) * dd->align4k);
 351                 else
 352                         buf = (u32 __iomem *)(dd->piovl15base +
 353                                 (i - (dd->piobcnt2k + dd->piobcnt4k)) *
 354                                 dd->align4k);
 355                 if (pbufnum)
 356                         *pbufnum = i;
 357                 dd->upd_pio_shadow = 0;
 358         }
 359
 360         return buf;
 361 }
 362
 363 /*
 364  * Record that the caller is finished writing to the buffer so we don't
 365  * disarm it while it is being written and disarm it now if needed.
 366  */
 367 void qib_sendbuf_done(struct qib_devdata *dd, unsigned n)
 368 {
 369         unsigned long flags;
 370
 371         spin_lock_irqsave(&dd->pioavail_lock, flags);
 372         __clear_bit(n, dd->pio_writing);
 373         if (__test_and_clear_bit(n, dd->pio_need_disarm))
 374                 dd->f_sendctrl(dd->pport, QIB_SENDCTRL_DISARM_BUF(n));
 375         spin_unlock_irqrestore(&dd->pioavail_lock, flags);
 376 }
 377
 378 /**
 379  * qib_chg_pioavailkernel - change which send buffers are available for kernel
 380  * @dd: the qlogic_ib device
 381  * @start: the starting send buffer number
 382  * @len: the number of send buffers
 383  * @avail: true if the buffers are available for kernel use, false otherwise
 384  */
 385 void qib_chg_pioavailkernel(struct qib_devdata *dd, unsigned start,
 386         unsigned len, u32 avail, struct qib_ctxtdata *rcd)
 387 {
 388         unsigned long flags;
 389         unsigned end;
 390         unsigned ostart = start;
 391
 392         /* There are two bits per send buffer (busy and generation) */
 393         start *= 2;
 394         end = start + len * 2;
 395
 396         spin_lock_irqsave(&dd->pioavail_lock, flags);
 397         /* Set or clear the busy bit in the shadow. */
 398         while (start < end) {
 399                 if (avail) {
 400                         unsigned long dma;
 401                         int i;
 402
 403                         /*
 404                          * The BUSY bit will never be set, because we disarm
 405                          * the user buffers before we hand them back to the
 406                          * kernel.  We do have to make sure the generation
 407                          * bit is set correctly in shadow, since it could
 408                          * have changed many times while allocated to user.
 409                          * We can't use the bitmap functions on the full
 410                          * dma array because it is always little-endian, so
 411                          * we have to flip to host-order first.
 412                          * BITS_PER_LONG is slightly wrong, since it's
 413                          * always 64 bits per register in chip...
 414                          * We only work on 64 bit kernels, so that's OK.
 415                          */
 416                         i = start / BITS_PER_LONG;
 417                         __clear_bit(QLOGIC_IB_SENDPIOAVAIL_BUSY_SHIFT + start,
 418                                     dd->pioavailshadow);
 419                         dma = (unsigned long)
 420                                 le64_to_cpu(dd->pioavailregs_dma[i]);
 421                         if (test_bit((QLOGIC_IB_SENDPIOAVAIL_CHECK_SHIFT +
 422                                       start) % BITS_PER_LONG, &dma))
 423                                 __set_bit(QLOGIC_IB_SENDPIOAVAIL_CHECK_SHIFT +
 424                                           start, dd->pioavailshadow);
 425                         else
 426                                 __clear_bit(QLOGIC_IB_SENDPIOAVAIL_CHECK_SHIFT
 427                                             + start, dd->pioavailshadow);
 428                         __set_bit(start, dd->pioavailkernel);
 429                         if ((start >> 1) < dd->min_kernel_pio)
 430                                 dd->min_kernel_pio = start >> 1;
 431                 } else {
 432                         __set_bit(start + QLOGIC_IB_SENDPIOAVAIL_BUSY_SHIFT,
 433                                   dd->pioavailshadow);
 434                         __clear_bit(start, dd->pioavailkernel);
 435                         if ((start >> 1) > dd->min_kernel_pio)
 436                                 dd->min_kernel_pio = start >> 1;
 437                 }
 438                 start += 2;
 439         }
 440
 441         if (dd->min_kernel_pio > 0 && dd->last_pio < dd->min_kernel_pio - 1)
 442                 dd->last_pio = dd->min_kernel_pio - 1;
 443         spin_unlock_irqrestore(&dd->pioavail_lock, flags);
 444
 445         dd->f_txchk_change(dd, ostart, len, avail, rcd);
 446 }
 447
 448 /*
 449  * Flush all sends that might be in the ready to send state, as well as any
 450  * that are in the process of being sent.  Used whenever we need to be
 451  * sure the send side is idle.  Cleans up all buffer state by canceling
 452  * all pio buffers, and issuing an abort, which cleans up anything in the
 453  * launch fifo.  The cancel is superfluous on some chip versions, but
 454  * it's safer to always do it.
 455  * PIOAvail bits are updated by the chip as if a normal send had happened.
 456  */
 457 void qib_cancel_sends(struct qib_pportdata *ppd)
 458 {
 459         struct qib_devdata *dd = ppd->dd;
 460         struct qib_ctxtdata *rcd;
 461         unsigned long flags;
 462         unsigned ctxt;
 463         unsigned i;
 464         unsigned last;
 465
 466         /*
 467          * Tell PSM to disarm buffers again before trying to reuse them.
 468          * We need to be sure the rcd doesn't change out from under us
 469          * while we do so.  We hold the two locks sequentially.  We might
 470          * needlessly set some need_disarm bits as a result, if the
 471          * context is closed after we release the uctxt_lock, but that's
 472          * fairly benign, and safer than nesting the locks.
 473          */
 474         for (ctxt = dd->first_user_ctxt; ctxt < dd->cfgctxts; ctxt++) {
 475                 spin_lock_irqsave(&dd->uctxt_lock, flags);
 476                 rcd = dd->rcd[ctxt];
 477                 if (rcd && rcd->ppd == ppd) {
 478                         last = rcd->pio_base + rcd->piocnt;
 479                         if (rcd->user_event_mask) {
 480                                 /*
 481                                  * subctxt_cnt is 0 if not shared, so do base
 482                                  * separately, first, then remaining subctxt,
 483                                  * if any
 484                                  */
 485                                 set_bit(_QIB_EVENT_DISARM_BUFS_BIT,
 486                                         &rcd->user_event_mask[0]);
 487                                 for (i = 1; i < rcd->subctxt_cnt; i++)
 488                                         set_bit(_QIB_EVENT_DISARM_BUFS_BIT,
 489                                                 &rcd->user_event_mask[i]);
 490                         }
 491                         i = rcd->pio_base;
 492                         spin_unlock_irqrestore(&dd->uctxt_lock, flags);
 493                         spin_lock_irqsave(&dd->pioavail_lock, flags);
 494                         for (; i < last; i++)
 495                                 __set_bit(i, dd->pio_need_disarm);
 496                         spin_unlock_irqrestore(&dd->pioavail_lock, flags);
 497                 } else
 498                         spin_unlock_irqrestore(&dd->uctxt_lock, flags);
 499         }
 500
 501         if (!(dd->flags & QIB_HAS_SEND_DMA))
 502                 dd->f_sendctrl(ppd, QIB_SENDCTRL_DISARM_ALL |
 503                                     QIB_SENDCTRL_FLUSH);
 504 }
 505
 506 /*
 507  * Force an update of in-memory copy of the pioavail registers, when
 508  * needed for any of a variety of reasons.
 509  * If already off, this routine is a nop, on the assumption that the
 510  * caller (or set of callers) will "do the right thing".
 511  * This is a per-device operation, so just the first port.
 512  */
 513 void qib_force_pio_avail_update(struct qib_devdata *dd)
 514 {
 515         dd->f_sendctrl(dd->pport, QIB_SENDCTRL_AVAIL_BLIP);
 516 }
 517
 518 void qib_hol_down(struct qib_pportdata *ppd)
 519 {
 520         /*
 521          * Cancel sends when the link goes DOWN so that we aren't doing it
 522          * at INIT when we might be trying to send SMI packets.
 523          */
 524         if (!(ppd->lflags & QIBL_IB_AUTONEG_INPROG))
 525                 qib_cancel_sends(ppd);
 526 }
 527
 528 /*
 529  * Link is at INIT.
 530  * We start the HoL timer so we can detect stuck packets blocking SMP replies.
 531  * Timer may already be running, so use mod_timer, not add_timer.
 532  */
 533 void qib_hol_init(struct qib_pportdata *ppd)
 534 {
 535         if (ppd->hol_state != QIB_HOL_INIT) {
 536                 ppd->hol_state = QIB_HOL_INIT;
 537                 mod_timer(&ppd->hol_timer,
 538                           jiffies + msecs_to_jiffies(qib_hol_timeout_ms));
 539         }
 540 }
 541
 542 /*
 543  * Link is up, continue any user processes, and ensure timer
 544  * is a nop, if running.  Let timer keep running, if set; it
 545  * will nop when it sees the link is up.
 546  */
 547 void qib_hol_up(struct qib_pportdata *ppd)
 548 {
 549         ppd->hol_state = QIB_HOL_UP;
 550 }
 551
 552 /*
 553  * This is only called via the timer.
 554  */
 555 void qib_hol_event(unsigned long opaque)
 556 {
 557         struct qib_pportdata *ppd = (struct qib_pportdata *)opaque;
 558
 559         /* If hardware error, etc, skip. */
 560         if (!(ppd->dd->flags & QIB_INITTED))
 561                 return;
 562
 563         if (ppd->hol_state != QIB_HOL_UP) {
 564                 /*
 565                  * Try to flush sends in case a stuck packet is blocking
 566                  * SMP replies.
 567                  */
 568                 qib_hol_down(ppd);
 569                 mod_timer(&ppd->hol_timer,
 570                           jiffies + msecs_to_jiffies(qib_hol_timeout_ms));
 571         }
 572 }