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 * commsup.c 27 * 28 * Abstract: Contain all routines that are required for FSA host/adapter 29 * communication. 30 * 31 */ 32 33#include <linux/kernel.h> 34#include <linux/init.h> 35#include <linux/types.h> 36#include <linux/sched.h> 37#include <linux/pci.h> 38#include <linux/spinlock.h> 39#include <linux/slab.h> 40#include <linux/completion.h> 41#include <linux/blkdev.h> 42#include <linux/delay.h> 43#include <linux/kthread.h> 44#include <linux/interrupt.h> 45#include <linux/semaphore.h> 46#include <scsi/scsi.h> 47#include <scsi/scsi_host.h> 48#include <scsi/scsi_device.h> 49#include <scsi/scsi_cmnd.h> 50 51#include "aacraid.h" 52 53/** 54 * fib_map_alloc - allocate the fib objects 55 * @dev: Adapter to allocate for 56 * 57 * Allocate and map the shared PCI space for the FIB blocks used to 58 * talk to the Adaptec firmware. 59 */ 60 61static int fib_map_alloc(struct aac_dev *dev) 62{ 63 dprintk((KERN_INFO 64 "allocate hardware fibs pci_alloc_consistent(%p, %d * (%d + %d), %p)\n", 65 dev->pdev, dev->max_fib_size, dev->scsi_host_ptr->can_queue, 66 AAC_NUM_MGT_FIB, &dev->hw_fib_pa)); 67 dev->hw_fib_va = pci_alloc_consistent(dev->pdev, 68 (dev->max_fib_size + sizeof(struct aac_fib_xporthdr)) 69 * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB) + (ALIGN32 - 1), 70 &dev->hw_fib_pa); 71 if (dev->hw_fib_va == NULL) 72 return -ENOMEM; 73 return 0; 74} 75 76/** 77 * aac_fib_map_free - free the fib objects 78 * @dev: Adapter to free 79 * 80 * Free the PCI mappings and the memory allocated for FIB blocks 81 * on this adapter. 82 */ 83 84void aac_fib_map_free(struct aac_dev *dev) 85{ 86 pci_free_consistent(dev->pdev, 87 dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB), 88 dev->hw_fib_va, dev->hw_fib_pa); 89 dev->hw_fib_va = NULL; 90 dev->hw_fib_pa = 0; 91} 92 93/** 94 * aac_fib_setup - setup the fibs 95 * @dev: Adapter to set up 96 * 97 * Allocate the PCI space for the fibs, map it and then initialise the 98 * fib area, the unmapped fib data and also the free list 99 */ 100 101int aac_fib_setup(struct aac_dev * dev) 102{ 103 struct fib *fibptr; 104 struct hw_fib *hw_fib; 105 dma_addr_t hw_fib_pa; 106 int i; 107 108 while (((i = fib_map_alloc(dev)) == -ENOMEM) 109 && (dev->scsi_host_ptr->can_queue > (64 - AAC_NUM_MGT_FIB))) { 110 dev->init->MaxIoCommands = cpu_to_le32((dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB) >> 1); 111 dev->scsi_host_ptr->can_queue = le32_to_cpu(dev->init->MaxIoCommands) - AAC_NUM_MGT_FIB; 112 } 113 if (i<0) 114 return -ENOMEM; 115 116 /* 32 byte alignment for PMC */ 117 hw_fib_pa = (dev->hw_fib_pa + (ALIGN32 - 1)) & ~(ALIGN32 - 1); 118 dev->hw_fib_va = (struct hw_fib *)((unsigned char *)dev->hw_fib_va + 119 (hw_fib_pa - dev->hw_fib_pa)); 120 dev->hw_fib_pa = hw_fib_pa; 121 memset(dev->hw_fib_va, 0, 122 (dev->max_fib_size + sizeof(struct aac_fib_xporthdr)) * 123 (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB)); 124 125 /* add Xport header */ 126 dev->hw_fib_va = (struct hw_fib *)((unsigned char *)dev->hw_fib_va + 127 sizeof(struct aac_fib_xporthdr)); 128 dev->hw_fib_pa += sizeof(struct aac_fib_xporthdr); 129 130 hw_fib = dev->hw_fib_va; 131 hw_fib_pa = dev->hw_fib_pa; 132 /* 133 * Initialise the fibs 134 */ 135 for (i = 0, fibptr = &dev->fibs[i]; 136 i < (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); 137 i++, fibptr++) 138 { 139 fibptr->flags = 0; 140 fibptr->dev = dev; 141 fibptr->hw_fib_va = hw_fib; 142 fibptr->data = (void *) fibptr->hw_fib_va->data; 143 fibptr->next = fibptr+1; /* Forward chain the fibs */ 144 sema_init(&fibptr->event_wait, 0); 145 spin_lock_init(&fibptr->event_lock); 146 hw_fib->header.XferState = cpu_to_le32(0xffffffff); 147 hw_fib->header.SenderSize = cpu_to_le16(dev->max_fib_size); 148 fibptr->hw_fib_pa = hw_fib_pa; 149 hw_fib = (struct hw_fib *)((unsigned char *)hw_fib + 150 dev->max_fib_size + sizeof(struct aac_fib_xporthdr)); 151 hw_fib_pa = hw_fib_pa + 152 dev->max_fib_size + sizeof(struct aac_fib_xporthdr); 153 } 154 /* 155 * Add the fib chain to the free list 156 */ 157 dev->fibs[dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB - 1].next = NULL; 158 /* 159 * Enable this to debug out of queue space 160 */ 161 dev->free_fib = &dev->fibs[0]; 162 return 0; 163} 164 165/** 166 * aac_fib_alloc - allocate a fib 167 * @dev: Adapter to allocate the fib for 168 * 169 * Allocate a fib from the adapter fib pool. If the pool is empty we 170 * return NULL. 171 */ 172 173struct fib *aac_fib_alloc(struct aac_dev *dev) 174{ 175 struct fib * fibptr; 176 unsigned long flags; 177 spin_lock_irqsave(&dev->fib_lock, flags); 178 fibptr = dev->free_fib; 179 if(!fibptr){ 180 spin_unlock_irqrestore(&dev->fib_lock, flags); 181 return fibptr; 182 } 183 dev->free_fib = fibptr->next; 184 spin_unlock_irqrestore(&dev->fib_lock, flags); 185 /* 186 * Set the proper node type code and node byte size 187 */ 188 fibptr->type = FSAFS_NTC_FIB_CONTEXT; 189 fibptr->size = sizeof(struct fib); 190 /* 191 * Null out fields that depend on being zero at the start of 192 * each I/O 193 */ 194 fibptr->hw_fib_va->header.XferState = 0; 195 fibptr->flags = 0; 196 fibptr->callback = NULL; 197 fibptr->callback_data = NULL; 198 199 return fibptr; 200} 201 202/** 203 * aac_fib_free - free a fib 204 * @fibptr: fib to free up 205 * 206 * Frees up a fib and places it on the appropriate queue 207 */ 208 209void aac_fib_free(struct fib *fibptr) 210{ 211 unsigned long flags, flagsv; 212 213 spin_lock_irqsave(&fibptr->event_lock, flagsv); 214 if (fibptr->done == 2) { 215 spin_unlock_irqrestore(&fibptr->event_lock, flagsv); 216 return; 217 } 218 spin_unlock_irqrestore(&fibptr->event_lock, flagsv); 219 220 spin_lock_irqsave(&fibptr->dev->fib_lock, flags); 221 if (unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) 222 aac_config.fib_timeouts++; 223 if (fibptr->hw_fib_va->header.XferState != 0) { 224 printk(KERN_WARNING "aac_fib_free, XferState != 0, fibptr = 0x%p, XferState = 0x%x\n", 225 (void*)fibptr, 226 le32_to_cpu(fibptr->hw_fib_va->header.XferState)); 227 } 228 fibptr->next = fibptr->dev->free_fib; 229 fibptr->dev->free_fib = fibptr; 230 spin_unlock_irqrestore(&fibptr->dev->fib_lock, flags); 231} 232 233/** 234 * aac_fib_init - initialise a fib 235 * @fibptr: The fib to initialize 236 * 237 * Set up the generic fib fields ready for use 238 */ 239 240void aac_fib_init(struct fib *fibptr) 241{ 242 struct hw_fib *hw_fib = fibptr->hw_fib_va; 243 244 memset(&hw_fib->header, 0, sizeof(struct aac_fibhdr)); 245 hw_fib->header.StructType = FIB_MAGIC; 246 hw_fib->header.Size = cpu_to_le16(fibptr->dev->max_fib_size); 247 hw_fib->header.XferState = cpu_to_le32(HostOwned | FibInitialized | FibEmpty | FastResponseCapable); 248 hw_fib->header.u.ReceiverFibAddress = cpu_to_le32(fibptr->hw_fib_pa); 249 hw_fib->header.SenderSize = cpu_to_le16(fibptr->dev->max_fib_size); 250} 251 252/** 253 * fib_deallocate - deallocate a fib 254 * @fibptr: fib to deallocate 255 * 256 * Will deallocate and return to the free pool the FIB pointed to by the 257 * caller. 258 */ 259 260static void fib_dealloc(struct fib * fibptr) 261{ 262 struct hw_fib *hw_fib = fibptr->hw_fib_va; 263 hw_fib->header.XferState = 0; 264} 265 266/* 267 * Commuication primitives define and support the queuing method we use to 268 * support host to adapter commuication. All queue accesses happen through 269 * these routines and are the only routines which have a knowledge of the 270 * how these queues are implemented. 271 */ 272 273/** 274 * aac_get_entry - get a queue entry 275 * @dev: Adapter 276 * @qid: Queue Number 277 * @entry: Entry return 278 * @index: Index return 279 * @nonotify: notification control 280 * 281 * With a priority the routine returns a queue entry if the queue has free entries. If the queue 282 * is full(no free entries) than no entry is returned and the function returns 0 otherwise 1 is 283 * returned. 284 */ 285 286static int aac_get_entry (struct aac_dev * dev, u32 qid, struct aac_entry **entry, u32 * index, unsigned long *nonotify) 287{ 288 struct aac_queue * q; 289 unsigned long idx; 290 291 /* 292 * All of the queues wrap when they reach the end, so we check 293 * to see if they have reached the end and if they have we just 294 * set the index back to zero. This is a wrap. You could or off 295 * the high bits in all updates but this is a bit faster I think. 296 */ 297 298 q = &dev->queues->queue[qid]; 299 300 idx = *index = le32_to_cpu(*(q->headers.producer)); 301 /* Interrupt Moderation, only interrupt for first two entries */ 302 if (idx != le32_to_cpu(*(q->headers.consumer))) { 303 if (--idx == 0) { 304 if (qid == AdapNormCmdQueue) 305 idx = ADAP_NORM_CMD_ENTRIES; 306 else 307 idx = ADAP_NORM_RESP_ENTRIES; 308 } 309 if (idx != le32_to_cpu(*(q->headers.consumer))) 310 *nonotify = 1; 311 } 312 313 if (qid == AdapNormCmdQueue) { 314 if (*index >= ADAP_NORM_CMD_ENTRIES) 315 *index = 0; /* Wrap to front of the Producer Queue. */ 316 } else { 317 if (*index >= ADAP_NORM_RESP_ENTRIES) 318 *index = 0; /* Wrap to front of the Producer Queue. */ 319 } 320 321 /* Queue is full */ 322 if ((*index + 1) == le32_to_cpu(*(q->headers.consumer))) { 323 printk(KERN_WARNING "Queue %d full, %u outstanding.\n", 324 qid, q->numpending); 325 return 0; 326 } else { 327 *entry = q->base + *index; 328 return 1; 329 } 330} 331 332/** 333 * aac_queue_get - get the next free QE 334 * @dev: Adapter 335 * @index: Returned index 336 * @priority: Priority of fib 337 * @fib: Fib to associate with the queue entry 338 * @wait: Wait if queue full 339 * @fibptr: Driver fib object to go with fib 340 * @nonotify: Don't notify the adapter 341 * 342 * Gets the next free QE off the requested priorty adapter command 343 * queue and associates the Fib with the QE. The QE represented by 344 * index is ready to insert on the queue when this routine returns 345 * success. 346 */ 347 348int aac_queue_get(struct aac_dev * dev, u32 * index, u32 qid, struct hw_fib * hw_fib, int wait, struct fib * fibptr, unsigned long *nonotify) 349{ 350 struct aac_entry * entry = NULL; 351 int map = 0; 352 353 if (qid == AdapNormCmdQueue) { 354 /* if no entries wait for some if caller wants to */ 355 while (!aac_get_entry(dev, qid, &entry, index, nonotify)) { 356 printk(KERN_ERR "GetEntries failed\n"); 357 } 358 /* 359 * Setup queue entry with a command, status and fib mapped 360 */ 361 entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size)); 362 map = 1; 363 } else { 364 while (!aac_get_entry(dev, qid, &entry, index, nonotify)) { 365 /* if no entries wait for some if caller wants to */ 366 } 367 /* 368 * Setup queue entry with command, status and fib mapped 369 */ 370 entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size)); 371 entry->addr = hw_fib->header.SenderFibAddress; 372 /* Restore adapters pointer to the FIB */ 373 hw_fib->header.u.ReceiverFibAddress = hw_fib->header.SenderFibAddress; /* Let the adapter now where to find its data */ 374 map = 0; 375 } 376 /* 377 * If MapFib is true than we need to map the Fib and put pointers 378 * in the queue entry. 379 */ 380 if (map) 381 entry->addr = cpu_to_le32(fibptr->hw_fib_pa); 382 return 0; 383} 384 385/* 386 * Define the highest level of host to adapter communication routines. 387 * These routines will support host to adapter FS commuication. These 388 * routines have no knowledge of the commuication method used. This level 389 * sends and receives FIBs. This level has no knowledge of how these FIBs 390 * get passed back and forth. 391 */ 392 393/** 394 * aac_fib_send - send a fib to the adapter 395 * @command: Command to send 396 * @fibptr: The fib 397 * @size: Size of fib data area 398 * @priority: Priority of Fib 399 * @wait: Async/sync select 400 * @reply: True if a reply is wanted 401 * @callback: Called with reply 402 * @callback_data: Passed to callback 403 * 404 * Sends the requested FIB to the adapter and optionally will wait for a 405 * response FIB. If the caller does not wish to wait for a response than 406 * an event to wait on must be supplied. This event will be set when a 407 * response FIB is received from the adapter. 408 */ 409 410int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size, 411 int priority, int wait, int reply, fib_callback callback, 412 void *callback_data) 413{ 414 struct aac_dev * dev = fibptr->dev; 415 struct hw_fib * hw_fib = fibptr->hw_fib_va; 416 unsigned long flags = 0; 417 unsigned long qflags; 418 unsigned long mflags = 0; 419 unsigned long sflags = 0; 420 421 422 if (!(hw_fib->header.XferState & cpu_to_le32(HostOwned))) 423 return -EBUSY; 424 /* 425 * There are 5 cases with the wait and response requested flags. 426 * The only invalid cases are if the caller requests to wait and 427 * does not request a response and if the caller does not want a 428 * response and the Fib is not allocated from pool. If a response 429 * is not requesed the Fib will just be deallocaed by the DPC 430 * routine when the response comes back from the adapter. No 431 * further processing will be done besides deleting the Fib. We 432 * will have a debug mode where the adapter can notify the host 433 * it had a problem and the host can log that fact. 434 */ 435 fibptr->flags = 0; 436 if (wait && !reply) { 437 return -EINVAL; 438 } else if (!wait && reply) { 439 hw_fib->header.XferState |= cpu_to_le32(Async | ResponseExpected); 440 FIB_COUNTER_INCREMENT(aac_config.AsyncSent); 441 } else if (!wait && !reply) { 442 hw_fib->header.XferState |= cpu_to_le32(NoResponseExpected); 443 FIB_COUNTER_INCREMENT(aac_config.NoResponseSent); 444 } else if (wait && reply) { 445 hw_fib->header.XferState |= cpu_to_le32(ResponseExpected); 446 FIB_COUNTER_INCREMENT(aac_config.NormalSent); 447 } 448 /* 449 * Map the fib into 32bits by using the fib number 450 */ 451 452 hw_fib->header.SenderFibAddress = cpu_to_le32(((u32)(fibptr - dev->fibs)) << 2); 453 hw_fib->header.Handle = (u32)(fibptr - dev->fibs) + 1; 454 /* 455 * Set FIB state to indicate where it came from and if we want a 456 * response from the adapter. Also load the command from the 457 * caller. 458 * 459 * Map the hw fib pointer as a 32bit value 460 */ 461 hw_fib->header.Command = cpu_to_le16(command); 462 hw_fib->header.XferState |= cpu_to_le32(SentFromHost); 463 /* 464 * Set the size of the Fib we want to send to the adapter 465 */ 466 hw_fib->header.Size = cpu_to_le16(sizeof(struct aac_fibhdr) + size); 467 if (le16_to_cpu(hw_fib->header.Size) > le16_to_cpu(hw_fib->header.SenderSize)) { 468 return -EMSGSIZE; 469 } 470 /* 471 * Get a queue entry connect the FIB to it and send an notify 472 * the adapter a command is ready. 473 */ 474 hw_fib->header.XferState |= cpu_to_le32(NormalPriority); 475 476 /* 477 * Fill in the Callback and CallbackContext if we are not 478 * going to wait. 479 */ 480 if (!wait) { 481 fibptr->callback = callback; 482 fibptr->callback_data = callback_data; 483 fibptr->flags = FIB_CONTEXT_FLAG; 484 } 485 486 fibptr->done = 0; 487 488 FIB_COUNTER_INCREMENT(aac_config.FibsSent); 489 490 dprintk((KERN_DEBUG "Fib contents:.\n")); 491 dprintk((KERN_DEBUG " Command = %d.\n", le32_to_cpu(hw_fib->header.Command))); 492 dprintk((KERN_DEBUG " SubCommand = %d.\n", le32_to_cpu(((struct aac_query_mount *)fib_data(fibptr))->command))); 493 dprintk((KERN_DEBUG " XferState = %x.\n", le32_to_cpu(hw_fib->header.XferState))); 494 dprintk((KERN_DEBUG " hw_fib va being sent=%p\n",fibptr->hw_fib_va)); 495 dprintk((KERN_DEBUG " hw_fib pa being sent=%lx\n",(ulong)fibptr->hw_fib_pa)); 496 dprintk((KERN_DEBUG " fib being sent=%p\n",fibptr)); 497 498 if (!dev->queues) 499 return -EBUSY; 500 501 if (wait) { 502 503 spin_lock_irqsave(&dev->manage_lock, mflags); 504 if (dev->management_fib_count >= AAC_NUM_MGT_FIB) { 505 printk(KERN_INFO "No management Fibs Available:%d\n", 506 dev->management_fib_count); 507 spin_unlock_irqrestore(&dev->manage_lock, mflags); 508 return -EBUSY; 509 } 510 dev->management_fib_count++; 511 spin_unlock_irqrestore(&dev->manage_lock, mflags); 512 spin_lock_irqsave(&fibptr->event_lock, flags); 513 } 514 515 if (dev->sync_mode) { 516 if (wait) 517 spin_unlock_irqrestore(&fibptr->event_lock, flags); 518 spin_lock_irqsave(&dev->sync_lock, sflags); 519 if (dev->sync_fib) { 520 list_add_tail(&fibptr->fiblink, &dev->sync_fib_list); 521 spin_unlock_irqrestore(&dev->sync_lock, sflags); 522 } else { 523 dev->sync_fib = fibptr; 524 spin_unlock_irqrestore(&dev->sync_lock, sflags); 525 aac_adapter_sync_cmd(dev, SEND_SYNCHRONOUS_FIB, 526 (u32)fibptr->hw_fib_pa, 0, 0, 0, 0, 0, 527 NULL, NULL, NULL, NULL, NULL); 528 } 529 if (wait) { 530 fibptr->flags |= FIB_CONTEXT_FLAG_WAIT; 531 if (down_interruptible(&fibptr->event_wait)) { 532 fibptr->flags &= ~FIB_CONTEXT_FLAG_WAIT; 533 return -EFAULT; 534 } 535 return 0; 536 } 537 return -EINPROGRESS; 538 } 539 540 if (aac_adapter_deliver(fibptr) != 0) { 541 printk(KERN_ERR "aac_fib_send: returned -EBUSY\n"); 542 if (wait) { 543 spin_unlock_irqrestore(&fibptr->event_lock, flags); 544 spin_lock_irqsave(&dev->manage_lock, mflags); 545 dev->management_fib_count--; 546 spin_unlock_irqrestore(&dev->manage_lock, mflags); 547 } 548 return -EBUSY; 549 } 550 551 552 /* 553 * If the caller wanted us to wait for response wait now. 554 */ 555 556 if (wait) { 557 spin_unlock_irqrestore(&fibptr->event_lock, flags); 558 /* Only set for first known interruptable command */ 559 if (wait < 0) { 560 /* 561 * *VERY* Dangerous to time out a command, the 562 * assumption is made that we have no hope of 563 * functioning because an interrupt routing or other 564 * hardware failure has occurred. 565 */ 566 unsigned long timeout = jiffies + (180 * HZ); /* 3 minutes */ 567 while (down_trylock(&fibptr->event_wait)) { 568 int blink; 569 if (time_is_before_eq_jiffies(timeout)) { 570 struct aac_queue * q = &dev->queues->queue[AdapNormCmdQueue]; 571 spin_lock_irqsave(q->lock, qflags); 572 q->numpending--; 573 spin_unlock_irqrestore(q->lock, qflags); 574 if (wait == -1) { 575 printk(KERN_ERR "aacraid: aac_fib_send: first asynchronous command timed out.\n" 576 "Usually a result of a PCI interrupt routing problem;\n" 577 "update mother board BIOS or consider utilizing one of\n" 578 "the SAFE mode kernel options (acpi, apic etc)\n"); 579 } 580 return -ETIMEDOUT; 581 } 582 if ((blink = aac_adapter_check_health(dev)) > 0) { 583 if (wait == -1) { 584 printk(KERN_ERR "aacraid: aac_fib_send: adapter blinkLED 0x%x.\n" 585 "Usually a result of a serious unrecoverable hardware problem\n", 586 blink); 587 } 588 return -EFAULT; 589 } 590 /* We used to udelay() here but that absorbed 591 * a CPU when a timeout occured. Not very 592 * useful. */ 593 cpu_relax(); 594 } 595 } else if (down_interruptible(&fibptr->event_wait)) { 596 /* Do nothing ... satisfy 597 * down_interruptible must_check */ 598 } 599 600 spin_lock_irqsave(&fibptr->event_lock, flags); 601 if (fibptr->done == 0) { 602 fibptr->done = 2; /* Tell interrupt we aborted */ 603 spin_unlock_irqrestore(&fibptr->event_lock, flags); 604 return -ERESTARTSYS; 605 } 606 spin_unlock_irqrestore(&fibptr->event_lock, flags); 607 BUG_ON(fibptr->done == 0); 608 609 if(unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) 610 return -ETIMEDOUT; 611 return 0; 612 } 613 /* 614 * If the user does not want a response than return success otherwise 615 * return pending 616 */ 617 if (reply) 618 return -EINPROGRESS; 619 else 620 return 0; 621} 622 623/** 624 * aac_consumer_get - get the top of the queue 625 * @dev: Adapter 626 * @q: Queue 627 * @entry: Return entry 628 * 629 * Will return a pointer to the entry on the top of the queue requested that 630 * we are a consumer of, and return the address of the queue entry. It does 631 * not change the state of the queue. 632 */ 633 634int aac_consumer_get(struct aac_dev * dev, struct aac_queue * q, struct aac_entry **entry) 635{ 636 u32 index; 637 int status; 638 if (le32_to_cpu(*q->headers.producer) == le32_to_cpu(*q->headers.consumer)) { 639 status = 0; 640 } else { 641 /* 642 * The consumer index must be wrapped if we have reached 643 * the end of the queue, else we just use the entry 644 * pointed to by the header index 645 */ 646 if (le32_to_cpu(*q->headers.consumer) >= q->entries) 647 index = 0; 648 else 649 index = le32_to_cpu(*q->headers.consumer); 650 *entry = q->base + index; 651 status = 1; 652 } 653 return(status); 654} 655 656/** 657 * aac_consumer_free - free consumer entry 658 * @dev: Adapter 659 * @q: Queue 660 * @qid: Queue ident 661 * 662 * Frees up the current top of the queue we are a consumer of. If the 663 * queue was full notify the producer that the queue is no longer full. 664 */ 665 666void aac_consumer_free(struct aac_dev * dev, struct aac_queue *q, u32 qid) 667{ 668 int wasfull = 0; 669 u32 notify; 670 671 if ((le32_to_cpu(*q->headers.producer)+1) == le32_to_cpu(*q->headers.consumer)) 672 wasfull = 1; 673 674 if (le32_to_cpu(*q->headers.consumer) >= q->entries) 675 *q->headers.consumer = cpu_to_le32(1); 676 else 677 le32_add_cpu(q->headers.consumer, 1); 678 679 if (wasfull) { 680 switch (qid) { 681 682 case HostNormCmdQueue: 683 notify = HostNormCmdNotFull; 684 break; 685 case HostNormRespQueue: 686 notify = HostNormRespNotFull; 687 break; 688 default: 689 BUG(); 690 return; 691 } 692 aac_adapter_notify(dev, notify); 693 } 694} 695 696/** 697 * aac_fib_adapter_complete - complete adapter issued fib 698 * @fibptr: fib to complete 699 * @size: size of fib 700 * 701 * Will do all necessary work to complete a FIB that was sent from 702 * the adapter. 703 */ 704 705int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size) 706{ 707 struct hw_fib * hw_fib = fibptr->hw_fib_va; 708 struct aac_dev * dev = fibptr->dev; 709 struct aac_queue * q; 710 unsigned long nointr = 0; 711 unsigned long qflags; 712 713 if (dev->comm_interface == AAC_COMM_MESSAGE_TYPE1 || 714 dev->comm_interface == AAC_COMM_MESSAGE_TYPE2) { 715 kfree(hw_fib); 716 return 0; 717 } 718 719 if (hw_fib->header.XferState == 0) { 720 if (dev->comm_interface == AAC_COMM_MESSAGE) 721 kfree(hw_fib); 722 return 0; 723 } 724 /* 725 * If we plan to do anything check the structure type first. 726 */ 727 if (hw_fib->header.StructType != FIB_MAGIC && 728 hw_fib->header.StructType != FIB_MAGIC2 && 729 hw_fib->header.StructType != FIB_MAGIC2_64) { 730 if (dev->comm_interface == AAC_COMM_MESSAGE) 731 kfree(hw_fib); 732 return -EINVAL; 733 } 734 /* 735 * This block handles the case where the adapter had sent us a 736 * command and we have finished processing the command. We 737 * call completeFib when we are done processing the command 738 * and want to send a response back to the adapter. This will 739 * send the completed cdb to the adapter. 740 */ 741 if (hw_fib->header.XferState & cpu_to_le32(SentFromAdapter)) { 742 if (dev->comm_interface == AAC_COMM_MESSAGE) { 743 kfree (hw_fib); 744 } else { 745 u32 index; 746 hw_fib->header.XferState |= cpu_to_le32(HostProcessed); 747 if (size) { 748 size += sizeof(struct aac_fibhdr); 749 if (size > le16_to_cpu(hw_fib->header.SenderSize)) 750 return -EMSGSIZE; 751 hw_fib->header.Size = cpu_to_le16(size); 752 } 753 q = &dev->queues->queue[AdapNormRespQueue]; 754 spin_lock_irqsave(q->lock, qflags); 755 aac_queue_get(dev, &index, AdapNormRespQueue, hw_fib, 1, NULL, &nointr); 756 *(q->headers.producer) = cpu_to_le32(index + 1); 757 spin_unlock_irqrestore(q->lock, qflags); 758 if (!(nointr & (int)aac_config.irq_mod)) 759 aac_adapter_notify(dev, AdapNormRespQueue); 760 } 761 } else { 762 printk(KERN_WARNING "aac_fib_adapter_complete: " 763 "Unknown xferstate detected.\n"); 764 BUG(); 765 } 766 return 0; 767} 768 769/** 770 * aac_fib_complete - fib completion handler 771 * @fib: FIB to complete 772 * 773 * Will do all necessary work to complete a FIB. 774 */ 775 776int aac_fib_complete(struct fib *fibptr) 777{ 778 unsigned long flags; 779 struct hw_fib * hw_fib = fibptr->hw_fib_va; 780 781 /* 782 * Check for a fib which has already been completed 783 */ 784 785 if (hw_fib->header.XferState == 0) 786 return 0; 787 /* 788 * If we plan to do anything check the structure type first. 789 */ 790 791 if (hw_fib->header.StructType != FIB_MAGIC && 792 hw_fib->header.StructType != FIB_MAGIC2 && 793 hw_fib->header.StructType != FIB_MAGIC2_64) 794 return -EINVAL; 795 /* 796 * This block completes a cdb which orginated on the host and we 797 * just need to deallocate the cdb or reinit it. At this point the 798 * command is complete that we had sent to the adapter and this 799 * cdb could be reused. 800 */ 801 spin_lock_irqsave(&fibptr->event_lock, flags); 802 if (fibptr->done == 2) { 803 spin_unlock_irqrestore(&fibptr->event_lock, flags); 804 return 0; 805 } 806 spin_unlock_irqrestore(&fibptr->event_lock, flags); 807 808 if((hw_fib->header.XferState & cpu_to_le32(SentFromHost)) && 809 (hw_fib->header.XferState & cpu_to_le32(AdapterProcessed))) 810 { 811 fib_dealloc(fibptr); 812 } 813 else if(hw_fib->header.XferState & cpu_to_le32(SentFromHost)) 814 { 815 /* 816 * This handles the case when the host has aborted the I/O 817 * to the adapter because the adapter is not responding 818 */ 819 fib_dealloc(fibptr); 820 } else if(hw_fib->header.XferState & cpu_to_le32(HostOwned)) { 821 fib_dealloc(fibptr); 822 } else { 823 BUG(); 824 } 825 return 0; 826} 827 828/** 829 * aac_printf - handle printf from firmware 830 * @dev: Adapter 831 * @val: Message info 832 * 833 * Print a message passed to us by the controller firmware on the 834 * Adaptec board 835 */ 836 837void aac_printf(struct aac_dev *dev, u32 val) 838{ 839 char *cp = dev->printfbuf; 840 if (dev->printf_enabled) 841 { 842 int length = val & 0xffff; 843 int level = (val >> 16) & 0xffff; 844 845 /* 846 * The size of the printfbuf is set in port.c 847 * There is no variable or define for it 848 */ 849 if (length > 255) 850 length = 255; 851 if (cp[length] != 0) 852 cp[length] = 0; 853 if (level == LOG_AAC_HIGH_ERROR) 854 printk(KERN_WARNING "%s:%s", dev->name, cp); 855 else 856 printk(KERN_INFO "%s:%s", dev->name, cp); 857 } 858 memset(cp, 0, 256); 859} 860 861 862/** 863 * aac_handle_aif - Handle a message from the firmware 864 * @dev: Which adapter this fib is from 865 * @fibptr: Pointer to fibptr from adapter 866 * 867 * This routine handles a driver notify fib from the adapter and 868 * dispatches it to the appropriate routine for handling. 869 */ 870 871#define AIF_SNIFF_TIMEOUT (30*HZ) 872static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr) 873{ 874 struct hw_fib * hw_fib = fibptr->hw_fib_va; 875 struct aac_aifcmd * aifcmd = (struct aac_aifcmd *)hw_fib->data; 876 u32 channel, id, lun, container; 877 struct scsi_device *device; 878 enum { 879 NOTHING, 880 DELETE, 881 ADD, 882 CHANGE 883 } device_config_needed = NOTHING; 884 885 /* Sniff for container changes */ 886 887 if (!dev || !dev->fsa_dev) 888 return; 889 container = channel = id = lun = (u32)-1; 890 891 /* 892 * We have set this up to try and minimize the number of 893 * re-configures that take place. As a result of this when 894 * certain AIF's come in we will set a flag waiting for another 895 * type of AIF before setting the re-config flag. 896 */ 897 switch (le32_to_cpu(aifcmd->command)) { 898 case AifCmdDriverNotify: 899 switch (le32_to_cpu(((__le32 *)aifcmd->data)[0])) { 900 /* 901 * Morph or Expand complete 902 */ 903 case AifDenMorphComplete: 904 case AifDenVolumeExtendComplete: 905 container = le32_to_cpu(((__le32 *)aifcmd->data)[1]); 906 if (container >= dev->maximum_num_containers) 907 break; 908 909 /* 910 * Find the scsi_device associated with the SCSI 911 * address. Make sure we have the right array, and if 912 * so set the flag to initiate a new re-config once we 913 * see an AifEnConfigChange AIF come through. 914 */ 915 916 if ((dev != NULL) && (dev->scsi_host_ptr != NULL)) { 917 device = scsi_device_lookup(dev->scsi_host_ptr, 918 CONTAINER_TO_CHANNEL(container), 919 CONTAINER_TO_ID(container), 920 CONTAINER_TO_LUN(container)); 921 if (device) { 922 dev->fsa_dev[container].config_needed = CHANGE; 923 dev->fsa_dev[container].config_waiting_on = AifEnConfigChange; 924 dev->fsa_dev[container].config_waiting_stamp = jiffies; 925 scsi_device_put(device); 926 } 927 } 928 } 929 930 /* 931 * If we are waiting on something and this happens to be 932 * that thing then set the re-configure flag. 933 */ 934 if (container != (u32)-1) { 935 if (container >= dev->maximum_num_containers) 936 break; 937 if ((dev->fsa_dev[container].config_waiting_on == 938 le32_to_cpu(*(__le32 *)aifcmd->data)) && 939 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) 940 dev->fsa_dev[container].config_waiting_on = 0; 941 } else for (container = 0; 942 container < dev->maximum_num_containers; ++container) { 943 if ((dev->fsa_dev[container].config_waiting_on == 944 le32_to_cpu(*(__le32 *)aifcmd->data)) && 945 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) 946 dev->fsa_dev[container].config_waiting_on = 0; 947 } 948 break; 949 950 case AifCmdEventNotify: 951 switch (le32_to_cpu(((__le32 *)aifcmd->data)[0])) { 952 case AifEnBatteryEvent: 953 dev->cache_protected = 954 (((__le32 *)aifcmd->data)[1] == cpu_to_le32(3)); 955 break; 956 /* 957 * Add an Array. 958 */ 959 case AifEnAddContainer: 960 container = le32_to_cpu(((__le32 *)aifcmd->data)[1]); 961 if (container >= dev->maximum_num_containers) 962 break; 963 dev->fsa_dev[container].config_needed = ADD; 964 dev->fsa_dev[container].config_waiting_on = 965 AifEnConfigChange; 966 dev->fsa_dev[container].config_waiting_stamp = jiffies; 967 break; 968 969 /* 970 * Delete an Array. 971 */ 972 case AifEnDeleteContainer: 973 container = le32_to_cpu(((__le32 *)aifcmd->data)[1]); 974 if (container >= dev->maximum_num_containers) 975 break; 976 dev->fsa_dev[container].config_needed = DELETE; 977 dev->fsa_dev[container].config_waiting_on = 978 AifEnConfigChange; 979 dev->fsa_dev[container].config_waiting_stamp = jiffies; 980 break; 981 982 /* 983 * Container change detected. If we currently are not 984 * waiting on something else, setup to wait on a Config Change. 985 */ 986 case AifEnContainerChange: 987 container = le32_to_cpu(((__le32 *)aifcmd->data)[1]); 988 if (container >= dev->maximum_num_containers) 989 break; 990 if (dev->fsa_dev[container].config_waiting_on && 991 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) 992 break; 993 dev->fsa_dev[container].config_needed = CHANGE; 994 dev->fsa_dev[container].config_waiting_on = 995 AifEnConfigChange; 996 dev->fsa_dev[container].config_waiting_stamp = jiffies; 997 break; 998 999 case AifEnConfigChange: 1000 break; 1001 1002 case AifEnAddJBOD: 1003 case AifEnDeleteJBOD: 1004 container = le32_to_cpu(((__le32 *)aifcmd->data)[1]); 1005 if ((container >> 28)) { 1006 container = (u32)-1; 1007 break; 1008 } 1009 channel = (container >> 24) & 0xF; 1010 if (channel >= dev->maximum_num_channels) { 1011 container = (u32)-1; 1012 break; 1013 } 1014 id = container & 0xFFFF; 1015 if (id >= dev->maximum_num_physicals) { 1016 container = (u32)-1; 1017 break; 1018 } 1019 lun = (container >> 16) & 0xFF; 1020 container = (u32)-1; 1021 channel = aac_phys_to_logical(channel); 1022 device_config_needed = 1023 (((__le32 *)aifcmd->data)[0] == 1024 cpu_to_le32(AifEnAddJBOD)) ? ADD : DELETE; 1025 if (device_config_needed == ADD) { 1026 device = scsi_device_lookup(dev->scsi_host_ptr, 1027 channel, 1028 id, 1029 lun); 1030 if (device) { 1031 scsi_remove_device(device); 1032 scsi_device_put(device); 1033 } 1034 } 1035 break; 1036 1037 case AifEnEnclosureManagement: 1038 /* 1039 * If in JBOD mode, automatic exposure of new 1040 * physical target to be suppressed until configured. 1041 */ 1042 if (dev->jbod) 1043 break; 1044 switch (le32_to_cpu(((__le32 *)aifcmd->data)[3])) { 1045 case EM_DRIVE_INSERTION: 1046 case EM_DRIVE_REMOVAL: 1047 container = le32_to_cpu( 1048 ((__le32 *)aifcmd->data)[2]); 1049 if ((container >> 28)) { 1050 container = (u32)-1; 1051 break; 1052 } 1053 channel = (container >> 24) & 0xF; 1054 if (channel >= dev->maximum_num_channels) { 1055 container = (u32)-1; 1056 break; 1057 } 1058 id = container & 0xFFFF; 1059 lun = (container >> 16) & 0xFF; 1060 container = (u32)-1; 1061 if (id >= dev->maximum_num_physicals) { 1062 /* legacy dev_t ? */ 1063 if ((0x2000 <= id) || lun || channel || 1064 ((channel = (id >> 7) & 0x3F) >= 1065 dev->maximum_num_channels)) 1066 break; 1067 lun = (id >> 4) & 7; 1068 id &= 0xF; 1069 } 1070 channel = aac_phys_to_logical(channel); 1071 device_config_needed = 1072 (((__le32 *)aifcmd->data)[3] 1073 == cpu_to_le32(EM_DRIVE_INSERTION)) ? 1074 ADD : DELETE; 1075 break; 1076 } 1077 break; 1078 } 1079 1080 /* 1081 * If we are waiting on something and this happens to be 1082 * that thing then set the re-configure flag. 1083 */ 1084 if (container != (u32)-1) { 1085 if (container >= dev->maximum_num_containers) 1086 break; 1087 if ((dev->fsa_dev[container].config_waiting_on == 1088 le32_to_cpu(*(__le32 *)aifcmd->data)) && 1089 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) 1090 dev->fsa_dev[container].config_waiting_on = 0; 1091 } else for (container = 0; 1092 container < dev->maximum_num_containers; ++container) { 1093 if ((dev->fsa_dev[container].config_waiting_on == 1094 le32_to_cpu(*(__le32 *)aifcmd->data)) && 1095 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) 1096 dev->fsa_dev[container].config_waiting_on = 0; 1097 } 1098 break; 1099 1100 case AifCmdJobProgress: 1101 /* 1102 * These are job progress AIF's. When a Clear is being 1103 * done on a container it is initially created then hidden from 1104 * the OS. When the clear completes we don't get a config 1105 * change so we monitor the job status complete on a clear then 1106 * wait for a container change. 1107 */ 1108 1109 if (((__le32 *)aifcmd->data)[1] == cpu_to_le32(AifJobCtrZero) && 1110 (((__le32 *)aifcmd->data)[6] == ((__le32 *)aifcmd->data)[5] || 1111 ((__le32 *)aifcmd->data)[4] == cpu_to_le32(AifJobStsSuccess))) { 1112 for (container = 0; 1113 container < dev->maximum_num_containers; 1114 ++container) { 1115 /* 1116 * Stomp on all config sequencing for all 1117 * containers? 1118 */ 1119 dev->fsa_dev[container].config_waiting_on = 1120 AifEnContainerChange; 1121 dev->fsa_dev[container].config_needed = ADD; 1122 dev->fsa_dev[container].config_waiting_stamp = 1123 jiffies; 1124 } 1125 } 1126 if (((__le32 *)aifcmd->data)[1] == cpu_to_le32(AifJobCtrZero) && 1127 ((__le32 *)aifcmd->data)[6] == 0 && 1128 ((__le32 *)aifcmd->data)[4] == cpu_to_le32(AifJobStsRunning)) { 1129 for (container = 0; 1130 container < dev->maximum_num_containers; 1131 ++container) { 1132 /* 1133 * Stomp on all config sequencing for all 1134 * containers? 1135 */ 1136 dev->fsa_dev[container].config_waiting_on = 1137 AifEnContainerChange; 1138 dev->fsa_dev[container].config_needed = DELETE; 1139 dev->fsa_dev[container].config_waiting_stamp = 1140 jiffies; 1141 } 1142 } 1143 break; 1144 } 1145 1146 container = 0; 1147retry_next: 1148 if (device_config_needed == NOTHING) 1149 for (; container < dev->maximum_num_containers; ++container) { 1150 if ((dev->fsa_dev[container].config_waiting_on == 0) && 1151 (dev->fsa_dev[container].config_needed != NOTHING) && 1152 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) { 1153 device_config_needed = 1154 dev->fsa_dev[container].config_needed; 1155 dev->fsa_dev[container].config_needed = NOTHING; 1156 channel = CONTAINER_TO_CHANNEL(container); 1157 id = CONTAINER_TO_ID(container); 1158 lun = CONTAINER_TO_LUN(container); 1159 break; 1160 } 1161 } 1162 if (device_config_needed == NOTHING) 1163 return; 1164 1165 /* 1166 * If we decided that a re-configuration needs to be done, 1167 * schedule it here on the way out the door, please close the door 1168 * behind you. 1169 */ 1170 1171 /* 1172 * Find the scsi_device associated with the SCSI address, 1173 * and mark it as changed, invalidating the cache. This deals 1174 * with changes to existing device IDs. 1175 */ 1176 1177 if (!dev || !dev->scsi_host_ptr) 1178 return; 1179 /* 1180 * force reload of disk info via aac_probe_container 1181 */ 1182 if ((channel == CONTAINER_CHANNEL) && 1183 (device_config_needed != NOTHING)) { 1184 if (dev->fsa_dev[container].valid == 1) 1185 dev->fsa_dev[container].valid = 2; 1186 aac_probe_container(dev, container); 1187 } 1188 device = scsi_device_lookup(dev->scsi_host_ptr, channel, id, lun); 1189 if (device) { 1190 switch (device_config_needed) { 1191 case DELETE: 1192#if (defined(AAC_DEBUG_INSTRUMENT_AIF_DELETE)) 1193 scsi_remove_device(device); 1194#else 1195 if (scsi_device_online(device)) { 1196 scsi_device_set_state(device, SDEV_OFFLINE); 1197 sdev_printk(KERN_INFO, device, 1198 "Device offlined - %s\n", 1199 (channel == CONTAINER_CHANNEL) ? 1200 "array deleted" : 1201 "enclosure services event"); 1202 } 1203#endif 1204 break; 1205 case ADD: 1206 if (!scsi_device_online(device)) { 1207 sdev_printk(KERN_INFO, device, 1208 "Device online - %s\n", 1209 (channel == CONTAINER_CHANNEL) ? 1210 "array created" : 1211 "enclosure services event"); 1212 scsi_device_set_state(device, SDEV_RUNNING); 1213 } 1214 /* FALLTHRU */ 1215 case CHANGE: 1216 if ((channel == CONTAINER_CHANNEL) 1217 && (!dev->fsa_dev[container].valid)) { 1218#if (defined(AAC_DEBUG_INSTRUMENT_AIF_DELETE)) 1219 scsi_remove_device(device); 1220#else 1221 if (!scsi_device_online(device)) 1222 break; 1223 scsi_device_set_state(device, SDEV_OFFLINE); 1224 sdev_printk(KERN_INFO, device, 1225 "Device offlined - %s\n", 1226 "array failed"); 1227#endif 1228 break; 1229 } 1230 scsi_rescan_device(&device->sdev_gendev); 1231 1232 default: 1233 break; 1234 } 1235 scsi_device_put(device); 1236 device_config_needed = NOTHING; 1237 } 1238 if (device_config_needed == ADD) 1239 scsi_add_device(dev->scsi_host_ptr, channel, id, lun); 1240 if (channel == CONTAINER_CHANNEL) { 1241 container++; 1242 device_config_needed = NOTHING; 1243 goto retry_next; 1244 } 1245} 1246 1247static int _aac_reset_adapter(struct aac_dev *aac, int forced) 1248{ 1249 int index, quirks; 1250 int retval; 1251 struct Scsi_Host *host; 1252 struct scsi_device *dev; 1253 struct scsi_cmnd *command; 1254 struct scsi_cmnd *command_list; 1255 int jafo = 0; 1256 1257 /* 1258 * Assumptions: 1259 * - host is locked, unless called by the aacraid thread. 1260 * (a matter of convenience, due to legacy issues surrounding 1261 * eh_host_adapter_reset). 1262 * - in_reset is asserted, so no new i/o is getting to the 1263 * card. 1264 * - The card is dead, or will be very shortly ;-/ so no new 1265 * commands are completing in the interrupt service. 1266 */ 1267 host = aac->scsi_host_ptr; 1268 scsi_block_requests(host); 1269 aac_adapter_disable_int(aac); 1270 if (aac->thread->pid != current->pid) { 1271 spin_unlock_irq(host->host_lock); 1272 kthread_stop(aac->thread); 1273 jafo = 1; 1274 } 1275 1276 /* 1277 * If a positive health, means in a known DEAD PANIC 1278 * state and the adapter could be reset to `try again'. 1279 */ 1280 retval = aac_adapter_restart(aac, forced ? 0 : aac_adapter_check_health(aac)); 1281 1282 if (retval) 1283 goto out; 1284 1285 /* 1286 * Loop through the fibs, close the synchronous FIBS 1287 */ 1288 for (retval = 1, index = 0; index < (aac->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); index++) { 1289 struct fib *fib = &aac->fibs[index]; 1290 if (!(fib->hw_fib_va->header.XferState & cpu_to_le32(NoResponseExpected | Async)) && 1291 (fib->hw_fib_va->header.XferState & cpu_to_le32(ResponseExpected))) { 1292 unsigned long flagv; 1293 spin_lock_irqsave(&fib->event_lock, flagv); 1294 up(&fib->event_wait); 1295 spin_unlock_irqrestore(&fib->event_lock, flagv); 1296 schedule(); 1297 retval = 0; 1298 } 1299 } 1300 /* Give some extra time for ioctls to complete. */ 1301 if (retval == 0) 1302 ssleep(2); 1303 index = aac->cardtype; 1304 1305 /* 1306 * Re-initialize the adapter, first free resources, then carefully 1307 * apply the initialization sequence to come back again. Only risk 1308 * is a change in Firmware dropping cache, it is assumed the caller 1309 * will ensure that i/o is queisced and the card is flushed in that 1310 * case. 1311 */ 1312 aac_fib_map_free(aac); 1313 pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys); 1314 aac->comm_addr = NULL; 1315 aac->comm_phys = 0; 1316 kfree(aac->queues); 1317 aac->queues = NULL; 1318 free_irq(aac->pdev->irq, aac); 1319 if (aac->msi) 1320 pci_disable_msi(aac->pdev); 1321 kfree(aac->fsa_dev); 1322 aac->fsa_dev = NULL; 1323 quirks = aac_get_driver_ident(index)->quirks; 1324 if (quirks & AAC_QUIRK_31BIT) { 1325 if (((retval = pci_set_dma_mask(aac->pdev, DMA_BIT_MASK(31)))) || 1326 ((retval = pci_set_consistent_dma_mask(aac->pdev, DMA_BIT_MASK(31))))) 1327 goto out; 1328 } else { 1329 if (((retval = pci_set_dma_mask(aac->pdev, DMA_BIT_MASK(32)))) || 1330 ((retval = pci_set_consistent_dma_mask(aac->pdev, DMA_BIT_MASK(32))))) 1331 goto out; 1332 } 1333 if ((retval = (*(aac_get_driver_ident(index)->init))(aac))) 1334 goto out; 1335 if (quirks & AAC_QUIRK_31BIT) 1336 if ((retval = pci_set_dma_mask(aac->pdev, DMA_BIT_MASK(32)))) 1337 goto out; 1338 if (jafo) { 1339 aac->thread = kthread_run(aac_command_thread, aac, "%s", 1340 aac->name); 1341 if (IS_ERR(aac->thread)) { 1342 retval = PTR_ERR(aac->thread); 1343 goto out; 1344 } 1345 } 1346 (void)aac_get_adapter_info(aac); 1347 if ((quirks & AAC_QUIRK_34SG) && (host->sg_tablesize > 34)) { 1348 host->sg_tablesize = 34; 1349 host->max_sectors = (host->sg_tablesize * 8) + 112; 1350 } 1351 if ((quirks & AAC_QUIRK_17SG) && (host->sg_tablesize > 17)) { 1352 host->sg_tablesize = 17; 1353 host->max_sectors = (host->sg_tablesize * 8) + 112; 1354 } 1355 aac_get_config_status(aac, 1); 1356 aac_get_containers(aac); 1357 /* 1358 * This is where the assumption that the Adapter is quiesced 1359 * is important. 1360 */ 1361 command_list = NULL; 1362 __shost_for_each_device(dev, host) { 1363 unsigned long flags; 1364 spin_lock_irqsave(&dev->list_lock, flags); 1365 list_for_each_entry(command, &dev->cmd_list, list) 1366 if (command->SCp.phase == AAC_OWNER_FIRMWARE) { 1367 command->SCp.buffer = (struct scatterlist *)command_list; 1368 command_list = command; 1369 } 1370 spin_unlock_irqrestore(&dev->list_lock, flags); 1371 } 1372 while ((command = command_list)) { 1373 command_list = (struct scsi_cmnd *)command->SCp.buffer; 1374 command->SCp.buffer = NULL; 1375 command->result = DID_OK << 16 1376 | COMMAND_COMPLETE << 8 1377 | SAM_STAT_TASK_SET_FULL; 1378 command->SCp.phase = AAC_OWNER_ERROR_HANDLER; 1379 command->scsi_done(command); 1380 } 1381 retval = 0; 1382 1383out: 1384 aac->in_reset = 0; 1385 scsi_unblock_requests(host); 1386 if (jafo) { 1387 spin_lock_irq(host->host_lock); 1388 } 1389 return retval; 1390} 1391 1392int aac_reset_adapter(struct aac_dev * aac, int forced) 1393{ 1394 unsigned long flagv = 0; 1395 int retval; 1396 struct Scsi_Host * host; 1397 1398 if (spin_trylock_irqsave(&aac->fib_lock, flagv) == 0) 1399 return -EBUSY; 1400 1401 if (aac->in_reset) { 1402 spin_unlock_irqrestore(&aac->fib_lock, flagv); 1403 return -EBUSY; 1404 } 1405 aac->in_reset = 1; 1406 spin_unlock_irqrestore(&aac->fib_lock, flagv); 1407 1408 /* 1409 * Wait for all commands to complete to this specific 1410 * target (block maximum 60 seconds). Although not necessary, 1411 * it does make us a good storage citizen. 1412 */ 1413 host = aac->scsi_host_ptr; 1414 scsi_block_requests(host); 1415 if (forced < 2) for (retval = 60; retval; --retval) { 1416 struct scsi_device * dev; 1417 struct scsi_cmnd * command; 1418 int active = 0; 1419 1420 __shost_for_each_device(dev, host) { 1421 spin_lock_irqsave(&dev->list_lock, flagv); 1422 list_for_each_entry(command, &dev->cmd_list, list) { 1423 if (command->SCp.phase == AAC_OWNER_FIRMWARE) { 1424 active++; 1425 break; 1426 } 1427 } 1428 spin_unlock_irqrestore(&dev->list_lock, flagv); 1429 if (active) 1430 break; 1431 1432 } 1433 /* 1434 * We can exit If all the commands are complete 1435 */ 1436 if (active == 0) 1437 break; 1438 ssleep(1); 1439 } 1440 1441 /* Quiesce build, flush cache, write through mode */ 1442 if (forced < 2) 1443 aac_send_shutdown(aac); 1444 spin_lock_irqsave(host->host_lock, flagv); 1445 retval = _aac_reset_adapter(aac, forced ? forced : ((aac_check_reset != 0) && (aac_check_reset != 1))); 1446 spin_unlock_irqrestore(host->host_lock, flagv); 1447 1448 if ((forced < 2) && (retval == -ENODEV)) { 1449 /* Unwind aac_send_shutdown() IOP_RESET unsupported/disabled */ 1450 struct fib * fibctx = aac_fib_alloc(aac); 1451 if (fibctx) { 1452 struct aac_pause *cmd; 1453 int status; 1454 1455 aac_fib_init(fibctx); 1456 1457 cmd = (struct aac_pause *) fib_data(fibctx); 1458 1459 cmd->command = cpu_to_le32(VM_ContainerConfig); 1460 cmd->type = cpu_to_le32(CT_PAUSE_IO); 1461 cmd->timeout = cpu_to_le32(1); 1462 cmd->min = cpu_to_le32(1); 1463 cmd->noRescan = cpu_to_le32(1); 1464 cmd->count = cpu_to_le32(0); 1465 1466 status = aac_fib_send(ContainerCommand, 1467 fibctx, 1468 sizeof(struct aac_pause), 1469 FsaNormal, 1470 -2 /* Timeout silently */, 1, 1471 NULL, NULL); 1472 1473 if (status >= 0) 1474 aac_fib_complete(fibctx); 1475 /* FIB should be freed only after getting 1476 * the response from the F/W */ 1477 if (status != -ERESTARTSYS) 1478 aac_fib_free(fibctx); 1479 } 1480 } 1481 1482 return retval; 1483} 1484 1485int aac_check_health(struct aac_dev * aac) 1486{ 1487 int BlinkLED; 1488 unsigned long time_now, flagv = 0; 1489 struct list_head * entry; 1490 struct Scsi_Host * host; 1491 1492 /* Extending the scope of fib_lock slightly to protect aac->in_reset */ 1493 if (spin_trylock_irqsave(&aac->fib_lock, flagv) == 0) 1494 return 0; 1495 1496 if (aac->in_reset || !(BlinkLED = aac_adapter_check_health(aac))) { 1497 spin_unlock_irqrestore(&aac->fib_lock, flagv); 1498 return 0; /* OK */ 1499 } 1500 1501 aac->in_reset = 1; 1502 1503 /* Fake up an AIF: 1504 * aac_aifcmd.command = AifCmdEventNotify = 1 1505 * aac_aifcmd.seqnum = 0xFFFFFFFF 1506 * aac_aifcmd.data[0] = AifEnExpEvent = 23 1507 * aac_aifcmd.data[1] = AifExeFirmwarePanic = 3 1508 * aac.aifcmd.data[2] = AifHighPriority = 3 1509 * aac.aifcmd.data[3] = BlinkLED 1510 */ 1511 1512 time_now = jiffies/HZ; 1513 entry = aac->fib_list.next; 1514 1515 /* 1516 * For each Context that is on the 1517 * fibctxList, make a copy of the 1518 * fib, and then set the event to wake up the 1519 * thread that is waiting for it. 1520 */ 1521 while (entry != &aac->fib_list) { 1522 /* 1523 * Extract the fibctx 1524 */ 1525 struct aac_fib_context *fibctx = list_entry(entry, struct aac_fib_context, next); 1526 struct hw_fib * hw_fib; 1527 struct fib * fib; 1528 /* 1529 * Check if the queue is getting 1530 * backlogged 1531 */ 1532 if (fibctx->count > 20) { 1533 /* 1534 * It's *not* jiffies folks, 1535 * but jiffies / HZ, so do not 1536 * panic ... 1537 */ 1538 u32 time_last = fibctx->jiffies; 1539 /* 1540 * Has it been > 2 minutes 1541 * since the last read off 1542 * the queue? 1543 */ 1544 if ((time_now - time_last) > aif_timeout) { 1545 entry = entry->next; 1546 aac_close_fib_context(aac, fibctx); 1547 continue; 1548 } 1549 } 1550 /* 1551 * Warning: no sleep allowed while 1552 * holding spinlock 1553 */ 1554 hw_fib = kzalloc(sizeof(struct hw_fib), GFP_ATOMIC); 1555 fib = kzalloc(sizeof(struct fib), GFP_ATOMIC); 1556 if (fib && hw_fib) { 1557 struct aac_aifcmd * aif; 1558 1559 fib->hw_fib_va = hw_fib; 1560 fib->dev = aac; 1561 aac_fib_init(fib); 1562 fib->type = FSAFS_NTC_FIB_CONTEXT; 1563 fib->size = sizeof (struct fib); 1564 fib->data = hw_fib->data; 1565 aif = (struct aac_aifcmd *)hw_fib->data; 1566 aif->command = cpu_to_le32(AifCmdEventNotify); 1567 aif->seqnum = cpu_to_le32(0xFFFFFFFF); 1568 ((__le32 *)aif->data)[0] = cpu_to_le32(AifEnExpEvent); 1569 ((__le32 *)aif->data)[1] = cpu_to_le32(AifExeFirmwarePanic); 1570 ((__le32 *)aif->data)[2] = cpu_to_le32(AifHighPriority); 1571 ((__le32 *)aif->data)[3] = cpu_to_le32(BlinkLED); 1572 1573 /* 1574 * Put the FIB onto the 1575 * fibctx's fibs 1576 */ 1577 list_add_tail(&fib->fiblink, &fibctx->fib_list); 1578 fibctx->count++; 1579 /* 1580 * Set the event to wake up the 1581 * thread that will waiting. 1582 */ 1583 up(&fibctx->wait_sem); 1584 } else { 1585 printk(KERN_WARNING "aifd: didn't allocate NewFib.\n"); 1586 kfree(fib); 1587 kfree(hw_fib); 1588 } 1589 entry = entry->next; 1590 } 1591 1592 spin_unlock_irqrestore(&aac->fib_lock, flagv); 1593 1594 if (BlinkLED < 0) { 1595 printk(KERN_ERR "%s: Host adapter dead %d\n", aac->name, BlinkLED); 1596 goto out; 1597 } 1598 1599 printk(KERN_ERR "%s: Host adapter BLINK LED 0x%x\n", aac->name, BlinkLED); 1600 1601 if (!aac_check_reset || ((aac_check_reset == 1) && 1602 (aac->supplement_adapter_info.SupportedOptions2 & 1603 AAC_OPTION_IGNORE_RESET))) 1604 goto out; 1605 host = aac->scsi_host_ptr; 1606 if (aac->thread->pid != current->pid) 1607 spin_lock_irqsave(host->host_lock, flagv); 1608 BlinkLED = _aac_reset_adapter(aac, aac_check_reset != 1); 1609 if (aac->thread->pid != current->pid) 1610 spin_unlock_irqrestore(host->host_lock, flagv); 1611 return BlinkLED; 1612 1613out: 1614 aac->in_reset = 0; 1615 return BlinkLED; 1616} 1617 1618 1619/** 1620 * aac_command_thread - command processing thread 1621 * @dev: Adapter to monitor 1622 * 1623 * Waits on the commandready event in it's queue. When the event gets set 1624 * it will pull FIBs off it's queue. It will continue to pull FIBs off 1625 * until the queue is empty. When the queue is empty it will wait for 1626 * more FIBs. 1627 */ 1628 1629int aac_command_thread(void *data) 1630{ 1631 struct aac_dev *dev = data; 1632 struct hw_fib *hw_fib, *hw_newfib; 1633 struct fib *fib, *newfib; 1634 struct aac_fib_context *fibctx; 1635 unsigned long flags; 1636 DECLARE_WAITQUEUE(wait, current); 1637 unsigned long next_jiffies = jiffies + HZ; 1638 unsigned long next_check_jiffies = next_jiffies; 1639 long difference = HZ; 1640 1641 /* 1642 * We can only have one thread per adapter for AIF's. 1643 */ 1644 if (dev->aif_thread) 1645 return -EINVAL; 1646 1647 /* 1648 * Let the DPC know it has a place to send the AIF's to. 1649 */ 1650 dev->aif_thread = 1; 1651 add_wait_queue(&dev->queues->queue[HostNormCmdQueue].cmdready, &wait); 1652 set_current_state(TASK_INTERRUPTIBLE); 1653 dprintk ((KERN_INFO "aac_command_thread start\n")); 1654 while (1) { 1655 spin_lock_irqsave(dev->queues->queue[HostNormCmdQueue].lock, flags); 1656 while(!list_empty(&(dev->queues->queue[HostNormCmdQueue].cmdq))) { 1657 struct list_head *entry; 1658 struct aac_aifcmd * aifcmd; 1659 1660 set_current_state(TASK_RUNNING); 1661 1662 entry = dev->queues->queue[HostNormCmdQueue].cmdq.next; 1663 list_del(entry); 1664 1665 spin_unlock_irqrestore(dev->queues->queue[HostNormCmdQueue].lock, flags); 1666 fib = list_entry(entry, struct fib, fiblink); 1667 /* 1668 * We will process the FIB here or pass it to a 1669 * worker thread that is TBD. We Really can't 1670 * do anything at this point since we don't have 1671 * anything defined for this thread to do. 1672 */ 1673 hw_fib = fib->hw_fib_va; 1674 memset(fib, 0, sizeof(struct fib)); 1675 fib->type = FSAFS_NTC_FIB_CONTEXT; 1676 fib->size = sizeof(struct fib); 1677 fib->hw_fib_va = hw_fib; 1678 fib->data = hw_fib->data; 1679 fib->dev = dev; 1680 /* 1681 * We only handle AifRequest fibs from the adapter. 1682 */ 1683 aifcmd = (struct aac_aifcmd *) hw_fib->data; 1684 if (aifcmd->command == cpu_to_le32(AifCmdDriverNotify)) { 1685 /* Handle Driver Notify Events */ 1686 aac_handle_aif(dev, fib); 1687 *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK); 1688 aac_fib_adapter_complete(fib, (u16)sizeof(u32)); 1689 } else { 1690 /* The u32 here is important and intended. We are using 1691 32bit wrapping time to fit the adapter field */ 1692 1693 u32 time_now, time_last; 1694 unsigned long flagv; 1695 unsigned num; 1696 struct hw_fib ** hw_fib_pool, ** hw_fib_p; 1697 struct fib ** fib_pool, ** fib_p; 1698 1699 /* Sniff events */ 1700 if ((aifcmd->command == 1701 cpu_to_le32(AifCmdEventNotify)) || 1702 (aifcmd->command == 1703 cpu_to_le32(AifCmdJobProgress))) { 1704 aac_handle_aif(dev, fib); 1705 } 1706 1707 time_now = jiffies/HZ; 1708 1709 /* 1710 * Warning: no sleep allowed while 1711 * holding spinlock. We take the estimate 1712 * and pre-allocate a set of fibs outside the 1713 * lock. 1714 */ 1715 num = le32_to_cpu(dev->init->AdapterFibsSize) 1716 / sizeof(struct hw_fib); /* some extra */ 1717 spin_lock_irqsave(&dev->fib_lock, flagv); 1718 entry = dev->fib_list.next; 1719 while (entry != &dev->fib_list) { 1720 entry = entry->next; 1721 ++num; 1722 } 1723 spin_unlock_irqrestore(&dev->fib_lock, flagv); 1724 hw_fib_pool = NULL; 1725 fib_pool = NULL; 1726 if (num 1727 && ((hw_fib_pool = kmalloc(sizeof(struct hw_fib *) * num, GFP_KERNEL))) 1728 && ((fib_pool = kmalloc(sizeof(struct fib *) * num, GFP_KERNEL)))) { 1729 hw_fib_p = hw_fib_pool; 1730 fib_p = fib_pool; 1731 while (hw_fib_p < &hw_fib_pool[num]) { 1732 if (!(*(hw_fib_p++) = kmalloc(sizeof(struct hw_fib), GFP_KERNEL))) { 1733 --hw_fib_p; 1734 break; 1735 } 1736 if (!(*(fib_p++) = kmalloc(sizeof(struct fib), GFP_KERNEL))) { 1737 kfree(*(--hw_fib_p)); 1738 break; 1739 } 1740 } 1741 if ((num = hw_fib_p - hw_fib_pool) == 0) { 1742 kfree(fib_pool); 1743 fib_pool = NULL; 1744 kfree(hw_fib_pool); 1745 hw_fib_pool = NULL; 1746 } 1747 } else { 1748 kfree(hw_fib_pool); 1749 hw_fib_pool = NULL; 1750 } 1751 spin_lock_irqsave(&dev->fib_lock, flagv); 1752 entry = dev->fib_list.next; 1753 /* 1754 * For each Context that is on the 1755 * fibctxList, make a copy of the 1756 * fib, and then set the event to wake up the 1757 * thread that is waiting for it. 1758 */ 1759 hw_fib_p = hw_fib_pool; 1760 fib_p = fib_pool; 1761 while (entry != &dev->fib_list) { 1762 /* 1763 * Extract the fibctx 1764 */ 1765 fibctx = list_entry(entry, struct aac_fib_context, next); 1766 /* 1767 * Check if the queue is getting 1768 * backlogged 1769 */ 1770 if (fibctx->count > 20) 1771 { 1772 /* 1773 * It's *not* jiffies folks, 1774 * but jiffies / HZ so do not 1775 * panic ... 1776 */ 1777 time_last = fibctx->jiffies; 1778 /* 1779 * Has it been > 2 minutes 1780 * since the last read off 1781 * the queue? 1782 */ 1783 if ((time_now - time_last) > aif_timeout) { 1784 entry = entry->next; 1785 aac_close_fib_context(dev, fibctx); 1786 continue; 1787 } 1788 } 1789 /* 1790 * Warning: no sleep allowed while 1791 * holding spinlock 1792 */ 1793 if (hw_fib_p < &hw_fib_pool[num]) { 1794 hw_newfib = *hw_fib_p; 1795 *(hw_fib_p++) = NULL; 1796 newfib = *fib_p; 1797 *(fib_p++) = NULL; 1798 /* 1799 * Make the copy of the FIB 1800 */ 1801 memcpy(hw_newfib, hw_fib, sizeof(struct hw_fib)); 1802 memcpy(newfib, fib, sizeof(struct fib)); 1803 newfib->hw_fib_va = hw_newfib; 1804 /* 1805 * Put the FIB onto the 1806 * fibctx's fibs 1807 */ 1808 list_add_tail(&newfib->fiblink, &fibctx->fib_list); 1809 fibctx->count++; 1810 /* 1811 * Set the event to wake up the 1812 * thread that is waiting. 1813 */ 1814 up(&fibctx->wait_sem); 1815 } else { 1816 printk(KERN_WARNING "aifd: didn't allocate NewFib.\n"); 1817 } 1818 entry = entry->next; 1819 } 1820 /* 1821 * Set the status of this FIB 1822 */ 1823 *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK); 1824 aac_fib_adapter_complete(fib, sizeof(u32)); 1825 spin_unlock_irqrestore(&dev->fib_lock, flagv); 1826 /* Free up the remaining resources */ 1827 hw_fib_p = hw_fib_pool; 1828 fib_p = fib_pool; 1829 while (hw_fib_p < &hw_fib_pool[num]) { 1830 kfree(*hw_fib_p); 1831 kfree(*fib_p); 1832 ++fib_p; 1833 ++hw_fib_p; 1834 } 1835 kfree(hw_fib_pool); 1836 kfree(fib_pool); 1837 } 1838 kfree(fib); 1839 spin_lock_irqsave(dev->queues->queue[HostNormCmdQueue].lock, flags); 1840 } 1841 /* 1842 * There are no more AIF's 1843 */ 1844 spin_unlock_irqrestore(dev->queues->queue[HostNormCmdQueue].lock, flags); 1845 1846 /* 1847 * Background activity 1848 */ 1849 if ((time_before(next_check_jiffies,next_jiffies)) 1850 && ((difference = next_check_jiffies - jiffies) <= 0)) { 1851 next_check_jiffies = next_jiffies; 1852 if (aac_check_health(dev) == 0) { 1853 difference = ((long)(unsigned)check_interval) 1854 * HZ; 1855 next_check_jiffies = jiffies + difference; 1856 } else if (!dev->queues) 1857 break; 1858 } 1859 if (!time_before(next_check_jiffies,next_jiffies) 1860 && ((difference = next_jiffies - jiffies) <= 0)) { 1861 struct timeval now; 1862 int ret; 1863 1864 /* Don't even try to talk to adapter if its sick */ 1865 ret = aac_check_health(dev); 1866 if (!ret && !dev->queues) 1867 break; 1868 next_check_jiffies = jiffies 1869 + ((long)(unsigned)check_interval) 1870 * HZ; 1871 do_gettimeofday(&now); 1872 1873 /* Synchronize our watches */ 1874 if (((1000000 - (1000000 / HZ)) > now.tv_usec) 1875 && (now.tv_usec > (1000000 / HZ))) 1876 difference = (((1000000 - now.tv_usec) * HZ) 1877 + 500000) / 1000000; 1878 else if (ret == 0) { 1879 struct fib *fibptr; 1880 1881 if ((fibptr = aac_fib_alloc(dev))) { 1882 int status; 1883 __le32 *info; 1884 1885 aac_fib_init(fibptr); 1886 1887 info = (__le32 *) fib_data(fibptr); 1888 if (now.tv_usec > 500000) 1889 ++now.tv_sec; 1890 1891 *info = cpu_to_le32(now.tv_sec); 1892 1893 status = aac_fib_send(SendHostTime, 1894 fibptr, 1895 sizeof(*info), 1896 FsaNormal, 1897 1, 1, 1898 NULL, 1899 NULL); 1900 /* Do not set XferState to zero unless 1901 * receives a response from F/W */ 1902 if (status >= 0) 1903 aac_fib_complete(fibptr); 1904 /* FIB should be freed only after 1905 * getting the response from the F/W */ 1906 if (status != -ERESTARTSYS) 1907 aac_fib_free(fibptr); 1908 } 1909 difference = (long)(unsigned)update_interval*HZ; 1910 } else { 1911 /* retry shortly */ 1912 difference = 10 * HZ; 1913 } 1914 next_jiffies = jiffies + difference; 1915 if (time_before(next_check_jiffies,next_jiffies)) 1916 difference = next_check_jiffies - jiffies; 1917 } 1918 if (difference <= 0) 1919 difference = 1; 1920 set_current_state(TASK_INTERRUPTIBLE); 1921 schedule_timeout(difference); 1922 1923 if (kthread_should_stop()) 1924 break; 1925 } 1926 if (dev->queues) 1927 remove_wait_queue(&dev->queues->queue[HostNormCmdQueue].cmdready, &wait); 1928 dev->aif_thread = 0; 1929 return 0; 1930} 1931