commsup.c revision 65101355450df2d935f8d56ac3abef279f28a0e2
1/* 2 * Adaptec AAC series RAID controller driver 3 * (c) Copyright 2001 Red Hat Inc. <alan@redhat.com> 4 * 5 * based on the old aacraid driver that is.. 6 * Adaptec aacraid device driver for Linux. 7 * 8 * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com) 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2, or (at your option) 13 * any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; see the file COPYING. If not, write to 22 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 23 * 24 * Module Name: 25 * commsup.c 26 * 27 * Abstract: Contain all routines that are required for FSA host/adapter 28 * communication. 29 * 30 */ 31 32#include <linux/kernel.h> 33#include <linux/init.h> 34#include <linux/types.h> 35#include <linux/sched.h> 36#include <linux/pci.h> 37#include <linux/spinlock.h> 38#include <linux/slab.h> 39#include <linux/completion.h> 40#include <linux/blkdev.h> 41#include <linux/delay.h> 42#include <linux/kthread.h> 43#include <scsi/scsi.h> 44#include <scsi/scsi_host.h> 45#include <scsi/scsi_device.h> 46#include <scsi/scsi_cmnd.h> 47#include <asm/semaphore.h> 48 49#include "aacraid.h" 50 51/** 52 * fib_map_alloc - allocate the fib objects 53 * @dev: Adapter to allocate for 54 * 55 * Allocate and map the shared PCI space for the FIB blocks used to 56 * talk to the Adaptec firmware. 57 */ 58 59static int fib_map_alloc(struct aac_dev *dev) 60{ 61 dprintk((KERN_INFO 62 "allocate hardware fibs pci_alloc_consistent(%p, %d * (%d + %d), %p)\n", 63 dev->pdev, dev->max_fib_size, dev->scsi_host_ptr->can_queue, 64 AAC_NUM_MGT_FIB, &dev->hw_fib_pa)); 65 if((dev->hw_fib_va = pci_alloc_consistent(dev->pdev, dev->max_fib_size 66 * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB), 67 &dev->hw_fib_pa))==NULL) 68 return -ENOMEM; 69 return 0; 70} 71 72/** 73 * aac_fib_map_free - free the fib objects 74 * @dev: Adapter to free 75 * 76 * Free the PCI mappings and the memory allocated for FIB blocks 77 * on this adapter. 78 */ 79 80void aac_fib_map_free(struct aac_dev *dev) 81{ 82 pci_free_consistent(dev->pdev, dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB), dev->hw_fib_va, dev->hw_fib_pa); 83} 84 85/** 86 * aac_fib_setup - setup the fibs 87 * @dev: Adapter to set up 88 * 89 * Allocate the PCI space for the fibs, map it and then intialise the 90 * fib area, the unmapped fib data and also the free list 91 */ 92 93int aac_fib_setup(struct aac_dev * dev) 94{ 95 struct fib *fibptr; 96 struct hw_fib *hw_fib_va; 97 dma_addr_t hw_fib_pa; 98 int i; 99 100 while (((i = fib_map_alloc(dev)) == -ENOMEM) 101 && (dev->scsi_host_ptr->can_queue > (64 - AAC_NUM_MGT_FIB))) { 102 dev->init->MaxIoCommands = cpu_to_le32((dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB) >> 1); 103 dev->scsi_host_ptr->can_queue = le32_to_cpu(dev->init->MaxIoCommands) - AAC_NUM_MGT_FIB; 104 } 105 if (i<0) 106 return -ENOMEM; 107 108 hw_fib_va = dev->hw_fib_va; 109 hw_fib_pa = dev->hw_fib_pa; 110 memset(hw_fib_va, 0, dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB)); 111 /* 112 * Initialise the fibs 113 */ 114 for (i = 0, fibptr = &dev->fibs[i]; i < (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); i++, fibptr++) 115 { 116 fibptr->dev = dev; 117 fibptr->hw_fib = hw_fib_va; 118 fibptr->data = (void *) fibptr->hw_fib->data; 119 fibptr->next = fibptr+1; /* Forward chain the fibs */ 120 init_MUTEX_LOCKED(&fibptr->event_wait); 121 spin_lock_init(&fibptr->event_lock); 122 hw_fib_va->header.XferState = cpu_to_le32(0xffffffff); 123 hw_fib_va->header.SenderSize = cpu_to_le16(dev->max_fib_size); 124 fibptr->hw_fib_pa = hw_fib_pa; 125 hw_fib_va = (struct hw_fib *)((unsigned char *)hw_fib_va + dev->max_fib_size); 126 hw_fib_pa = hw_fib_pa + dev->max_fib_size; 127 } 128 /* 129 * Add the fib chain to the free list 130 */ 131 dev->fibs[dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB - 1].next = NULL; 132 /* 133 * Enable this to debug out of queue space 134 */ 135 dev->free_fib = &dev->fibs[0]; 136 return 0; 137} 138 139/** 140 * aac_fib_alloc - allocate a fib 141 * @dev: Adapter to allocate the fib for 142 * 143 * Allocate a fib from the adapter fib pool. If the pool is empty we 144 * return NULL. 145 */ 146 147struct fib *aac_fib_alloc(struct aac_dev *dev) 148{ 149 struct fib * fibptr; 150 unsigned long flags; 151 spin_lock_irqsave(&dev->fib_lock, flags); 152 fibptr = dev->free_fib; 153 if(!fibptr){ 154 spin_unlock_irqrestore(&dev->fib_lock, flags); 155 return fibptr; 156 } 157 dev->free_fib = fibptr->next; 158 spin_unlock_irqrestore(&dev->fib_lock, flags); 159 /* 160 * Set the proper node type code and node byte size 161 */ 162 fibptr->type = FSAFS_NTC_FIB_CONTEXT; 163 fibptr->size = sizeof(struct fib); 164 /* 165 * Null out fields that depend on being zero at the start of 166 * each I/O 167 */ 168 fibptr->hw_fib->header.XferState = 0; 169 fibptr->callback = NULL; 170 fibptr->callback_data = NULL; 171 172 return fibptr; 173} 174 175/** 176 * aac_fib_free - free a fib 177 * @fibptr: fib to free up 178 * 179 * Frees up a fib and places it on the appropriate queue 180 * (either free or timed out) 181 */ 182 183void aac_fib_free(struct fib *fibptr) 184{ 185 unsigned long flags; 186 187 spin_lock_irqsave(&fibptr->dev->fib_lock, flags); 188 if (fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT) { 189 aac_config.fib_timeouts++; 190 fibptr->next = fibptr->dev->timeout_fib; 191 fibptr->dev->timeout_fib = fibptr; 192 } else { 193 if (fibptr->hw_fib->header.XferState != 0) { 194 printk(KERN_WARNING "aac_fib_free, XferState != 0, fibptr = 0x%p, XferState = 0x%x\n", 195 (void*)fibptr, 196 le32_to_cpu(fibptr->hw_fib->header.XferState)); 197 } 198 fibptr->next = fibptr->dev->free_fib; 199 fibptr->dev->free_fib = fibptr; 200 } 201 spin_unlock_irqrestore(&fibptr->dev->fib_lock, flags); 202} 203 204/** 205 * aac_fib_init - initialise a fib 206 * @fibptr: The fib to initialize 207 * 208 * Set up the generic fib fields ready for use 209 */ 210 211void aac_fib_init(struct fib *fibptr) 212{ 213 struct hw_fib *hw_fib = fibptr->hw_fib; 214 215 hw_fib->header.StructType = FIB_MAGIC; 216 hw_fib->header.Size = cpu_to_le16(fibptr->dev->max_fib_size); 217 hw_fib->header.XferState = cpu_to_le32(HostOwned | FibInitialized | FibEmpty | FastResponseCapable); 218 hw_fib->header.SenderFibAddress = 0; /* Filled in later if needed */ 219 hw_fib->header.ReceiverFibAddress = cpu_to_le32(fibptr->hw_fib_pa); 220 hw_fib->header.SenderSize = cpu_to_le16(fibptr->dev->max_fib_size); 221} 222 223/** 224 * fib_deallocate - deallocate a fib 225 * @fibptr: fib to deallocate 226 * 227 * Will deallocate and return to the free pool the FIB pointed to by the 228 * caller. 229 */ 230 231static void fib_dealloc(struct fib * fibptr) 232{ 233 struct hw_fib *hw_fib = fibptr->hw_fib; 234 BUG_ON(hw_fib->header.StructType != FIB_MAGIC); 235 hw_fib->header.XferState = 0; 236} 237 238/* 239 * Commuication primitives define and support the queuing method we use to 240 * support host to adapter commuication. All queue accesses happen through 241 * these routines and are the only routines which have a knowledge of the 242 * how these queues are implemented. 243 */ 244 245/** 246 * aac_get_entry - get a queue entry 247 * @dev: Adapter 248 * @qid: Queue Number 249 * @entry: Entry return 250 * @index: Index return 251 * @nonotify: notification control 252 * 253 * With a priority the routine returns a queue entry if the queue has free entries. If the queue 254 * is full(no free entries) than no entry is returned and the function returns 0 otherwise 1 is 255 * returned. 256 */ 257 258static int aac_get_entry (struct aac_dev * dev, u32 qid, struct aac_entry **entry, u32 * index, unsigned long *nonotify) 259{ 260 struct aac_queue * q; 261 unsigned long idx; 262 263 /* 264 * All of the queues wrap when they reach the end, so we check 265 * to see if they have reached the end and if they have we just 266 * set the index back to zero. This is a wrap. You could or off 267 * the high bits in all updates but this is a bit faster I think. 268 */ 269 270 q = &dev->queues->queue[qid]; 271 272 idx = *index = le32_to_cpu(*(q->headers.producer)); 273 /* Interrupt Moderation, only interrupt for first two entries */ 274 if (idx != le32_to_cpu(*(q->headers.consumer))) { 275 if (--idx == 0) { 276 if (qid == AdapNormCmdQueue) 277 idx = ADAP_NORM_CMD_ENTRIES; 278 else 279 idx = ADAP_NORM_RESP_ENTRIES; 280 } 281 if (idx != le32_to_cpu(*(q->headers.consumer))) 282 *nonotify = 1; 283 } 284 285 if (qid == AdapNormCmdQueue) { 286 if (*index >= ADAP_NORM_CMD_ENTRIES) 287 *index = 0; /* Wrap to front of the Producer Queue. */ 288 } else { 289 if (*index >= ADAP_NORM_RESP_ENTRIES) 290 *index = 0; /* Wrap to front of the Producer Queue. */ 291 } 292 293 if ((*index + 1) == le32_to_cpu(*(q->headers.consumer))) { /* Queue is full */ 294 printk(KERN_WARNING "Queue %d full, %u outstanding.\n", 295 qid, q->numpending); 296 return 0; 297 } else { 298 *entry = q->base + *index; 299 return 1; 300 } 301} 302 303/** 304 * aac_queue_get - get the next free QE 305 * @dev: Adapter 306 * @index: Returned index 307 * @priority: Priority of fib 308 * @fib: Fib to associate with the queue entry 309 * @wait: Wait if queue full 310 * @fibptr: Driver fib object to go with fib 311 * @nonotify: Don't notify the adapter 312 * 313 * Gets the next free QE off the requested priorty adapter command 314 * queue and associates the Fib with the QE. The QE represented by 315 * index is ready to insert on the queue when this routine returns 316 * success. 317 */ 318 319static int aac_queue_get(struct aac_dev * dev, u32 * index, u32 qid, struct hw_fib * hw_fib, int wait, struct fib * fibptr, unsigned long *nonotify) 320{ 321 struct aac_entry * entry = NULL; 322 int map = 0; 323 324 if (qid == AdapNormCmdQueue) { 325 /* if no entries wait for some if caller wants to */ 326 while (!aac_get_entry(dev, qid, &entry, index, nonotify)) 327 { 328 printk(KERN_ERR "GetEntries failed\n"); 329 } 330 /* 331 * Setup queue entry with a command, status and fib mapped 332 */ 333 entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size)); 334 map = 1; 335 } else { 336 while(!aac_get_entry(dev, qid, &entry, index, nonotify)) 337 { 338 /* if no entries wait for some if caller wants to */ 339 } 340 /* 341 * Setup queue entry with command, status and fib mapped 342 */ 343 entry->size = cpu_to_le32(le16_to_cpu(hw_fib->header.Size)); 344 entry->addr = hw_fib->header.SenderFibAddress; 345 /* Restore adapters pointer to the FIB */ 346 hw_fib->header.ReceiverFibAddress = hw_fib->header.SenderFibAddress; /* Let the adapter now where to find its data */ 347 map = 0; 348 } 349 /* 350 * If MapFib is true than we need to map the Fib and put pointers 351 * in the queue entry. 352 */ 353 if (map) 354 entry->addr = cpu_to_le32(fibptr->hw_fib_pa); 355 return 0; 356} 357 358/* 359 * Define the highest level of host to adapter communication routines. 360 * These routines will support host to adapter FS commuication. These 361 * routines have no knowledge of the commuication method used. This level 362 * sends and receives FIBs. This level has no knowledge of how these FIBs 363 * get passed back and forth. 364 */ 365 366/** 367 * aac_fib_send - send a fib to the adapter 368 * @command: Command to send 369 * @fibptr: The fib 370 * @size: Size of fib data area 371 * @priority: Priority of Fib 372 * @wait: Async/sync select 373 * @reply: True if a reply is wanted 374 * @callback: Called with reply 375 * @callback_data: Passed to callback 376 * 377 * Sends the requested FIB to the adapter and optionally will wait for a 378 * response FIB. If the caller does not wish to wait for a response than 379 * an event to wait on must be supplied. This event will be set when a 380 * response FIB is received from the adapter. 381 */ 382 383int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size, 384 int priority, int wait, int reply, fib_callback callback, 385 void *callback_data) 386{ 387 struct aac_dev * dev = fibptr->dev; 388 struct hw_fib * hw_fib = fibptr->hw_fib; 389 struct aac_queue * q; 390 unsigned long flags = 0; 391 unsigned long qflags; 392 393 if (!(hw_fib->header.XferState & cpu_to_le32(HostOwned))) 394 return -EBUSY; 395 /* 396 * There are 5 cases with the wait and reponse requested flags. 397 * The only invalid cases are if the caller requests to wait and 398 * does not request a response and if the caller does not want a 399 * response and the Fib is not allocated from pool. If a response 400 * is not requesed the Fib will just be deallocaed by the DPC 401 * routine when the response comes back from the adapter. No 402 * further processing will be done besides deleting the Fib. We 403 * will have a debug mode where the adapter can notify the host 404 * it had a problem and the host can log that fact. 405 */ 406 if (wait && !reply) { 407 return -EINVAL; 408 } else if (!wait && reply) { 409 hw_fib->header.XferState |= cpu_to_le32(Async | ResponseExpected); 410 FIB_COUNTER_INCREMENT(aac_config.AsyncSent); 411 } else if (!wait && !reply) { 412 hw_fib->header.XferState |= cpu_to_le32(NoResponseExpected); 413 FIB_COUNTER_INCREMENT(aac_config.NoResponseSent); 414 } else if (wait && reply) { 415 hw_fib->header.XferState |= cpu_to_le32(ResponseExpected); 416 FIB_COUNTER_INCREMENT(aac_config.NormalSent); 417 } 418 /* 419 * Map the fib into 32bits by using the fib number 420 */ 421 422 hw_fib->header.SenderFibAddress = cpu_to_le32(((u32)(fibptr - dev->fibs)) << 2); 423 hw_fib->header.SenderData = (u32)(fibptr - dev->fibs); 424 /* 425 * Set FIB state to indicate where it came from and if we want a 426 * response from the adapter. Also load the command from the 427 * caller. 428 * 429 * Map the hw fib pointer as a 32bit value 430 */ 431 hw_fib->header.Command = cpu_to_le16(command); 432 hw_fib->header.XferState |= cpu_to_le32(SentFromHost); 433 fibptr->hw_fib->header.Flags = 0; /* 0 the flags field - internal only*/ 434 /* 435 * Set the size of the Fib we want to send to the adapter 436 */ 437 hw_fib->header.Size = cpu_to_le16(sizeof(struct aac_fibhdr) + size); 438 if (le16_to_cpu(hw_fib->header.Size) > le16_to_cpu(hw_fib->header.SenderSize)) { 439 return -EMSGSIZE; 440 } 441 /* 442 * Get a queue entry connect the FIB to it and send an notify 443 * the adapter a command is ready. 444 */ 445 hw_fib->header.XferState |= cpu_to_le32(NormalPriority); 446 447 /* 448 * Fill in the Callback and CallbackContext if we are not 449 * going to wait. 450 */ 451 if (!wait) { 452 fibptr->callback = callback; 453 fibptr->callback_data = callback_data; 454 } 455 456 fibptr->done = 0; 457 fibptr->flags = 0; 458 459 FIB_COUNTER_INCREMENT(aac_config.FibsSent); 460 461 dprintk((KERN_DEBUG "Fib contents:.\n")); 462 dprintk((KERN_DEBUG " Command = %d.\n", le32_to_cpu(hw_fib->header.Command))); 463 dprintk((KERN_DEBUG " SubCommand = %d.\n", le32_to_cpu(((struct aac_query_mount *)fib_data(fibptr))->command))); 464 dprintk((KERN_DEBUG " XferState = %x.\n", le32_to_cpu(hw_fib->header.XferState))); 465 dprintk((KERN_DEBUG " hw_fib va being sent=%p\n",fibptr->hw_fib)); 466 dprintk((KERN_DEBUG " hw_fib pa being sent=%lx\n",(ulong)fibptr->hw_fib_pa)); 467 dprintk((KERN_DEBUG " fib being sent=%p\n",fibptr)); 468 469 if (!dev->queues) 470 return -EBUSY; 471 q = &dev->queues->queue[AdapNormCmdQueue]; 472 473 if(wait) 474 spin_lock_irqsave(&fibptr->event_lock, flags); 475 spin_lock_irqsave(q->lock, qflags); 476 if (dev->new_comm_interface) { 477 unsigned long count = 10000000L; /* 50 seconds */ 478 q->numpending++; 479 spin_unlock_irqrestore(q->lock, qflags); 480 while (aac_adapter_send(fibptr) != 0) { 481 if (--count == 0) { 482 if (wait) 483 spin_unlock_irqrestore(&fibptr->event_lock, flags); 484 spin_lock_irqsave(q->lock, qflags); 485 q->numpending--; 486 spin_unlock_irqrestore(q->lock, qflags); 487 return -ETIMEDOUT; 488 } 489 udelay(5); 490 } 491 } else { 492 u32 index; 493 unsigned long nointr = 0; 494 aac_queue_get( dev, &index, AdapNormCmdQueue, hw_fib, 1, fibptr, &nointr); 495 496 q->numpending++; 497 *(q->headers.producer) = cpu_to_le32(index + 1); 498 spin_unlock_irqrestore(q->lock, qflags); 499 dprintk((KERN_DEBUG "aac_fib_send: inserting a queue entry at index %d.\n",index)); 500 if (!(nointr & aac_config.irq_mod)) 501 aac_adapter_notify(dev, AdapNormCmdQueue); 502 } 503 504 /* 505 * If the caller wanted us to wait for response wait now. 506 */ 507 508 if (wait) { 509 spin_unlock_irqrestore(&fibptr->event_lock, flags); 510 /* Only set for first known interruptable command */ 511 if (wait < 0) { 512 /* 513 * *VERY* Dangerous to time out a command, the 514 * assumption is made that we have no hope of 515 * functioning because an interrupt routing or other 516 * hardware failure has occurred. 517 */ 518 unsigned long count = 36000000L; /* 3 minutes */ 519 while (down_trylock(&fibptr->event_wait)) { 520 if (--count == 0) { 521 spin_lock_irqsave(q->lock, qflags); 522 q->numpending--; 523 spin_unlock_irqrestore(q->lock, qflags); 524 if (wait == -1) { 525 printk(KERN_ERR "aacraid: aac_fib_send: first asynchronous command timed out.\n" 526 "Usually a result of a PCI interrupt routing problem;\n" 527 "update mother board BIOS or consider utilizing one of\n" 528 "the SAFE mode kernel options (acpi, apic etc)\n"); 529 } 530 return -ETIMEDOUT; 531 } 532 udelay(5); 533 } 534 } else if (down_interruptible(&fibptr->event_wait)) { 535 spin_lock_irqsave(&fibptr->event_lock, flags); 536 if (fibptr->done == 0) { 537 fibptr->done = 2; /* Tell interrupt we aborted */ 538 spin_unlock_irqrestore(&fibptr->event_lock, flags); 539 return -EINTR; 540 } 541 spin_unlock_irqrestore(&fibptr->event_lock, flags); 542 } 543 BUG_ON(fibptr->done == 0); 544 545 if((fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT)){ 546 return -ETIMEDOUT; 547 } else { 548 return 0; 549 } 550 } 551 /* 552 * If the user does not want a response than return success otherwise 553 * return pending 554 */ 555 if (reply) 556 return -EINPROGRESS; 557 else 558 return 0; 559} 560 561/** 562 * aac_consumer_get - get the top of the queue 563 * @dev: Adapter 564 * @q: Queue 565 * @entry: Return entry 566 * 567 * Will return a pointer to the entry on the top of the queue requested that 568 * we are a consumer of, and return the address of the queue entry. It does 569 * not change the state of the queue. 570 */ 571 572int aac_consumer_get(struct aac_dev * dev, struct aac_queue * q, struct aac_entry **entry) 573{ 574 u32 index; 575 int status; 576 if (le32_to_cpu(*q->headers.producer) == le32_to_cpu(*q->headers.consumer)) { 577 status = 0; 578 } else { 579 /* 580 * The consumer index must be wrapped if we have reached 581 * the end of the queue, else we just use the entry 582 * pointed to by the header index 583 */ 584 if (le32_to_cpu(*q->headers.consumer) >= q->entries) 585 index = 0; 586 else 587 index = le32_to_cpu(*q->headers.consumer); 588 *entry = q->base + index; 589 status = 1; 590 } 591 return(status); 592} 593 594/** 595 * aac_consumer_free - free consumer entry 596 * @dev: Adapter 597 * @q: Queue 598 * @qid: Queue ident 599 * 600 * Frees up the current top of the queue we are a consumer of. If the 601 * queue was full notify the producer that the queue is no longer full. 602 */ 603 604void aac_consumer_free(struct aac_dev * dev, struct aac_queue *q, u32 qid) 605{ 606 int wasfull = 0; 607 u32 notify; 608 609 if ((le32_to_cpu(*q->headers.producer)+1) == le32_to_cpu(*q->headers.consumer)) 610 wasfull = 1; 611 612 if (le32_to_cpu(*q->headers.consumer) >= q->entries) 613 *q->headers.consumer = cpu_to_le32(1); 614 else 615 *q->headers.consumer = cpu_to_le32(le32_to_cpu(*q->headers.consumer)+1); 616 617 if (wasfull) { 618 switch (qid) { 619 620 case HostNormCmdQueue: 621 notify = HostNormCmdNotFull; 622 break; 623 case HostNormRespQueue: 624 notify = HostNormRespNotFull; 625 break; 626 default: 627 BUG(); 628 return; 629 } 630 aac_adapter_notify(dev, notify); 631 } 632} 633 634/** 635 * aac_fib_adapter_complete - complete adapter issued fib 636 * @fibptr: fib to complete 637 * @size: size of fib 638 * 639 * Will do all necessary work to complete a FIB that was sent from 640 * the adapter. 641 */ 642 643int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size) 644{ 645 struct hw_fib * hw_fib = fibptr->hw_fib; 646 struct aac_dev * dev = fibptr->dev; 647 struct aac_queue * q; 648 unsigned long nointr = 0; 649 unsigned long qflags; 650 651 if (hw_fib->header.XferState == 0) { 652 if (dev->new_comm_interface) 653 kfree (hw_fib); 654 return 0; 655 } 656 /* 657 * If we plan to do anything check the structure type first. 658 */ 659 if ( hw_fib->header.StructType != FIB_MAGIC ) { 660 if (dev->new_comm_interface) 661 kfree (hw_fib); 662 return -EINVAL; 663 } 664 /* 665 * This block handles the case where the adapter had sent us a 666 * command and we have finished processing the command. We 667 * call completeFib when we are done processing the command 668 * and want to send a response back to the adapter. This will 669 * send the completed cdb to the adapter. 670 */ 671 if (hw_fib->header.XferState & cpu_to_le32(SentFromAdapter)) { 672 if (dev->new_comm_interface) { 673 kfree (hw_fib); 674 } else { 675 u32 index; 676 hw_fib->header.XferState |= cpu_to_le32(HostProcessed); 677 if (size) { 678 size += sizeof(struct aac_fibhdr); 679 if (size > le16_to_cpu(hw_fib->header.SenderSize)) 680 return -EMSGSIZE; 681 hw_fib->header.Size = cpu_to_le16(size); 682 } 683 q = &dev->queues->queue[AdapNormRespQueue]; 684 spin_lock_irqsave(q->lock, qflags); 685 aac_queue_get(dev, &index, AdapNormRespQueue, hw_fib, 1, NULL, &nointr); 686 *(q->headers.producer) = cpu_to_le32(index + 1); 687 spin_unlock_irqrestore(q->lock, qflags); 688 if (!(nointr & (int)aac_config.irq_mod)) 689 aac_adapter_notify(dev, AdapNormRespQueue); 690 } 691 } 692 else 693 { 694 printk(KERN_WARNING "aac_fib_adapter_complete: Unknown xferstate detected.\n"); 695 BUG(); 696 } 697 return 0; 698} 699 700/** 701 * aac_fib_complete - fib completion handler 702 * @fib: FIB to complete 703 * 704 * Will do all necessary work to complete a FIB. 705 */ 706 707int aac_fib_complete(struct fib *fibptr) 708{ 709 struct hw_fib * hw_fib = fibptr->hw_fib; 710 711 /* 712 * Check for a fib which has already been completed 713 */ 714 715 if (hw_fib->header.XferState == 0) 716 return 0; 717 /* 718 * If we plan to do anything check the structure type first. 719 */ 720 721 if (hw_fib->header.StructType != FIB_MAGIC) 722 return -EINVAL; 723 /* 724 * This block completes a cdb which orginated on the host and we 725 * just need to deallocate the cdb or reinit it. At this point the 726 * command is complete that we had sent to the adapter and this 727 * cdb could be reused. 728 */ 729 if((hw_fib->header.XferState & cpu_to_le32(SentFromHost)) && 730 (hw_fib->header.XferState & cpu_to_le32(AdapterProcessed))) 731 { 732 fib_dealloc(fibptr); 733 } 734 else if(hw_fib->header.XferState & cpu_to_le32(SentFromHost)) 735 { 736 /* 737 * This handles the case when the host has aborted the I/O 738 * to the adapter because the adapter is not responding 739 */ 740 fib_dealloc(fibptr); 741 } else if(hw_fib->header.XferState & cpu_to_le32(HostOwned)) { 742 fib_dealloc(fibptr); 743 } else { 744 BUG(); 745 } 746 return 0; 747} 748 749/** 750 * aac_printf - handle printf from firmware 751 * @dev: Adapter 752 * @val: Message info 753 * 754 * Print a message passed to us by the controller firmware on the 755 * Adaptec board 756 */ 757 758void aac_printf(struct aac_dev *dev, u32 val) 759{ 760 char *cp = dev->printfbuf; 761 if (dev->printf_enabled) 762 { 763 int length = val & 0xffff; 764 int level = (val >> 16) & 0xffff; 765 766 /* 767 * The size of the printfbuf is set in port.c 768 * There is no variable or define for it 769 */ 770 if (length > 255) 771 length = 255; 772 if (cp[length] != 0) 773 cp[length] = 0; 774 if (level == LOG_AAC_HIGH_ERROR) 775 printk(KERN_WARNING "%s:%s", dev->name, cp); 776 else 777 printk(KERN_INFO "%s:%s", dev->name, cp); 778 } 779 memset(cp, 0, 256); 780} 781 782 783/** 784 * aac_handle_aif - Handle a message from the firmware 785 * @dev: Which adapter this fib is from 786 * @fibptr: Pointer to fibptr from adapter 787 * 788 * This routine handles a driver notify fib from the adapter and 789 * dispatches it to the appropriate routine for handling. 790 */ 791 792#define AIF_SNIFF_TIMEOUT (30*HZ) 793static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr) 794{ 795 struct hw_fib * hw_fib = fibptr->hw_fib; 796 struct aac_aifcmd * aifcmd = (struct aac_aifcmd *)hw_fib->data; 797 int busy; 798 u32 container; 799 struct scsi_device *device; 800 enum { 801 NOTHING, 802 DELETE, 803 ADD, 804 CHANGE 805 } device_config_needed; 806 807 /* Sniff for container changes */ 808 809 if (!dev || !dev->fsa_dev) 810 return; 811 container = (u32)-1; 812 813 /* 814 * We have set this up to try and minimize the number of 815 * re-configures that take place. As a result of this when 816 * certain AIF's come in we will set a flag waiting for another 817 * type of AIF before setting the re-config flag. 818 */ 819 switch (le32_to_cpu(aifcmd->command)) { 820 case AifCmdDriverNotify: 821 switch (le32_to_cpu(((u32 *)aifcmd->data)[0])) { 822 /* 823 * Morph or Expand complete 824 */ 825 case AifDenMorphComplete: 826 case AifDenVolumeExtendComplete: 827 container = le32_to_cpu(((u32 *)aifcmd->data)[1]); 828 if (container >= dev->maximum_num_containers) 829 break; 830 831 /* 832 * Find the scsi_device associated with the SCSI 833 * address. Make sure we have the right array, and if 834 * so set the flag to initiate a new re-config once we 835 * see an AifEnConfigChange AIF come through. 836 */ 837 838 if ((dev != NULL) && (dev->scsi_host_ptr != NULL)) { 839 device = scsi_device_lookup(dev->scsi_host_ptr, 840 CONTAINER_TO_CHANNEL(container), 841 CONTAINER_TO_ID(container), 842 CONTAINER_TO_LUN(container)); 843 if (device) { 844 dev->fsa_dev[container].config_needed = CHANGE; 845 dev->fsa_dev[container].config_waiting_on = AifEnConfigChange; 846 dev->fsa_dev[container].config_waiting_stamp = jiffies; 847 scsi_device_put(device); 848 } 849 } 850 } 851 852 /* 853 * If we are waiting on something and this happens to be 854 * that thing then set the re-configure flag. 855 */ 856 if (container != (u32)-1) { 857 if (container >= dev->maximum_num_containers) 858 break; 859 if ((dev->fsa_dev[container].config_waiting_on == 860 le32_to_cpu(*(u32 *)aifcmd->data)) && 861 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) 862 dev->fsa_dev[container].config_waiting_on = 0; 863 } else for (container = 0; 864 container < dev->maximum_num_containers; ++container) { 865 if ((dev->fsa_dev[container].config_waiting_on == 866 le32_to_cpu(*(u32 *)aifcmd->data)) && 867 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) 868 dev->fsa_dev[container].config_waiting_on = 0; 869 } 870 break; 871 872 case AifCmdEventNotify: 873 switch (le32_to_cpu(((u32 *)aifcmd->data)[0])) { 874 /* 875 * Add an Array. 876 */ 877 case AifEnAddContainer: 878 container = le32_to_cpu(((u32 *)aifcmd->data)[1]); 879 if (container >= dev->maximum_num_containers) 880 break; 881 dev->fsa_dev[container].config_needed = ADD; 882 dev->fsa_dev[container].config_waiting_on = 883 AifEnConfigChange; 884 dev->fsa_dev[container].config_waiting_stamp = jiffies; 885 break; 886 887 /* 888 * Delete an Array. 889 */ 890 case AifEnDeleteContainer: 891 container = le32_to_cpu(((u32 *)aifcmd->data)[1]); 892 if (container >= dev->maximum_num_containers) 893 break; 894 dev->fsa_dev[container].config_needed = DELETE; 895 dev->fsa_dev[container].config_waiting_on = 896 AifEnConfigChange; 897 dev->fsa_dev[container].config_waiting_stamp = jiffies; 898 break; 899 900 /* 901 * Container change detected. If we currently are not 902 * waiting on something else, setup to wait on a Config Change. 903 */ 904 case AifEnContainerChange: 905 container = le32_to_cpu(((u32 *)aifcmd->data)[1]); 906 if (container >= dev->maximum_num_containers) 907 break; 908 if (dev->fsa_dev[container].config_waiting_on && 909 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) 910 break; 911 dev->fsa_dev[container].config_needed = CHANGE; 912 dev->fsa_dev[container].config_waiting_on = 913 AifEnConfigChange; 914 dev->fsa_dev[container].config_waiting_stamp = jiffies; 915 break; 916 917 case AifEnConfigChange: 918 break; 919 920 } 921 922 /* 923 * If we are waiting on something and this happens to be 924 * that thing then set the re-configure flag. 925 */ 926 if (container != (u32)-1) { 927 if (container >= dev->maximum_num_containers) 928 break; 929 if ((dev->fsa_dev[container].config_waiting_on == 930 le32_to_cpu(*(u32 *)aifcmd->data)) && 931 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) 932 dev->fsa_dev[container].config_waiting_on = 0; 933 } else for (container = 0; 934 container < dev->maximum_num_containers; ++container) { 935 if ((dev->fsa_dev[container].config_waiting_on == 936 le32_to_cpu(*(u32 *)aifcmd->data)) && 937 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) 938 dev->fsa_dev[container].config_waiting_on = 0; 939 } 940 break; 941 942 case AifCmdJobProgress: 943 /* 944 * These are job progress AIF's. When a Clear is being 945 * done on a container it is initially created then hidden from 946 * the OS. When the clear completes we don't get a config 947 * change so we monitor the job status complete on a clear then 948 * wait for a container change. 949 */ 950 951 if ((((u32 *)aifcmd->data)[1] == cpu_to_le32(AifJobCtrZero)) 952 && ((((u32 *)aifcmd->data)[6] == ((u32 *)aifcmd->data)[5]) 953 || (((u32 *)aifcmd->data)[4] == cpu_to_le32(AifJobStsSuccess)))) { 954 for (container = 0; 955 container < dev->maximum_num_containers; 956 ++container) { 957 /* 958 * Stomp on all config sequencing for all 959 * containers? 960 */ 961 dev->fsa_dev[container].config_waiting_on = 962 AifEnContainerChange; 963 dev->fsa_dev[container].config_needed = ADD; 964 dev->fsa_dev[container].config_waiting_stamp = 965 jiffies; 966 } 967 } 968 if ((((u32 *)aifcmd->data)[1] == cpu_to_le32(AifJobCtrZero)) 969 && (((u32 *)aifcmd->data)[6] == 0) 970 && (((u32 *)aifcmd->data)[4] == cpu_to_le32(AifJobStsRunning))) { 971 for (container = 0; 972 container < dev->maximum_num_containers; 973 ++container) { 974 /* 975 * Stomp on all config sequencing for all 976 * containers? 977 */ 978 dev->fsa_dev[container].config_waiting_on = 979 AifEnContainerChange; 980 dev->fsa_dev[container].config_needed = DELETE; 981 dev->fsa_dev[container].config_waiting_stamp = 982 jiffies; 983 } 984 } 985 break; 986 } 987 988 device_config_needed = NOTHING; 989 for (container = 0; container < dev->maximum_num_containers; 990 ++container) { 991 if ((dev->fsa_dev[container].config_waiting_on == 0) && 992 (dev->fsa_dev[container].config_needed != NOTHING) && 993 time_before(jiffies, dev->fsa_dev[container].config_waiting_stamp + AIF_SNIFF_TIMEOUT)) { 994 device_config_needed = 995 dev->fsa_dev[container].config_needed; 996 dev->fsa_dev[container].config_needed = NOTHING; 997 break; 998 } 999 } 1000 if (device_config_needed == NOTHING) 1001 return; 1002 1003 /* 1004 * If we decided that a re-configuration needs to be done, 1005 * schedule it here on the way out the door, please close the door 1006 * behind you. 1007 */ 1008 1009 busy = 0; 1010 1011 1012 /* 1013 * Find the scsi_device associated with the SCSI address, 1014 * and mark it as changed, invalidating the cache. This deals 1015 * with changes to existing device IDs. 1016 */ 1017 1018 if (!dev || !dev->scsi_host_ptr) 1019 return; 1020 /* 1021 * force reload of disk info via aac_probe_container 1022 */ 1023 if ((device_config_needed == CHANGE) 1024 && (dev->fsa_dev[container].valid == 1)) 1025 dev->fsa_dev[container].valid = 2; 1026 if ((device_config_needed == CHANGE) || 1027 (device_config_needed == ADD)) 1028 aac_probe_container(dev, container); 1029 device = scsi_device_lookup(dev->scsi_host_ptr, 1030 CONTAINER_TO_CHANNEL(container), 1031 CONTAINER_TO_ID(container), 1032 CONTAINER_TO_LUN(container)); 1033 if (device) { 1034 switch (device_config_needed) { 1035 case DELETE: 1036 scsi_remove_device(device); 1037 break; 1038 case CHANGE: 1039 if (!dev->fsa_dev[container].valid) { 1040 scsi_remove_device(device); 1041 break; 1042 } 1043 scsi_rescan_device(&device->sdev_gendev); 1044 1045 default: 1046 break; 1047 } 1048 scsi_device_put(device); 1049 } 1050 if (device_config_needed == ADD) { 1051 scsi_add_device(dev->scsi_host_ptr, 1052 CONTAINER_TO_CHANNEL(container), 1053 CONTAINER_TO_ID(container), 1054 CONTAINER_TO_LUN(container)); 1055 } 1056 1057} 1058 1059static int _aac_reset_adapter(struct aac_dev *aac) 1060{ 1061 int index, quirks; 1062 u32 ret; 1063 int retval; 1064 struct Scsi_Host *host; 1065 struct scsi_device *dev; 1066 struct scsi_cmnd *command; 1067 struct scsi_cmnd *command_list; 1068 1069 /* 1070 * Assumptions: 1071 * - host is locked. 1072 * - in_reset is asserted, so no new i/o is getting to the 1073 * card. 1074 * - The card is dead. 1075 */ 1076 host = aac->scsi_host_ptr; 1077 scsi_block_requests(host); 1078 aac_adapter_disable_int(aac); 1079 spin_unlock_irq(host->host_lock); 1080 kthread_stop(aac->thread); 1081 1082 /* 1083 * If a positive health, means in a known DEAD PANIC 1084 * state and the adapter could be reset to `try again'. 1085 */ 1086 retval = aac_adapter_check_health(aac); 1087 if (retval == 0) 1088 retval = aac_adapter_sync_cmd(aac, IOP_RESET_ALWAYS, 1089 0, 0, 0, 0, 0, 0, &ret, NULL, NULL, NULL, NULL); 1090 if (retval) 1091 retval = aac_adapter_sync_cmd(aac, IOP_RESET, 1092 0, 0, 0, 0, 0, 0, &ret, NULL, NULL, NULL, NULL); 1093 1094 if (retval) 1095 goto out; 1096 if (ret != 0x00000001) { 1097 retval = -ENODEV; 1098 goto out; 1099 } 1100 1101 index = aac->cardtype; 1102 1103 /* 1104 * Re-initialize the adapter, first free resources, then carefully 1105 * apply the initialization sequence to come back again. Only risk 1106 * is a change in Firmware dropping cache, it is assumed the caller 1107 * will ensure that i/o is queisced and the card is flushed in that 1108 * case. 1109 */ 1110 aac_fib_map_free(aac); 1111 aac->hw_fib_va = NULL; 1112 aac->hw_fib_pa = 0; 1113 pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys); 1114 aac->comm_addr = NULL; 1115 aac->comm_phys = 0; 1116 kfree(aac->queues); 1117 aac->queues = NULL; 1118 free_irq(aac->pdev->irq, aac); 1119 kfree(aac->fsa_dev); 1120 aac->fsa_dev = NULL; 1121 if (aac_get_driver_ident(index)->quirks & AAC_QUIRK_31BIT) { 1122 if (((retval = pci_set_dma_mask(aac->pdev, DMA_32BIT_MASK))) || 1123 ((retval = pci_set_consistent_dma_mask(aac->pdev, DMA_32BIT_MASK)))) 1124 goto out; 1125 } else { 1126 if (((retval = pci_set_dma_mask(aac->pdev, 0x7FFFFFFFULL))) || 1127 ((retval = pci_set_consistent_dma_mask(aac->pdev, 0x7FFFFFFFULL)))) 1128 goto out; 1129 } 1130 if ((retval = (*(aac_get_driver_ident(index)->init))(aac))) 1131 goto out; 1132 if (aac_get_driver_ident(index)->quirks & AAC_QUIRK_31BIT) 1133 if ((retval = pci_set_dma_mask(aac->pdev, DMA_32BIT_MASK))) 1134 goto out; 1135 aac->thread = kthread_run(aac_command_thread, aac, aac->name); 1136 if (IS_ERR(aac->thread)) { 1137 retval = PTR_ERR(aac->thread); 1138 goto out; 1139 } 1140 (void)aac_get_adapter_info(aac); 1141 quirks = aac_get_driver_ident(index)->quirks; 1142 if ((quirks & AAC_QUIRK_34SG) && (host->sg_tablesize > 34)) { 1143 host->sg_tablesize = 34; 1144 host->max_sectors = (host->sg_tablesize * 8) + 112; 1145 } 1146 if ((quirks & AAC_QUIRK_17SG) && (host->sg_tablesize > 17)) { 1147 host->sg_tablesize = 17; 1148 host->max_sectors = (host->sg_tablesize * 8) + 112; 1149 } 1150 aac_get_config_status(aac, 1); 1151 aac_get_containers(aac); 1152 /* 1153 * This is where the assumption that the Adapter is quiesced 1154 * is important. 1155 */ 1156 command_list = NULL; 1157 __shost_for_each_device(dev, host) { 1158 unsigned long flags; 1159 spin_lock_irqsave(&dev->list_lock, flags); 1160 list_for_each_entry(command, &dev->cmd_list, list) 1161 if (command->SCp.phase == AAC_OWNER_FIRMWARE) { 1162 command->SCp.buffer = (struct scatterlist *)command_list; 1163 command_list = command; 1164 } 1165 spin_unlock_irqrestore(&dev->list_lock, flags); 1166 } 1167 while ((command = command_list)) { 1168 command_list = (struct scsi_cmnd *)command->SCp.buffer; 1169 command->SCp.buffer = NULL; 1170 command->result = DID_OK << 16 1171 | COMMAND_COMPLETE << 8 1172 | SAM_STAT_TASK_SET_FULL; 1173 command->SCp.phase = AAC_OWNER_ERROR_HANDLER; 1174 command->scsi_done(command); 1175 } 1176 retval = 0; 1177 1178out: 1179 aac->in_reset = 0; 1180 scsi_unblock_requests(host); 1181 spin_lock_irq(host->host_lock); 1182 return retval; 1183} 1184 1185int aac_check_health(struct aac_dev * aac) 1186{ 1187 int BlinkLED; 1188 unsigned long time_now, flagv = 0; 1189 struct list_head * entry; 1190 struct Scsi_Host * host; 1191 1192 /* Extending the scope of fib_lock slightly to protect aac->in_reset */ 1193 if (spin_trylock_irqsave(&aac->fib_lock, flagv) == 0) 1194 return 0; 1195 1196 if (aac->in_reset || !(BlinkLED = aac_adapter_check_health(aac))) { 1197 spin_unlock_irqrestore(&aac->fib_lock, flagv); 1198 return 0; /* OK */ 1199 } 1200 1201 aac->in_reset = 1; 1202 1203 /* Fake up an AIF: 1204 * aac_aifcmd.command = AifCmdEventNotify = 1 1205 * aac_aifcmd.seqnum = 0xFFFFFFFF 1206 * aac_aifcmd.data[0] = AifEnExpEvent = 23 1207 * aac_aifcmd.data[1] = AifExeFirmwarePanic = 3 1208 * aac.aifcmd.data[2] = AifHighPriority = 3 1209 * aac.aifcmd.data[3] = BlinkLED 1210 */ 1211 1212 time_now = jiffies/HZ; 1213 entry = aac->fib_list.next; 1214 1215 /* 1216 * For each Context that is on the 1217 * fibctxList, make a copy of the 1218 * fib, and then set the event to wake up the 1219 * thread that is waiting for it. 1220 */ 1221 while (entry != &aac->fib_list) { 1222 /* 1223 * Extract the fibctx 1224 */ 1225 struct aac_fib_context *fibctx = list_entry(entry, struct aac_fib_context, next); 1226 struct hw_fib * hw_fib; 1227 struct fib * fib; 1228 /* 1229 * Check if the queue is getting 1230 * backlogged 1231 */ 1232 if (fibctx->count > 20) { 1233 /* 1234 * It's *not* jiffies folks, 1235 * but jiffies / HZ, so do not 1236 * panic ... 1237 */ 1238 u32 time_last = fibctx->jiffies; 1239 /* 1240 * Has it been > 2 minutes 1241 * since the last read off 1242 * the queue? 1243 */ 1244 if ((time_now - time_last) > aif_timeout) { 1245 entry = entry->next; 1246 aac_close_fib_context(aac, fibctx); 1247 continue; 1248 } 1249 } 1250 /* 1251 * Warning: no sleep allowed while 1252 * holding spinlock 1253 */ 1254 hw_fib = kmalloc(sizeof(struct hw_fib), GFP_ATOMIC); 1255 fib = kmalloc(sizeof(struct fib), GFP_ATOMIC); 1256 if (fib && hw_fib) { 1257 struct aac_aifcmd * aif; 1258 1259 memset(hw_fib, 0, sizeof(struct hw_fib)); 1260 memset(fib, 0, sizeof(struct fib)); 1261 fib->hw_fib = hw_fib; 1262 fib->dev = aac; 1263 aac_fib_init(fib); 1264 fib->type = FSAFS_NTC_FIB_CONTEXT; 1265 fib->size = sizeof (struct fib); 1266 fib->data = hw_fib->data; 1267 aif = (struct aac_aifcmd *)hw_fib->data; 1268 aif->command = cpu_to_le32(AifCmdEventNotify); 1269 aif->seqnum = cpu_to_le32(0xFFFFFFFF); 1270 aif->data[0] = cpu_to_le32(AifEnExpEvent); 1271 aif->data[1] = cpu_to_le32(AifExeFirmwarePanic); 1272 aif->data[2] = cpu_to_le32(AifHighPriority); 1273 aif->data[3] = cpu_to_le32(BlinkLED); 1274 1275 /* 1276 * Put the FIB onto the 1277 * fibctx's fibs 1278 */ 1279 list_add_tail(&fib->fiblink, &fibctx->fib_list); 1280 fibctx->count++; 1281 /* 1282 * Set the event to wake up the 1283 * thread that will waiting. 1284 */ 1285 up(&fibctx->wait_sem); 1286 } else { 1287 printk(KERN_WARNING "aifd: didn't allocate NewFib.\n"); 1288 kfree(fib); 1289 kfree(hw_fib); 1290 } 1291 entry = entry->next; 1292 } 1293 1294 spin_unlock_irqrestore(&aac->fib_lock, flagv); 1295 1296 if (BlinkLED < 0) { 1297 printk(KERN_ERR "%s: Host adapter dead %d\n", aac->name, BlinkLED); 1298 goto out; 1299 } 1300 1301 printk(KERN_ERR "%s: Host adapter BLINK LED 0x%x\n", aac->name, BlinkLED); 1302 1303 host = aac->scsi_host_ptr; 1304 spin_lock_irqsave(host->host_lock, flagv); 1305 BlinkLED = _aac_reset_adapter(aac); 1306 spin_unlock_irqrestore(host->host_lock, flagv); 1307 return BlinkLED; 1308 1309out: 1310 aac->in_reset = 0; 1311 return BlinkLED; 1312} 1313 1314 1315/** 1316 * aac_command_thread - command processing thread 1317 * @dev: Adapter to monitor 1318 * 1319 * Waits on the commandready event in it's queue. When the event gets set 1320 * it will pull FIBs off it's queue. It will continue to pull FIBs off 1321 * until the queue is empty. When the queue is empty it will wait for 1322 * more FIBs. 1323 */ 1324 1325int aac_command_thread(void *data) 1326{ 1327 struct aac_dev *dev = data; 1328 struct hw_fib *hw_fib, *hw_newfib; 1329 struct fib *fib, *newfib; 1330 struct aac_fib_context *fibctx; 1331 unsigned long flags; 1332 DECLARE_WAITQUEUE(wait, current); 1333 1334 /* 1335 * We can only have one thread per adapter for AIF's. 1336 */ 1337 if (dev->aif_thread) 1338 return -EINVAL; 1339 1340 /* 1341 * Let the DPC know it has a place to send the AIF's to. 1342 */ 1343 dev->aif_thread = 1; 1344 add_wait_queue(&dev->queues->queue[HostNormCmdQueue].cmdready, &wait); 1345 set_current_state(TASK_INTERRUPTIBLE); 1346 dprintk ((KERN_INFO "aac_command_thread start\n")); 1347 while(1) 1348 { 1349 spin_lock_irqsave(dev->queues->queue[HostNormCmdQueue].lock, flags); 1350 while(!list_empty(&(dev->queues->queue[HostNormCmdQueue].cmdq))) { 1351 struct list_head *entry; 1352 struct aac_aifcmd * aifcmd; 1353 1354 set_current_state(TASK_RUNNING); 1355 1356 entry = dev->queues->queue[HostNormCmdQueue].cmdq.next; 1357 list_del(entry); 1358 1359 spin_unlock_irqrestore(dev->queues->queue[HostNormCmdQueue].lock, flags); 1360 fib = list_entry(entry, struct fib, fiblink); 1361 /* 1362 * We will process the FIB here or pass it to a 1363 * worker thread that is TBD. We Really can't 1364 * do anything at this point since we don't have 1365 * anything defined for this thread to do. 1366 */ 1367 hw_fib = fib->hw_fib; 1368 memset(fib, 0, sizeof(struct fib)); 1369 fib->type = FSAFS_NTC_FIB_CONTEXT; 1370 fib->size = sizeof( struct fib ); 1371 fib->hw_fib = hw_fib; 1372 fib->data = hw_fib->data; 1373 fib->dev = dev; 1374 /* 1375 * We only handle AifRequest fibs from the adapter. 1376 */ 1377 aifcmd = (struct aac_aifcmd *) hw_fib->data; 1378 if (aifcmd->command == cpu_to_le32(AifCmdDriverNotify)) { 1379 /* Handle Driver Notify Events */ 1380 aac_handle_aif(dev, fib); 1381 *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK); 1382 aac_fib_adapter_complete(fib, (u16)sizeof(u32)); 1383 } else { 1384 struct list_head *entry; 1385 /* The u32 here is important and intended. We are using 1386 32bit wrapping time to fit the adapter field */ 1387 1388 u32 time_now, time_last; 1389 unsigned long flagv; 1390 unsigned num; 1391 struct hw_fib ** hw_fib_pool, ** hw_fib_p; 1392 struct fib ** fib_pool, ** fib_p; 1393 1394 /* Sniff events */ 1395 if ((aifcmd->command == 1396 cpu_to_le32(AifCmdEventNotify)) || 1397 (aifcmd->command == 1398 cpu_to_le32(AifCmdJobProgress))) { 1399 aac_handle_aif(dev, fib); 1400 } 1401 1402 time_now = jiffies/HZ; 1403 1404 /* 1405 * Warning: no sleep allowed while 1406 * holding spinlock. We take the estimate 1407 * and pre-allocate a set of fibs outside the 1408 * lock. 1409 */ 1410 num = le32_to_cpu(dev->init->AdapterFibsSize) 1411 / sizeof(struct hw_fib); /* some extra */ 1412 spin_lock_irqsave(&dev->fib_lock, flagv); 1413 entry = dev->fib_list.next; 1414 while (entry != &dev->fib_list) { 1415 entry = entry->next; 1416 ++num; 1417 } 1418 spin_unlock_irqrestore(&dev->fib_lock, flagv); 1419 hw_fib_pool = NULL; 1420 fib_pool = NULL; 1421 if (num 1422 && ((hw_fib_pool = kmalloc(sizeof(struct hw_fib *) * num, GFP_KERNEL))) 1423 && ((fib_pool = kmalloc(sizeof(struct fib *) * num, GFP_KERNEL)))) { 1424 hw_fib_p = hw_fib_pool; 1425 fib_p = fib_pool; 1426 while (hw_fib_p < &hw_fib_pool[num]) { 1427 if (!(*(hw_fib_p++) = kmalloc(sizeof(struct hw_fib), GFP_KERNEL))) { 1428 --hw_fib_p; 1429 break; 1430 } 1431 if (!(*(fib_p++) = kmalloc(sizeof(struct fib), GFP_KERNEL))) { 1432 kfree(*(--hw_fib_p)); 1433 break; 1434 } 1435 } 1436 if ((num = hw_fib_p - hw_fib_pool) == 0) { 1437 kfree(fib_pool); 1438 fib_pool = NULL; 1439 kfree(hw_fib_pool); 1440 hw_fib_pool = NULL; 1441 } 1442 } else { 1443 kfree(hw_fib_pool); 1444 hw_fib_pool = NULL; 1445 } 1446 spin_lock_irqsave(&dev->fib_lock, flagv); 1447 entry = dev->fib_list.next; 1448 /* 1449 * For each Context that is on the 1450 * fibctxList, make a copy of the 1451 * fib, and then set the event to wake up the 1452 * thread that is waiting for it. 1453 */ 1454 hw_fib_p = hw_fib_pool; 1455 fib_p = fib_pool; 1456 while (entry != &dev->fib_list) { 1457 /* 1458 * Extract the fibctx 1459 */ 1460 fibctx = list_entry(entry, struct aac_fib_context, next); 1461 /* 1462 * Check if the queue is getting 1463 * backlogged 1464 */ 1465 if (fibctx->count > 20) 1466 { 1467 /* 1468 * It's *not* jiffies folks, 1469 * but jiffies / HZ so do not 1470 * panic ... 1471 */ 1472 time_last = fibctx->jiffies; 1473 /* 1474 * Has it been > 2 minutes 1475 * since the last read off 1476 * the queue? 1477 */ 1478 if ((time_now - time_last) > aif_timeout) { 1479 entry = entry->next; 1480 aac_close_fib_context(dev, fibctx); 1481 continue; 1482 } 1483 } 1484 /* 1485 * Warning: no sleep allowed while 1486 * holding spinlock 1487 */ 1488 if (hw_fib_p < &hw_fib_pool[num]) { 1489 hw_newfib = *hw_fib_p; 1490 *(hw_fib_p++) = NULL; 1491 newfib = *fib_p; 1492 *(fib_p++) = NULL; 1493 /* 1494 * Make the copy of the FIB 1495 */ 1496 memcpy(hw_newfib, hw_fib, sizeof(struct hw_fib)); 1497 memcpy(newfib, fib, sizeof(struct fib)); 1498 newfib->hw_fib = hw_newfib; 1499 /* 1500 * Put the FIB onto the 1501 * fibctx's fibs 1502 */ 1503 list_add_tail(&newfib->fiblink, &fibctx->fib_list); 1504 fibctx->count++; 1505 /* 1506 * Set the event to wake up the 1507 * thread that is waiting. 1508 */ 1509 up(&fibctx->wait_sem); 1510 } else { 1511 printk(KERN_WARNING "aifd: didn't allocate NewFib.\n"); 1512 } 1513 entry = entry->next; 1514 } 1515 /* 1516 * Set the status of this FIB 1517 */ 1518 *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK); 1519 aac_fib_adapter_complete(fib, sizeof(u32)); 1520 spin_unlock_irqrestore(&dev->fib_lock, flagv); 1521 /* Free up the remaining resources */ 1522 hw_fib_p = hw_fib_pool; 1523 fib_p = fib_pool; 1524 while (hw_fib_p < &hw_fib_pool[num]) { 1525 kfree(*hw_fib_p); 1526 kfree(*fib_p); 1527 ++fib_p; 1528 ++hw_fib_p; 1529 } 1530 kfree(hw_fib_pool); 1531 kfree(fib_pool); 1532 } 1533 kfree(fib); 1534 spin_lock_irqsave(dev->queues->queue[HostNormCmdQueue].lock, flags); 1535 } 1536 /* 1537 * There are no more AIF's 1538 */ 1539 spin_unlock_irqrestore(dev->queues->queue[HostNormCmdQueue].lock, flags); 1540 schedule(); 1541 1542 if (kthread_should_stop()) 1543 break; 1544 set_current_state(TASK_INTERRUPTIBLE); 1545 } 1546 if (dev->queues) 1547 remove_wait_queue(&dev->queues->queue[HostNormCmdQueue].cmdready, &wait); 1548 dev->aif_thread = 0; 1549 return 0; 1550} 1551