drivers/scsi/aacraid/src.c

   1 /*
   2  *      Adaptec AAC series RAID controller driver
   3  *      (c) Copyright 2001 Red Hat Inc.
   4  *
   5  * based on the old aacraid driver that is..
   6  * Adaptec aacraid device driver for Linux.
   7  *
   8  * Copyright (c) 2000-2010 Adaptec, Inc.
   9  *               2010 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2, or (at your option)
  14  * any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; see the file COPYING.  If not, write to
  23  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  24  *
  25  * Module Name:
  26  *  src.c
  27  *
  28  * Abstract: Hardware Device Interface for PMC SRC based controllers
  29  *
  30  */
  31
  32 #include <linux/kernel.h>
  33 #include <linux/init.h>
  34 #include <linux/types.h>
  35 #include <linux/pci.h>
  36 #include <linux/spinlock.h>
  37 #include <linux/slab.h>
  38 #include <linux/blkdev.h>
  39 #include <linux/delay.h>
  40 #include <linux/version.h>
  41 #include <linux/completion.h>
  42 #include <linux/time.h>
  43 #include <linux/interrupt.h>
  44 #include <scsi/scsi_host.h>
  45
  46 #include "aacraid.h"
  47
  48 static irqreturn_t aac_src_intr_message(int irq, void *dev_id)
  49 {
  50         struct aac_dev *dev = dev_id;
  51         unsigned long bellbits, bellbits_shifted;
  52         int our_interrupt = 0;
  53         int isFastResponse;
  54         u32 index, handle;
  55
  56         bellbits = src_readl(dev, MUnit.ODR_R);
  57         if (bellbits & PmDoorBellResponseSent) {
  58                 bellbits = PmDoorBellResponseSent;
  59                 /* handle async. status */
  60                 our_interrupt = 1;
  61                 index = dev->host_rrq_idx;
  62                 if (dev->host_rrq[index] == 0) {
  63                         u32 old_index = index;
  64                         /* adjust index */
  65                         do {
  66                                 index++;
  67                                 if (index == dev->scsi_host_ptr->can_queue +
  68                                                         AAC_NUM_MGT_FIB)
  69                                         index = 0;
  70                                 if (dev->host_rrq[index] != 0)
  71                                         break;
  72                         } while (index != old_index);
  73                         dev->host_rrq_idx = index;
  74                 }
  75                 for (;;) {
  76                         isFastResponse = 0;
  77                         /* remove toggle bit (31) */
  78                         handle = (dev->host_rrq[index] & 0x7fffffff);
  79                         /* check fast response bit (30) */
  80                         if (handle & 0x40000000)
  81                                 isFastResponse = 1;
  82                         handle &= 0x0000ffff;
  83                         if (handle == 0)
  84                                 break;
  85
  86                         aac_intr_normal(dev, handle-1, 0, isFastResponse, NULL);
  87
  88                         dev->host_rrq[index++] = 0;
  89                         if (index == dev->scsi_host_ptr->can_queue +
  90                                                 AAC_NUM_MGT_FIB)
  91                                 index = 0;
  92                         dev->host_rrq_idx = index;
  93                 }
  94         } else {
  95                 bellbits_shifted = (bellbits >> SRC_ODR_SHIFT);
  96                 if (bellbits_shifted & DoorBellAifPending) {
  97                         our_interrupt = 1;
  98                         /* handle AIF */
  99                         aac_intr_normal(dev, 0, 2, 0, NULL);
 100                 }
 101         }
 102
 103         if (our_interrupt) {
 104                 src_writel(dev, MUnit.ODR_C, bellbits);
 105                 return IRQ_HANDLED;
 106         }
 107         return IRQ_NONE;
 108 }
 109
 110 /**
 111  *      aac_src_disable_interrupt       -       Disable interrupts
 112  *      @dev: Adapter
 113  */
 114
 115 static void aac_src_disable_interrupt(struct aac_dev *dev)
 116 {
 117         src_writel(dev, MUnit.OIMR, dev->OIMR = 0xffffffff);
 118 }
 119
 120 /**
 121  *      aac_src_enable_interrupt_message        -       Enable interrupts
 122  *      @dev: Adapter
 123  */
 124
 125 static void aac_src_enable_interrupt_message(struct aac_dev *dev)
 126 {
 127         src_writel(dev, MUnit.OIMR, dev->OIMR = 0xfffffff8);
 128 }
 129
 130 /**
 131  *      src_sync_cmd    -       send a command and wait
 132  *      @dev: Adapter
 133  *      @command: Command to execute
 134  *      @p1: first parameter
 135  *      @ret: adapter status
 136  *
 137  *      This routine will send a synchronous command to the adapter and wait
 138  *      for its completion.
 139  */
 140
 141 static int src_sync_cmd(struct aac_dev *dev, u32 command,
 142         u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6,
 143         u32 *status, u32 * r1, u32 * r2, u32 * r3, u32 * r4)
 144 {
 145         unsigned long start;
 146         int ok;
 147
 148         /*
 149          *      Write the command into Mailbox 0
 150          */
 151         writel(command, &dev->IndexRegs->Mailbox[0]);
 152         /*
 153          *      Write the parameters into Mailboxes 1 - 6
 154          */
 155         writel(p1, &dev->IndexRegs->Mailbox[1]);
 156         writel(p2, &dev->IndexRegs->Mailbox[2]);
 157         writel(p3, &dev->IndexRegs->Mailbox[3]);
 158         writel(p4, &dev->IndexRegs->Mailbox[4]);
 159
 160         /*
 161          *      Clear the synch command doorbell to start on a clean slate.
 162          */
 163         src_writel(dev, MUnit.ODR_C, OUTBOUNDDOORBELL_0 << SRC_ODR_SHIFT);
 164
 165         /*
 166          *      Disable doorbell interrupts
 167          */
 168         src_writel(dev, MUnit.OIMR, dev->OIMR = 0xffffffff);
 169
 170         /*
 171          *      Force the completion of the mask register write before issuing
 172          *      the interrupt.
 173          */
 174         src_readl(dev, MUnit.OIMR);
 175
 176         /*
 177          *      Signal that there is a new synch command
 178          */
 179         src_writel(dev, MUnit.IDR, INBOUNDDOORBELL_0 << SRC_IDR_SHIFT);
 180
 181         ok = 0;
 182         start = jiffies;
 183
 184         /*
 185          *      Wait up to 30 seconds
 186          */
 187         while (time_before(jiffies, start+30*HZ)) {
 188                 /* Delay 5 microseconds to let Mon960 get info. */
 189                 udelay(5);
 190
 191                 /* Mon960 will set doorbell0 bit
 192                  * when it has completed the command
 193                  */
 194                 if ((src_readl(dev, MUnit.ODR_R) >> SRC_ODR_SHIFT) & OUTBOUNDDOORBELL_0) {
 195                         /* Clear the doorbell */
 196                         src_writel(dev,
 197                                 MUnit.ODR_C,
 198                                 OUTBOUNDDOORBELL_0 << SRC_ODR_SHIFT);
 199                         ok = 1;
 200                         break;
 201                 }
 202
 203                  /* Yield the processor in case we are slow */
 204                 msleep(1);
 205         }
 206         if (unlikely(ok != 1)) {
 207                  /* Restore interrupt mask even though we timed out */
 208                 aac_adapter_enable_int(dev);
 209                 return -ETIMEDOUT;
 210         }
 211
 212          /* Pull the synch status from Mailbox 0 */
 213         if (status)
 214                 *status = readl(&dev->IndexRegs->Mailbox[0]);
 215         if (r1)
 216                 *r1 = readl(&dev->IndexRegs->Mailbox[1]);
 217         if (r2)
 218                 *r2 = readl(&dev->IndexRegs->Mailbox[2]);
 219         if (r3)
 220                 *r3 = readl(&dev->IndexRegs->Mailbox[3]);
 221         if (r4)
 222                 *r4 = readl(&dev->IndexRegs->Mailbox[4]);
 223
 224          /* Clear the synch command doorbell */
 225         src_writel(dev, MUnit.ODR_C, OUTBOUNDDOORBELL_0 << SRC_ODR_SHIFT);
 226
 227          /* Restore interrupt mask */
 228         aac_adapter_enable_int(dev);
 229         return 0;
 230
 231 }
 232
 233 /**
 234  *      aac_src_interrupt_adapter       -       interrupt adapter
 235  *      @dev: Adapter
 236  *
 237  *      Send an interrupt to the i960 and breakpoint it.
 238  */
 239
 240 static void aac_src_interrupt_adapter(struct aac_dev *dev)
 241 {
 242         src_sync_cmd(dev, BREAKPOINT_REQUEST,
 243                 0, 0, 0, 0, 0, 0,
 244                 NULL, NULL, NULL, NULL, NULL);
 245 }
 246
 247 /**
 248  *      aac_src_notify_adapter          -       send an event to the adapter
 249  *      @dev: Adapter
 250  *      @event: Event to send
 251  *
 252  *      Notify the i960 that something it probably cares about has
 253  *      happened.
 254  */
 255
 256 static void aac_src_notify_adapter(struct aac_dev *dev, u32 event)
 257 {
 258         switch (event) {
 259
 260         case AdapNormCmdQue:
 261                 src_writel(dev, MUnit.ODR_C,
 262                         INBOUNDDOORBELL_1 << SRC_ODR_SHIFT);
 263                 break;
 264         case HostNormRespNotFull:
 265                 src_writel(dev, MUnit.ODR_C,
 266                         INBOUNDDOORBELL_4 << SRC_ODR_SHIFT);
 267                 break;
 268         case AdapNormRespQue:
 269                 src_writel(dev, MUnit.ODR_C,
 270                         INBOUNDDOORBELL_2 << SRC_ODR_SHIFT);
 271                 break;
 272         case HostNormCmdNotFull:
 273                 src_writel(dev, MUnit.ODR_C,
 274                         INBOUNDDOORBELL_3 << SRC_ODR_SHIFT);
 275                 break;
 276         case FastIo:
 277                 src_writel(dev, MUnit.ODR_C,
 278                         INBOUNDDOORBELL_6 << SRC_ODR_SHIFT);
 279                 break;
 280         case AdapPrintfDone:
 281                 src_writel(dev, MUnit.ODR_C,
 282                         INBOUNDDOORBELL_5 << SRC_ODR_SHIFT);
 283                 break;
 284         default:
 285                 BUG();
 286                 break;
 287         }
 288 }
 289
 290 /**
 291  *      aac_src_start_adapter           -       activate adapter
 292  *      @dev:   Adapter
 293  *
 294  *      Start up processing on an i960 based AAC adapter
 295  */
 296
 297 static void aac_src_start_adapter(struct aac_dev *dev)
 298 {
 299         struct aac_init *init;
 300
 301         init = dev->init;
 302         init->HostElapsedSeconds = cpu_to_le32(get_seconds());
 303
 304         /* We can only use a 32 bit address here */
 305         src_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa,
 306           0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
 307 }
 308
 309 /**
 310  *      aac_src_check_health
 311  *      @dev: device to check if healthy
 312  *
 313  *      Will attempt to determine if the specified adapter is alive and
 314  *      capable of handling requests, returning 0 if alive.
 315  */
 316 static int aac_src_check_health(struct aac_dev *dev)
 317 {
 318         u32 status = src_readl(dev, MUnit.OMR);
 319
 320         /*
 321          *      Check to see if the board failed any self tests.
 322          */
 323         if (unlikely(status & SELF_TEST_FAILED))
 324                 return -1;
 325
 326         /*
 327          *      Check to see if the board panic'd.
 328          */
 329         if (unlikely(status & KERNEL_PANIC))
 330                 return (status >> 16) & 0xFF;
 331         /*
 332          *      Wait for the adapter to be up and running.
 333          */
 334         if (unlikely(!(status & KERNEL_UP_AND_RUNNING)))
 335                 return -3;
 336         /*
 337          *      Everything is OK
 338          */
 339         return 0;
 340 }
 341
 342 /**
 343  *      aac_src_deliver_message
 344  *      @fib: fib to issue
 345  *
 346  *      Will send a fib, returning 0 if successful.
 347  */
 348 static int aac_src_deliver_message(struct fib *fib)
 349 {
 350         struct aac_dev *dev = fib->dev;
 351         struct aac_queue *q = &dev->queues->queue[AdapNormCmdQueue];
 352         unsigned long qflags;
 353         u32 fibsize;
 354         u64 address;
 355         struct aac_fib_xporthdr *pFibX;
 356
 357         spin_lock_irqsave(q->lock, qflags);
 358         q->numpending++;
 359         spin_unlock_irqrestore(q->lock, qflags);
 360
 361         /* Calculate the amount to the fibsize bits */
 362         fibsize = (sizeof(struct aac_fib_xporthdr) +
 363                 fib->hw_fib_va->header.Size + 127) / 128 - 1;
 364         if (fibsize > (ALIGN32 - 1))
 365                 fibsize = ALIGN32 - 1;
 366
 367     /* Fill XPORT header */
 368         pFibX = (struct aac_fib_xporthdr *)
 369                 ((unsigned char *)fib->hw_fib_va -
 370                 sizeof(struct aac_fib_xporthdr));
 371         pFibX->Handle = fib->hw_fib_va->header.SenderData + 1;
 372         pFibX->HostAddress = fib->hw_fib_pa;
 373         pFibX->Size = fib->hw_fib_va->header.Size;
 374         address = fib->hw_fib_pa - (u64)sizeof(struct aac_fib_xporthdr);
 375
 376         src_writel(dev, MUnit.IQ_H, (u32)(address >> 32));
 377         src_writel(dev, MUnit.IQ_L, (u32)(address & 0xffffffff) + fibsize);
 378         return 0;
 379 }
 380
 381 /**
 382  *      aac_src_ioremap
 383  *      @size: mapping resize request
 384  *
 385  */
 386 static int aac_src_ioremap(struct aac_dev *dev, u32 size)
 387 {
 388         if (!size) {
 389                 iounmap(dev->regs.src.bar0);
 390                 dev->regs.src.bar0 = NULL;
 391                 iounmap(dev->base);
 392                 dev->base = NULL;
 393                 return 0;
 394         }
 395         dev->regs.src.bar1 = ioremap(pci_resource_start(dev->pdev, 2),
 396                 AAC_MIN_SRC_BAR1_SIZE);
 397         dev->base = NULL;
 398         if (dev->regs.src.bar1 == NULL)
 399                 return -1;
 400         dev->base = dev->regs.src.bar0 = ioremap(dev->scsi_host_ptr->base,
 401                                 size);
 402         if (dev->base == NULL) {
 403                 iounmap(dev->regs.src.bar1);
 404                 dev->regs.src.bar1 = NULL;
 405                 return -1;
 406         }
 407         dev->IndexRegs = &((struct src_registers __iomem *)
 408                 dev->base)->IndexRegs;
 409         return 0;
 410 }
 411
 412 static int aac_src_restart_adapter(struct aac_dev *dev, int bled)
 413 {
 414         u32 var, reset_mask;
 415
 416         if (bled >= 0) {
 417                 if (bled)
 418                         printk(KERN_ERR "%s%d: adapter kernel panic'd %x.\n",
 419                                 dev->name, dev->id, bled);
 420                 bled = aac_adapter_sync_cmd(dev, IOP_RESET_ALWAYS,
 421                         0, 0, 0, 0, 0, 0, &var, &reset_mask, NULL, NULL, NULL);
 422                         if (bled || (var != 0x00000001))
 423                                 bled = -EINVAL;
 424                 if (dev->supplement_adapter_info.SupportedOptions2 &
 425                         AAC_OPTION_DOORBELL_RESET) {
 426                         src_writel(dev, MUnit.IDR, reset_mask);
 427                         msleep(5000); /* Delay 5 seconds */
 428                 }
 429         }
 430
 431         if (src_readl(dev, MUnit.OMR) & KERNEL_PANIC)
 432                 return -ENODEV;
 433
 434         if (startup_timeout < 300)
 435                 startup_timeout = 300;
 436
 437         return 0;
 438 }
 439
 440 /**
 441  *      aac_src_select_comm     -       Select communications method
 442  *      @dev: Adapter
 443  *      @comm: communications method
 444  */
 445 int aac_src_select_comm(struct aac_dev *dev, int comm)
 446 {
 447         switch (comm) {
 448         case AAC_COMM_MESSAGE:
 449                 dev->a_ops.adapter_enable_int = aac_src_enable_interrupt_message;
 450                 dev->a_ops.adapter_intr = aac_src_intr_message;
 451                 dev->a_ops.adapter_deliver = aac_src_deliver_message;
 452                 break;
 453         default:
 454                 return 1;
 455         }
 456         return 0;
 457 }
 458
 459 /**
 460  *  aac_src_init        -       initialize an Cardinal Frey Bar card
 461  *  @dev: device to configure
 462  *
 463  */
 464
 465 int aac_src_init(struct aac_dev *dev)
 466 {
 467         unsigned long start;
 468         unsigned long status;
 469         int restart = 0;
 470         int instance = dev->id;
 471         const char *name = dev->name;
 472
 473         dev->a_ops.adapter_ioremap = aac_src_ioremap;
 474         dev->a_ops.adapter_comm = aac_src_select_comm;
 475
 476         dev->base_size = AAC_MIN_SRC_BAR0_SIZE;
 477         if (aac_adapter_ioremap(dev, dev->base_size)) {
 478                 printk(KERN_WARNING "%s: unable to map adapter.\n", name);
 479                 goto error_iounmap;
 480         }
 481
 482         /* Failure to reset here is an option ... */
 483         dev->a_ops.adapter_sync_cmd = src_sync_cmd;
 484         dev->a_ops.adapter_enable_int = aac_src_disable_interrupt;
 485         if ((aac_reset_devices || reset_devices) &&
 486                 !aac_src_restart_adapter(dev, 0))
 487                 ++restart;
 488         /*
 489          *      Check to see if the board panic'd while booting.
 490          */
 491         status = src_readl(dev, MUnit.OMR);
 492         if (status & KERNEL_PANIC) {
 493                 if (aac_src_restart_adapter(dev, aac_src_check_health(dev)))
 494                         goto error_iounmap;
 495                 ++restart;
 496         }
 497         /*
 498          *      Check to see if the board failed any self tests.
 499          */
 500         status = src_readl(dev, MUnit.OMR);
 501         if (status & SELF_TEST_FAILED) {
 502                 printk(KERN_ERR "%s%d: adapter self-test failed.\n",
 503                         dev->name, instance);
 504                 goto error_iounmap;
 505         }
 506         /*
 507          *      Check to see if the monitor panic'd while booting.
 508          */
 509         if (status & MONITOR_PANIC) {
 510                 printk(KERN_ERR "%s%d: adapter monitor panic.\n",
 511                         dev->name, instance);
 512                 goto error_iounmap;
 513         }
 514         start = jiffies;
 515         /*
 516          *      Wait for the adapter to be up and running. Wait up to 3 minutes
 517          */
 518         while (!((status = src_readl(dev, MUnit.OMR)) &
 519                 KERNEL_UP_AND_RUNNING)) {
 520                 if ((restart &&
 521                   (status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC))) ||
 522                   time_after(jiffies, start+HZ*startup_timeout)) {
 523                         printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %lx.\n",
 524                                         dev->name, instance, status);
 525                         goto error_iounmap;
 526                 }
 527                 if (!restart &&
 528                   ((status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC)) ||
 529                   time_after(jiffies, start + HZ *
 530                   ((startup_timeout > 60)
 531                     ? (startup_timeout - 60)
 532                     : (startup_timeout / 2))))) {
 533                         if (likely(!aac_src_restart_adapter(dev,
 534                             aac_src_check_health(dev))))
 535                                 start = jiffies;
 536                         ++restart;
 537                 }
 538                 msleep(1);
 539         }
 540         if (restart && aac_commit)
 541                 aac_commit = 1;
 542         /*
 543          *      Fill in the common function dispatch table.
 544          */
 545         dev->a_ops.adapter_interrupt = aac_src_interrupt_adapter;
 546         dev->a_ops.adapter_disable_int = aac_src_disable_interrupt;
 547         dev->a_ops.adapter_notify = aac_src_notify_adapter;
 548         dev->a_ops.adapter_sync_cmd = src_sync_cmd;
 549         dev->a_ops.adapter_check_health = aac_src_check_health;
 550         dev->a_ops.adapter_restart = aac_src_restart_adapter;
 551
 552         /*
 553          *      First clear out all interrupts.  Then enable the one's that we
 554          *      can handle.
 555          */
 556         aac_adapter_comm(dev, AAC_COMM_MESSAGE);
 557         aac_adapter_disable_int(dev);
 558         src_writel(dev, MUnit.ODR_C, 0xffffffff);
 559         aac_adapter_enable_int(dev);
 560
 561         if (aac_init_adapter(dev) == NULL)
 562                 goto error_iounmap;
 563         if (dev->comm_interface != AAC_COMM_MESSAGE_TYPE1)
 564                 goto error_iounmap;
 565
 566         dev->msi = aac_msi && !pci_enable_msi(dev->pdev);
 567
 568         if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr,
 569                         IRQF_SHARED|IRQF_DISABLED, "aacraid", dev) < 0) {
 570
 571                 if (dev->msi)
 572                         pci_disable_msi(dev->pdev);
 573
 574                 printk(KERN_ERR "%s%d: Interrupt unavailable.\n",
 575                         name, instance);
 576                 goto error_iounmap;
 577         }
 578         dev->dbg_base = pci_resource_start(dev->pdev, 2);
 579         dev->dbg_base_mapped = dev->regs.src.bar1;
 580         dev->dbg_size = AAC_MIN_SRC_BAR1_SIZE;
 581
 582         aac_adapter_enable_int(dev);
 583         /*
 584          *      Tell the adapter that all is configured, and it can
 585          * start accepting requests
 586          */
 587         aac_src_start_adapter(dev);
 588
 589         return 0;
 590
 591 error_iounmap:
 592
 593         return -1;
 594 }